diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 2165ad74..b53ca9ca 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -221,7 +221,7 @@ def _print_warnings(self): phase = df.loc[idx, "phase"] print(f"{phase}:\n\t {msg}") - except: + except: # noqa: E722 pass @property @@ -365,7 +365,7 @@ def compile_input_dict(cls, phases): " commissioning_factor)" ), "construction_insurance_factor": ( - "float (optional, default: 0.0115)" + "float (optional, default: 0.0207)" ), "construction_financing_factor": ( "$/kW (optional, default: value calculated using" @@ -379,7 +379,7 @@ def compile_input_dict(cls, phases): ), "tax_rate": "float (optional, default: 0.26", "interest_during_construction": ( - "float (optional, default: 0.044" + "float (optional, default: 0.065" ), "procurement_contingency_factor": ( "float (optional, default: 0.0575)" @@ -387,12 +387,12 @@ def compile_input_dict(cls, phases): "installation_contingency_factor": ( "float (optional, default: 0.345)" ), - "decommissioning_factor": ("float (optional, default: 0.1725)"), + "decommissioning_factor": ("float (optional, default: 0.2)"), "commissioning_factor": "float (optional, default: 0.0115)", - "site_auction_price": "$ (optional, default: 100e6)", - "site_assessment_cost": "$ (optional, default: 50e6)", - "construction_plan_cost": "$ (optional, default: 1e6)", - "installation_plan_cost": "$ (optional, default: 0.25e6)", + "site_auction_price": "$ (optional, default: 105e6)", + "site_assessment_cost": "$ (optional, default: 200e6)", + "construction_plan_cost": "$ (optional, default: 25e6)", + "installation_plan_cost": "$ (optional, default: 25e6)", } config["design_phases"] = [*design_phases.keys()] @@ -670,7 +670,7 @@ def run_install_phase(self, name, start, **kwargs): if phase.installation_capex: self.installation_costs[name] = phase.installation_capex - + return time, logs def get_phase_class(self, phase): @@ -747,6 +747,8 @@ def run_design_phase(self, name, **kwargs): self.detailed_outputs, phase.detailed_output ) + + def run_multiple_phases_in_serial(self, phase_list, **kwargs): """ Runs multiple phases listed in self.config['install_phases'] in serial. @@ -1052,6 +1054,10 @@ def outputs(self, include_logs=False, npv_detailed=False): "total_capex": self.total_capex, "total_capex_per_kw": self.total_capex_per_kw, "npv": self.npv, + "supply_chain_capex": self.supply_chain_capex, + "supply_chain_capex_kw": self.supply_chain_capex_per_kw, + "onshore_substation_capex": self.onshore_substation_capex, + "onshore_substation_capex_kw": self.onshore_substation_capex_per_kw, } if include_logs: @@ -1440,12 +1446,17 @@ def capex_breakdown(self): else: outputs[name] = cost + outputs["Onshore Substation"] = self.onshore_substation_capex + outputs["Turbine"] = self.turbine_capex outputs["Soft"] = self.soft_capex outputs["Project"] = self.project_capex + if self.supply_chain_capex > 0: + outputs["Supply Chain"] = self.supply_chain_capex + return outputs @property @@ -1486,7 +1497,7 @@ def capex_detailed_soft_capex_breakdown_per_kw(self): def bos_capex(self): """Returns total balance of system CapEx.""" - return self.system_capex + self.installation_capex + return self.system_capex + self.installation_capex + self.onshore_substation_capex @property def bos_capex_per_kw(self): @@ -1526,6 +1537,58 @@ def turbine_capex_per_kw(self): _capex = self.project_params.get("turbine_capex", 1300) return _capex + @property + def supply_chain_capex(self): + """Returns the supply chain CapEx. This parameter includes any + project-level investments in supply chain development, port upgrades, + community benefit agreements, fisheries mitigation funds, community or + research initiatives, and U.S.-built vessels. + """ + + _capex = self.project_params.get("supply_chain_capex", 0) + + try: + num_turbines = self.config["plant"]["num_turbines"] + rating = self.config["turbine"]["turbine_rating"] + + except KeyError: + pass + + return _capex * num_turbines * rating * 1000 + + @property + def supply_chain_capex_per_kw(self): + """Returns the supply chain CapEx/kW. This parameter includes any + project-level investments in supply chain development, port upgrades, + community benefit agreements, fisheries mitigation funds, community or + research initiatives, and U.S.-built vessels. + """ + + _capex = self.project_params.get("supply_chain_capex", 0) + + return _capex + + @property + def onshore_substation_capex(self): + """Returns the onshore substation CapEx if available in 'ElectricalDesign', otherwise 0.""" + if "ElectricalDesign" in self.phases: + try: + return self.phases["ElectricalDesign"].detailed_output["export_system"]["onshore_substation_costs"] + except KeyError: + return 0 + return 0 + + @property + def onshore_substation_capex_per_kw(self): + """Returns the onshore substation CapEx/kW. + """ + if "ElectricalDesign" in self.phases: + try: + return self.onshore_substation_capex / (self.capacity * 1000) + except KeyError: + return None + return None + @property def overnight_capex(self): """Returns the overnight capital cost of the project.""" @@ -1580,7 +1643,7 @@ def construction_insurance_capex(self): ) contruction_insurance_factor = self.project_params.get( - "construction_insurance_factor", 0.0115 + "construction_insurance_factor", 0.0207 ) if construction_insurance_per_kW is not None: @@ -1606,7 +1669,7 @@ def decommissioning_capex(self): ) decommissioning_factor = self.project_params.get( - "decommissioning_factor", 0.175 + "decommissioning_factor", 0.2 ) if decommissioning_per_kW is not None: @@ -1624,18 +1687,14 @@ def commissioning_capex(self): Energy Review. """ - commissioning_per_kW = self.project_params.get( - "commissioning", None - ) + commissioning_per_kW = self.project_params.get("commissioning", None) commissioning_factor = self.project_params.get( "commissioning_factor", 0.0115 ) if commissioning_per_kW is not None: - commissioning = ( - commissioning_per_kW * self.capacity * 1000 - ) + commissioning = commissioning_per_kW * self.capacity * 1000 else: commissioning = ( @@ -1715,7 +1774,7 @@ def construction_financing_factor(self): ) tax_rate = self.project_params.get("tax_rate", 0.26) interest_during_construction = self.project_params.get( - "interest_during_construction", 0.044 + "interest_during_construction", 0.065 ) _check = 0 @@ -1764,6 +1823,7 @@ def construction_financing_capex(self): + self.installation_contingency_capex() + self.bos_capex + self.turbine_capex + + self.supply_chain_capex ) * (construction_financing_factor - 1) return construction_financing @@ -1775,13 +1835,15 @@ def project_capex(self): the keys below should be passed to the 'project_parameters' subdict. """ - site_auction = self.project_params.get("site_auction_price", 122698898) - site_assessment = self.project_params.get("site_assessment_cost", 61349449) + site_auction = self.project_params.get("site_auction_price", 105000000) + site_assessment = self.project_params.get( + "site_assessment_cost", 200000000 + ) construction_plan = self.project_params.get( - "construction_plan_cost", 1226989 + "construction_plan_cost", 25000000 ) installation_plan = self.project_params.get( - "installation_plan_cost", 306747 + "installation_plan_cost", 25000000 ) return sum( @@ -1814,6 +1876,7 @@ def total_capex(self): + self.turbine_capex + self.soft_capex + self.project_capex + + self.supply_chain_capex ) @property diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 53285399..0e401bab 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -11,10 +11,6 @@ import numpy as np import pandas as pd -try: - import matplotlib.pyplot as plt -except ModuleNotFoundError: - pass from ORBIT.core.library import export_library_specs, extract_library_specs from ORBIT.core.exceptions import LibraryItemNotFoundError @@ -365,36 +361,15 @@ def run(self): self._create_wind_farm_layout() self._create_cable_section_lengths() - def save_layout(self, save_name, return_df=False, folder="cables"): - """Outputs a csv of the substation and turbine positional and cable - related components. - - Parameters - ---------- - save_name : str - The name of the file without an extension to be saved to - /cables/.csv. - return_df : bool, optional - If true, returns layout_df, a pandas.DataFrame of the cabling - layout, by default False. - folder : str, optional - If "cables", then the layout will saved to the "cables" folder, and - if "plant", then the layout will be saved to the "project/plant" - folder. + def create_layout_df(self) -> pd.DataFrame: + """Creates a Pandas DataFrame layout. Returns ------- pd.DataFrame - The DataFrame with the layout data. - - Raises - ------ - ValueError - Raised if ``folder`` is not one of "cables" or "plant". + Wind farm layout compatible with the ``CustomArrayDesignLayout`` or + for use with external models. """ - if folder not in ("cables", "plant"): - raise ValueError("`folder` must be one of: 'cables' or plant'.") - num_turbines = self.system.num_turbines columns = [ "id", @@ -437,7 +412,13 @@ def save_layout(self, save_name, return_df=False, folder="cables"): coords = np.array( [[0, 0]] - + list(zip(self.turbines_x.flatten(), self.turbines_y.flatten())) + + list( + zip( + self.turbines_x.flatten(), + self.turbines_y.flatten(), + strict=False, + ) + ) ) coords = coords[: self.system.num_turbines + 1] layout_df[["longitude", "latitude"]] = coords @@ -458,9 +439,42 @@ def save_layout(self, save_name, return_df=False, folder="cables"): layout_df.cable_length = [""] + self.sections_cable_lengths.flatten()[ :num_turbines ].tolist() - data = [columns] + layout_df.to_numpy().tolist() + return layout_df + + def save_layout(self, save_name, return_df=False, folder="cables"): + """Outputs a csv of the substation and turbine positional and cable + related components. + + Parameters + ---------- + save_name : str + The name of the file without an extension to be saved to + /cables/.csv. + return_df : bool, optional + If true, returns layout_df, a pandas.DataFrame of the cabling + layout, by default False. + folder : str, optional + If "cables", then the layout will saved to the "cables" folder, and + if "plant", then the layout will be saved to the "project/plant" + folder. + + Returns + ------- + pd.DataFrame + The DataFrame with the layout data. + + Raises + ------ + ValueError + Raised if ``folder`` is not one of "cables" or "plant". + """ + if folder not in ("cables", "plant"): + raise ValueError("`folder` must be one of: 'cables' or plant'.") + + layout_df = self.create_layout_df() + data = [layout_df.columns] + layout_df.to_numpy().tolist() print( - f"Saving custom array CSV to: /cables/{save_name}.csv" # noqa: E501 + f"Saving custom array CSV to: /{folder}/{save_name}.csv" # noqa: E501 ) export_library_specs(folder, save_name, data, file_ext="csv") if return_df: @@ -543,6 +557,14 @@ def plot_array_system( settings, and can be manipulated to add annotations, or other elements. """ + try: + import matplotlib.pyplot as plt + except ModuleNotFoundError as err: + msg = ( + "Please install ORBIT with the `plot` option or install" + " `matplotlib` manually." + ) + raise ModuleNotFoundError(msg) from err fig, ax = plt.subplots(figsize=(10, 10)) plt.axis("off") @@ -559,27 +581,12 @@ def plot_array_system( zorder=2, label="Turbine", ) - # Plot the turbine names - # for i in range(self.coordinates.shape[0]): - # for j in range(self.coordinates.shape[1] - 1): - # if not np.any(np.isnan(self.coordinates[i, j + 1])): - # x, y = self.coordinates[i, j + 1] - # name = self.location_data.loc[ - # (self.location_data.string == i) - # & (self.location_data.order == j), - # "turbine_name" - # ].to_numpy()[0] - # ax.text(x, y, name) - # Determine the cable section widths - string_sets = np.unique( - [ - list( - OrderedDict.fromkeys(el for el in cables if el is not None) - ) - for cables in self.sections_cables - ] - ) + string_sets = { + tuple(OrderedDict.fromkeys(el for el in cables if el is not None)) + for cables in self.sections_cables + } + string_sets = [list(el) for el in string_sets] if isinstance(string_sets[0], list): max_string = max(string_sets, key=len) else: @@ -587,7 +594,7 @@ def plot_array_system( string_widths = np.arange(len(max_string), 0, -1, dtype=float).tolist() for i, row in enumerate(self.sections_cables): - for cable, width in zip(max_string, string_widths): + for cable, width in zip(max_string, string_widths, strict=False): ix_to_plot = np.where(row == cable)[0] if ix_to_plot.size == 0: @@ -661,7 +668,7 @@ class CustomArraySystemDesign(ArraySystemDesign): expected_config = { "site": {"depth": "str"}, - "plant": {"layout": "str", "num_turbines": "int"}, + "plant": {"layout": "str | pd.DataFrame", "num_turbines": "int"}, "turbine": {"turbine_rating": "int | float"}, "array_system_design": { "cables": "list | str", @@ -868,18 +875,26 @@ def _format_windfarm_data(self): def _initialize_custom_data(self): windfarm = self.config["array_system_design"]["location_data"] - try: - self.location_data = extract_library_specs( - "cables", - windfarm, - file_type="csv", - ) - except LibraryItemNotFoundError: - self.location_data = extract_library_specs( - "plant", - windfarm, - file_type="csv", + if isinstance(windfarm, str): + try: + self.location_data = extract_library_specs( + "cables", + windfarm, + file_type="csv", + ) + except LibraryItemNotFoundError: + self.location_data = extract_library_specs( + "plant", + windfarm, + file_type="csv", + ) + elif isinstance(windfarm, pd.DataFrame): + self.location_data = windfarm + else: + raise ValueError( + "`location_data` must be a filename or DataFrame." ) + # Make sure no data is missing missing = set(self.COLUMNS).difference(self.location_data.columns) if missing: @@ -887,7 +902,6 @@ def _initialize_custom_data(self): "The following columns must be included in the location " f"data: {missing}", ) - self._format_windfarm_data() # Ensure there is no missing data in required columns @@ -940,7 +954,8 @@ def _initialize_custom_data(self): if longest_string > self.num_turbines_full_string: raise ValueError( "Strings can't contain more than " - f"{self.num_turbines_full_string} turbines." + f"{self.num_turbines_full_string} turbines. Reduce the number" + " of turbines or select a cable with higher current capacity." ) else: self.num_turbines_full_string = longest_string @@ -1108,6 +1123,7 @@ def cable_lengths_by_type_speed(self): zip( self.sections_cable_lengths[self.sections_cables == name], self.sections_bury_speeds[self.sections_cables == name], + strict=False, ) ) for name in self.cables diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index ce59c373..63b2a349 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -28,6 +28,7 @@ class GravityBasedInstallation(InstallPhase): #: expected_config = { "support_vessel": "str, (optional)", + "wtiv": "str, (optional)", "ahts_vessel": "str", "towing_vessel": "str", "towing_vessel_groups": { @@ -81,11 +82,15 @@ def setup_simulation(self, **kwargs): self.initialize_port() self.initialize_substructure_production() - self.initialize_turbine_assembly() + + if "wtiv" not in self.config: + self.initialize_turbine_assembly() + self.initialize_queue() self.initialize_towing_groups() self.initialize_support_vessel() - + + @property def system_capex(self): """Returns total procurement cost of the substructures.""" @@ -137,8 +142,19 @@ def initialize_substructure_production(self): self.env.register(a) a.start() + + if "wtiv" in self.config: + self.env.process(self.forward_substructures_to_assembly_storage(a)) + self.sub_assembly_lines.append(a) + try: + storage = self.config["port"]["assembly_storage"] + except KeyError: + storage = float("inf") + + self.assembly_storage = WetStorage(self.env, storage) + def initialize_turbine_assembly(self): """ Initializes turbine assembly lines. @@ -149,14 +165,6 @@ def initialize_turbine_assembly(self): - self.config["port"]["turb_assembly_lines"] """ - try: - storage = self.config["port"]["assembly_storage"] - - except KeyError: - storage = float("inf") - - self.assembly_storage = WetStorage(self.env, storage) - try: lines = self.config["port"]["turbine_assembly_cranes"] @@ -172,10 +180,10 @@ def initialize_turbine_assembly(self): turbine, i + 1, ) - self.env.register(a) a.start() self.turbine_assembly_lines.append(a) + def initialize_towing_groups(self, **kwargs): """ @@ -275,24 +283,30 @@ def initialize_support_vessel(self, **kwargs): def detailed_output(self): """Compiles the detailed installation phase outputs.""" + # Start with the base operational delays + delays = { + k: self.operational_delay(str(k)) + for k in self.sub_assembly_lines + } + + # Add turbine assembly lines only if "wtiv" not in config + if "wtiv" not in self.config: + delays.update({ + k: self.operational_delay(str(k)) + for k in self.turbine_assembly_lines + }) + + # Add installation groups + delays.update({ + k: self.operational_delay(str(k)) + for k in self.installation_groups + }) + + # Add support vessel + delays[self.support_vessel] = self.operational_delay(str(self.support_vessel)) + return { - "operational_delays": { - **{ - k: self.operational_delay(str(k)) - for k in self.sub_assembly_lines - }, - **{ - k: self.operational_delay(str(k)) - for k in self.turbine_assembly_lines - }, - **{ - k: self.operational_delay(str(k)) - for k in self.installation_groups - }, - self.support_vessel: self.operational_delay( - str(self.support_vessel) - ), - }, + "operational_delays": delays } def operational_delay(self, name): @@ -303,7 +317,22 @@ def operational_delay(self, name): return delay - + def forward_substructures_to_assembly_storage(self, SubstructureAssemblyLine): + while True: + # Wait until there is both: + # - an item in wet_storage + # - room in assembly_storage + if len(self.assembly_storage.items) < self.assembly_storage.capacity: + item = yield self.wet_storage.get() + yield self.assembly_storage.put(item) + # submit action log item saying what happened "moved from wet to sub assembly storage" + SubstructureAssemblyLine.submit_action_log( + "Move GBF from Wet Storage to Assembly Storage", 0 + ) + else: + # Wait a short amount of time before trying again + yield self.env.timeout(0.001) + @process def transfer_gbf_substructures_from_storage( group, diff --git a/README.rst b/README.rst index 19aa43cd..dd424e52 100644 --- a/README.rst +++ b/README.rst @@ -68,6 +68,10 @@ Instructions # OR if you are you going to be contributing to the code or building documentation pip install -e '.[dev]' + + # OR if you wish to use native plotting tools + pip install -e '.[plot]' + 6. (Development only) Install the pre-commit hooks to autoformat and lint code. .. code-block:: console @@ -83,7 +87,6 @@ Dependencies - NumPy - Pandas - SciPy -- Matplotlib - OpenMDAO (>=3.2) - python-benedict - statsmodels @@ -101,6 +104,9 @@ Development Specific - sphinx - sphinx-rtd-theme +Optional Plotting +~~~~~~~~~~~~~~~~~ +- matplotlib Recommended packages for easy iteration and running of code: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index e3066047..d150de16 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -2,6 +2,33 @@ ORBIT Changelog =============== + +Unreleased +---------- +- Allow for a Pandas DataFrame to be passed directly to the ``CustomArraySystemDesign.layout_data`` + configuration input. +- Move the matplotlib import from the import section of ``/ORBIT/phases/design/array_system_design.py`` + to the ``CustomArraySystemDesign.plot_array_system`` for missing module error handling. +- Adds a general layout ``DataFrame`` creation method as ``ArraySystemDesign.create_layout_df()`` that + is called by the ``save_layout`` method to maintain backwards compatibility, but opens up the ability + gather the layout without saving it to a file. +- Updated default `soft_capex` factors. `PR #201 `_ + - `construction_insurance_factor` updated from 0.115 to 0.0207 based on industry benchmarking, resulting in higher construction insurance costs. + - `interest_during_construction` updated from 4.4% to 6.5% based on financial assumptions from the 2025 Annual Technology Baseline (ATB), increasing construction financing costs. + - `decommissioning_factor` updated from 0.175 to 0.2 based on industry benchmarking, leading to higher decommissioning costs than in previous versions. +- Updated default `project_capex` values. `PR #201 `_ + - `site_auction_price` increased from 100M to 105M USD to account for rent fees before operation. + - `site_assessment_cost`, `construction_plan_cost`, and `installation_plan_cost` increased from 50M, 1M, and 0.25M USD to 200M, 25M, and 25M USD, respectively. + - Total `project_capex` excluding `site_auction_price` now sums to 250M USD, aligning with DevEx recommendations based on industry benchmarking. + - These updates lead to higher default total project costs than in previous versions. +- Included onshore substation costs in BOS CapEx and project breakdown. `PR #201 `_ + - The `ElectricalDesign` module previously calculated onshore substation costs but did not include them in `capex_breakdown` or `bos_capex`. + - These costs are now incorporated when `ElectricalDesign` is used, resulting in higher `bos_capex`, `soft_capex`, and `total_capex` than in prior versions. +- Cable configuration file updates. `PR #201 `_ + - Added a new dynamic cable configuration file for floating cases: `library/cables/XLPE_1200mm_220kV_dynamic.yaml`. + - Updated cost values for `library/cables/XLPE_630mm_66kV.yaml` and `library/cables/XLPE_630mm_66kV_dynamic.yaml` based on industry benchmarking. + - All cable cost updates are expressed in 2024 USD for consistency with other library configuration files. + 1.2.4 ----- - Support Python 3.14 diff --git a/docs/source/phases/design/api_ArraySystemDesign.rst b/docs/source/phases/design/api_ArraySystemDesign.rst index 816cdac0..d89817e2 100644 --- a/docs/source/phases/design/api_ArraySystemDesign.rst +++ b/docs/source/phases/design/api_ArraySystemDesign.rst @@ -6,3 +6,6 @@ For detailed methodology, please see .. autoclass:: ORBIT.phases.design.ArraySystemDesign :members: + +.. autoclass:: ORBIT.phases.design.CustomArraySystemDesign + :members: diff --git a/examples/Example - Custom Array Layout.ipynb b/examples/Example - Custom Array Layout.ipynb index d4932564..2aa16af0 100644 --- a/examples/Example - Custom Array Layout.ipynb +++ b/examples/Example - Custom Array Layout.ipynb @@ -10,9 +10,7 @@ "\n", "#### Author: Rob Hammond\n", "#### Date: 4 May 2020\n", - "#### Update: 30 March 2021\n", - "\n", - "\n", + "#### Update: 27 October 2025\n", "\n", "##### Data source: Dudgeon Wind Farm turbine locations from their publicly available [Call to Mariners](http://dudgeonoffshorewind.co.uk/news/notices/Dudgeon%20-%20Notice%20to%20Mariners%20wk25.pdf)\n", "\n", @@ -33,7 +31,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at '../library'\n" + "ORBIT library intialized at '/Users/rhammond/GitHub_Public/ORBIT/library'\n" ] } ], @@ -95,7 +93,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + "{'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", " 'location_data': 'dudgeon_array'},\n", " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", " 'site': {'depth': 20},\n", @@ -119,8 +119,8 @@ " 'array_system_design': {\n", " \n", " # A list of array cable YAML files that can be found in library/project/cables/ as\n", - " # XLPE_400mm_33kV.yaml and XLPE_630mm_33kV.yaml\n", - " 'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " # XLPE_400mm_33kV.yaml, XLPE_630mm_33kV.yaml, and XLPE_630mm_220kV.yaml\n", + " 'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV', 'XLPE_630mm_220kV'],\n", " \n", " # A YAML file named dudgeon_array.csv found in the same location\n", " 'location_data': 'dudgeon_array'},\n", @@ -150,45 +150,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'array_system_design': {'cables': {'XLPE_400mm_33kV': {'ac_resistance': 0.06,\n", - " 'capacitance': 225,\n", - " 'conductor_size': 400,\n", - " 'cost_per_km': 300000,\n", - " 'current_capacity': 600,\n", - " 'inductance': 0.375,\n", - " 'linear_density': 35,\n", - " 'name': 'XLPE_400mm_33kV',\n", - " 'rated_voltage': 33},\n", - " 'XLPE_630mm_33kV': {'ac_resistance': 0.04,\n", - " 'capacitance': 300,\n", - " 'conductor_size': 630,\n", - " 'cost_per_km': 450000,\n", - " 'current_capacity': 700,\n", - " 'inductance': 0.35,\n", - " 'linear_density': 42.5,\n", - " 'name': 'XLPE_630mm_33kV',\n", - " 'rated_voltage': 33}},\n", - " 'location_data': 'dudgeon_array'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': {'blade': {'deck_space': 100, 'length': 75, 'mass': 100},\n", - " 'hub_height': 110,\n", - " 'nacelle': {'deck_space': 200, 'mass': 360},\n", - " 'name': 'SWT-6MW-154',\n", - " 'rated_windspeed': 13,\n", - " 'rotor_diameter': 154,\n", - " 'tower': {'deck_space': 36,\n", - " 'length': 110,\n", - " 'mass': 150,\n", - " 'sections': 2},\n", - " 'turbine_rating': 6}}\n" + "{'array_system_design': {'cables': {'XLPE_400mm_33kV': {'ac_resistance': 0.06, 'capacitance': 225, 'conductor_size': 400, 'cost_per_km': 364352, 'current_capacity': 600, 'inductance': 0.375, 'linear_density': 35, 'name': 'XLPE_400mm_33kV', 'rated_voltage': 33}, 'XLPE_630mm_33kV': {'ac_resistance': 0.04, 'capacitance': 300, 'conductor_size': 630, 'cost_per_km': 546528, 'current_capacity': 700, 'inductance': 0.35, 'linear_density': 42.5, 'cable_type': 'HVAC', 'name': 'XLPE_630mm_33kV', 'rated_voltage': 33}, 'XLPE_630mm_220kV': {'ac_resistance': 0.25, 'capacitance': 160, 'conductor_size': 630, 'cost_per_km': 853557, 'current_capacity': 715, 'inductance': 0.41, 'linear_density': 96, 'rated_voltage': 220, 'cable_type': 'HVAC', 'name': 'XLPE_630mm_220kV'}}, 'location_data': 'dudgeon_array'}, 'plant': {'layout': 'custom', 'num_turbines': 67}, 'site': {'depth': 20}, 'turbine': {'blade': {'deck_space': 100, 'length': 75, 'mass': 100}, 'hub_height': 110, 'nacelle': {'deck_space': 200, 'mass': 360}, 'name': 'SWT-6MW-154', 'rotor_diameter': 154, 'tower': {'deck_space': 36, 'sections': 2, 'length': 110, 'mass': 150}, 'turbine_rating': 6, 'rated_windspeed': 13}}\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /Users/jnunemak/Fun/repos/ORBIT/ORBIT/phases/design/array_system_design.py:881\n", + "UserWarning: /Users/rhammond/GitHub_Public/ORBIT/ORBIT/phases/design/array_system_design.py:1088\n", "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." ] } @@ -265,10 +234,10 @@ " DAE_A1\n", " 1.358783\n", " 53.243950\n", - " 0\n", - " 0\n", - " 0\n", - " 0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 2\n", @@ -277,10 +246,10 @@ " DAD_A2\n", " 1.349033\n", " 53.248467\n", - " 0\n", - " 1\n", - " 0\n", - " 0\n", + " 0.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 3\n", @@ -289,10 +258,10 @@ " DAC_A3\n", " 1.339283\n", " 53.252983\n", - " 0\n", - " 2\n", - " 0\n", - " 0\n", + " 0.0\n", + " 2.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 4\n", @@ -301,10 +270,10 @@ " DAB_A4\n", " 1.329550\n", " 53.257500\n", - " 0\n", - " 3\n", - " 0\n", - " 0\n", + " 0.0\n", + " 3.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 5\n", @@ -313,10 +282,10 @@ " DAA_A5\n", " 1.319800\n", " 53.262017\n", - " 0\n", - " 4\n", - " 0\n", - " 0\n", + " 0.0\n", + " 4.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " ...\n", @@ -337,10 +306,10 @@ " DAF_L2\n", " 1.368533\n", " 53.239433\n", - " 11\n", - " 1\n", - " 0\n", - " 0\n", + " 11.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 60\n", @@ -349,10 +318,10 @@ " DAG_L3\n", " 1.378250\n", " 53.234917\n", - " 11\n", - " 2\n", - " 0\n", - " 0\n", + " 11.0\n", + " 2.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 61\n", @@ -361,10 +330,10 @@ " DAH_L4\n", " 1.388000\n", " 53.230400\n", - " 11\n", - " 3\n", - " 0\n", - " 0\n", + " 11.0\n", + " 3.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 62\n", @@ -373,10 +342,10 @@ " DAJ_L5\n", " 1.397750\n", " 53.225883\n", - " 11\n", - " 4\n", - " 0\n", - " 0\n", + " 11.0\n", + " 4.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 0\n", @@ -397,29 +366,29 @@ ], "text/plain": [ " id substation_id name Longitude Latitude String Order \\\n", - "1 DAE_A1 DOW_OSS DAE_A1 1.358783 53.243950 0 0 \n", - "2 DAD_A2 DOW_OSS DAD_A2 1.349033 53.248467 0 1 \n", - "3 DAC_A3 DOW_OSS DAC_A3 1.339283 53.252983 0 2 \n", - "4 DAB_A4 DOW_OSS DAB_A4 1.329550 53.257500 0 3 \n", - "5 DAA_A5 DOW_OSS DAA_A5 1.319800 53.262017 0 4 \n", + "1 DAE_A1 DOW_OSS DAE_A1 1.358783 53.243950 0.0 0.0 \n", + "2 DAD_A2 DOW_OSS DAD_A2 1.349033 53.248467 0.0 1.0 \n", + "3 DAC_A3 DOW_OSS DAC_A3 1.339283 53.252983 0.0 2.0 \n", + "4 DAB_A4 DOW_OSS DAB_A4 1.329550 53.257500 0.0 3.0 \n", + "5 DAA_A5 DOW_OSS DAA_A5 1.319800 53.262017 0.0 4.0 \n", ".. ... ... ... ... ... ... ... \n", - "59 DAF_L2 DOW_OSS DAF_L2 1.368533 53.239433 11 1 \n", - "60 DAG_L3 DOW_OSS DAG_L3 1.378250 53.234917 11 2 \n", - "61 DAH_L4 DOW_OSS DAH_L4 1.388000 53.230400 11 3 \n", - "62 DAJ_L5 DOW_OSS DAJ_L5 1.397750 53.225883 11 4 \n", + "59 DAF_L2 DOW_OSS DAF_L2 1.368533 53.239433 11.0 1.0 \n", + "60 DAG_L3 DOW_OSS DAG_L3 1.378250 53.234917 11.0 2.0 \n", + "61 DAH_L4 DOW_OSS DAH_L4 1.388000 53.230400 11.0 3.0 \n", + "62 DAJ_L5 DOW_OSS DAJ_L5 1.397750 53.225883 11.0 4.0 \n", "0 DOW_OSS DOW_OSS DOW_OSS 1.378767 53.264800 \n", "\n", " cable_length bury_speed \n", - "1 0 0 \n", - "2 0 0 \n", - "3 0 0 \n", - "4 0 0 \n", - "5 0 0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + "5 0.0 0.0 \n", ".. ... ... \n", - "59 0 0 \n", - "60 0 0 \n", - "61 0 0 \n", - "62 0 0 \n", + "59 0.0 0.0 \n", + "60 0.0 0.0 \n", + "61 0.0 0.0 \n", + "62 0.0 0.0 \n", "0 \n", "\n", "[68 rows x 9 columns]" @@ -473,19 +442,19 @@ "+--------------------------------+\n", "| PROJECT SPECIFICATIONS |\n", "+---------------------------+----+\n", - "| N turbines full string | 6 |\n", - "| N full strings | 11 |\n", - "| N turbines partial string | 1 |\n", + "| N turbines full string | 5 |\n", + "| N full strings | 13 |\n", + "| N turbines partial string | 2 |\n", "| N partial strings | 1 |\n", "+---------------------------+----+\n", - "Saving custom array CSV to: /cables/dudgeon_array_no_data.csv\n" + "Saving custom array to: /cables/dudgeon_array_no_data.csv\n" ] }, { "name": "stdin", "output_type": "stream", "text": [ - "../library/cables/dudgeon_array_no_data.csv already exists, overwrite [y/n]? y\n" + "/Users/rhammond/GitHub_Public/ORBIT/library/cables/dudgeon_array_no_data.csv already exists, overwrite [y/n]? y\n" ] }, { @@ -645,7 +614,7 @@ " turbine-62\n", " 0.0\n", " 0.0\n", - " 10.0\n", + " 12.0\n", " 2.0\n", " 0.0\n", " 0.0\n", @@ -657,7 +626,7 @@ " turbine-63\n", " 0.0\n", " 0.0\n", - " 10.0\n", + " 12.0\n", " 3.0\n", " 0.0\n", " 0.0\n", @@ -669,7 +638,7 @@ " turbine-64\n", " 0.0\n", " 0.0\n", - " 10.0\n", + " 12.0\n", " 4.0\n", " 0.0\n", " 0.0\n", @@ -681,8 +650,8 @@ " turbine-65\n", " 0.0\n", " 0.0\n", - " 10.0\n", - " 5.0\n", + " 13.0\n", + " 0.0\n", " 0.0\n", " 0.0\n", " \n", @@ -693,8 +662,8 @@ " turbine-66\n", " 0.0\n", " 0.0\n", - " 11.0\n", - " 0.0\n", + " 13.0\n", + " 1.0\n", " 0.0\n", " 0.0\n", " \n", @@ -711,11 +680,11 @@ "3 t2 oss1 turbine-2 0.0 0.0 0.0 \n", "4 t3 oss1 turbine-3 0.0 0.0 0.0 \n", ".. ... ... ... ... ... ... \n", - "63 t62 oss1 turbine-62 0.0 0.0 10.0 \n", - "64 t63 oss1 turbine-63 0.0 0.0 10.0 \n", - "65 t64 oss1 turbine-64 0.0 0.0 10.0 \n", - "66 t65 oss1 turbine-65 0.0 0.0 10.0 \n", - "67 t66 oss1 turbine-66 0.0 0.0 11.0 \n", + "63 t62 oss1 turbine-62 0.0 0.0 12.0 \n", + "64 t63 oss1 turbine-63 0.0 0.0 12.0 \n", + "65 t64 oss1 turbine-64 0.0 0.0 12.0 \n", + "66 t65 oss1 turbine-65 0.0 0.0 13.0 \n", + "67 t66 oss1 turbine-66 0.0 0.0 13.0 \n", "\n", " order cable_length bury_speed \n", "0 NaN NaN NaN \n", @@ -727,8 +696,8 @@ "63 2.0 0.0 0.0 \n", "64 3.0 0.0 0.0 \n", "65 4.0 0.0 0.0 \n", - "66 5.0 0.0 0.0 \n", - "67 0.0 0.0 0.0 \n", + "66 0.0 0.0 0.0 \n", + "67 1.0 0.0 0.0 \n", "\n", "[68 rows x 9 columns]" ] @@ -768,7 +737,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + "{'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", " 'location_data': 'dudgeon_array'},\n", " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", " 'site': {'depth': 20},\n", @@ -785,7 +756,16 @@ "cell_type": "code", "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/rhammond/GitHub_Public/ORBIT/ORBIT/phases/design/array_system_design.py:1088\n", + "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." + ] + } + ], "source": [ "array = CustomArraySystemDesign(config)\n", "array.run()" @@ -807,14 +787,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1109,9 +1087,10 @@ "output_type": "stream", "text": [ "Cable Type | Cost in USD\n", - "XLPE_400mm_33kV | $ 19,868,788.44\n", - "XLPE_630mm_33kV | $ 5,462,877.30\n", - "Total | $ 25,331,665.74\n" + "XLPE_400mm_33kV | $ 18,701,160.61\n", + "XLPE_630mm_33kV | $ 8,144,423.11\n", + "XLPE_630mm_220kV| $ 10,361,949.24\n", + "Total | $ 37,207,532.97\n" ] } ], @@ -1192,10 +1171,10 @@ " DAE_A1\n", " 14.890845\n", " 33.450759\n", - " 0\n", - " 0\n", - " 0\n", - " 0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 2\n", @@ -1204,10 +1183,10 @@ " DAD_A2\n", " 14.237528\n", " 33.953026\n", - " 0\n", - " 1\n", - " 0\n", - " 0\n", + " 0.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 3\n", @@ -1216,10 +1195,10 @@ " DAC_A3\n", " 13.584211\n", " 34.455182\n", - " 0\n", - " 2\n", - " 0\n", - " 0\n", + " 0.0\n", + " 2.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 4\n", @@ -1228,10 +1207,10 @@ " DAB_A4\n", " 12.932034\n", " 34.957450\n", - " 0\n", - " 3\n", - " 0\n", - " 0\n", + " 0.0\n", + " 3.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " ...\n", @@ -1252,10 +1231,10 @@ " DCE_L1\n", " 15.564263\n", " 34.321749\n", - " 11\n", - " 0\n", - " 0\n", - " 0\n", + " 11.0\n", + " 0.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 64\n", @@ -1264,10 +1243,10 @@ " DAF_L2\n", " 15.544161\n", " 32.948491\n", - " 11\n", - " 1\n", - " 0\n", - " 0\n", + " 11.0\n", + " 1.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 65\n", @@ -1276,10 +1255,10 @@ " DAG_L3\n", " 16.195266\n", " 32.446335\n", - " 11\n", - " 2\n", - " 0\n", - " 0\n", + " 11.0\n", + " 2.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 66\n", @@ -1288,10 +1267,10 @@ " DAH_L4\n", " 16.848583\n", " 31.944067\n", - " 11\n", - " 3\n", - " 0\n", - " 0\n", + " 11.0\n", + " 3.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", " 67\n", @@ -1300,10 +1279,10 @@ " DAJ_L5\n", " 17.501899\n", " 31.441800\n", - " 11\n", - " 4\n", - " 0\n", - " 0\n", + " 11.0\n", + " 4.0\n", + " 0.0\n", + " 0.0\n", " \n", " \n", "\n", @@ -1313,29 +1292,29 @@ "text/plain": [ " id substation_id name longitude latitude string order \\\n", "0 DOW_OSS DOW_OSS DOW_OSS 16.229909 35.769173 \n", - "1 DAE_A1 DOW_OSS DAE_A1 14.890845 33.450759 0 0 \n", - "2 DAD_A2 DOW_OSS DAD_A2 14.237528 33.953026 0 1 \n", - "3 DAC_A3 DOW_OSS DAC_A3 13.584211 34.455182 0 2 \n", - "4 DAB_A4 DOW_OSS DAB_A4 12.932034 34.957450 0 3 \n", + "1 DAE_A1 DOW_OSS DAE_A1 14.890845 33.450759 0.0 0.0 \n", + "2 DAD_A2 DOW_OSS DAD_A2 14.237528 33.953026 0.0 1.0 \n", + "3 DAC_A3 DOW_OSS DAC_A3 13.584211 34.455182 0.0 2.0 \n", + "4 DAB_A4 DOW_OSS DAB_A4 12.932034 34.957450 0.0 3.0 \n", ".. ... ... ... ... ... ... ... \n", - "63 DCE_L1 DOW_OSS DCE_L1 15.564263 34.321749 11 0 \n", - "64 DAF_L2 DOW_OSS DAF_L2 15.544161 32.948491 11 1 \n", - "65 DAG_L3 DOW_OSS DAG_L3 16.195266 32.446335 11 2 \n", - "66 DAH_L4 DOW_OSS DAH_L4 16.848583 31.944067 11 3 \n", - "67 DAJ_L5 DOW_OSS DAJ_L5 17.501899 31.441800 11 4 \n", + "63 DCE_L1 DOW_OSS DCE_L1 15.564263 34.321749 11.0 0.0 \n", + "64 DAF_L2 DOW_OSS DAF_L2 15.544161 32.948491 11.0 1.0 \n", + "65 DAG_L3 DOW_OSS DAG_L3 16.195266 32.446335 11.0 2.0 \n", + "66 DAH_L4 DOW_OSS DAH_L4 16.848583 31.944067 11.0 3.0 \n", + "67 DAJ_L5 DOW_OSS DAJ_L5 17.501899 31.441800 11.0 4.0 \n", "\n", " cable_length bury_speed \n", "0 \n", - "1 0 0 \n", - "2 0 0 \n", - "3 0 0 \n", - "4 0 0 \n", + "1 0.0 0.0 \n", + "2 0.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", ".. ... ... \n", - "63 0 0 \n", - "64 0 0 \n", - "65 0 0 \n", - "66 0 0 \n", - "67 0 0 \n", + "63 0.0 0.0 \n", + "64 0.0 0.0 \n", + "65 0.0 0.0 \n", + "66 0.0 0.0 \n", + "67 0.0 0.0 \n", "\n", "[68 rows x 9 columns]" ] @@ -1366,7 +1345,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + "{'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", " 'distance': True,\n", " 'location_data': 'dudgeon_distance_based'},\n", " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", @@ -1393,7 +1374,16 @@ "cell_type": "code", "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/rhammond/GitHub_Public/ORBIT/ORBIT/phases/design/array_system_design.py:1088\n", + "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." + ] + } + ], "source": [ "array_distance = CustomArraySystemDesign(config, distance=True)\n", "array_distance.run()" @@ -1415,14 +1405,12 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1449,9 +1437,10 @@ "output_type": "stream", "text": [ "Cable Type | Cost in USD (lat,lon) | Cost in USD (dist_lat,dist_lon)\n", - "XLPE_400mm_33kV | $ 19,868,788.44 | $ 19,926,147.66\n", - "XLPE_630mm_33kV | $ 5,462,877.30 | $ 5,479,206.87\n", - "Total | $ 25,331,665.74 | $ 25,405,354.53\n" + "XLPE_400mm_33kV | $ 18,701,160.61 | $ 18,756,091.16\n", + "XLPE_630mm_33kV | $ 8,144,423.11 | $ 8,166,522.03\n", + "XLPE_630mm_220kV | $ 10,361,949.24 | $ 10,392,923.05\n", + "Total | $ 37,207,532.97 | $ 37,315,536.24\n" ] } ], @@ -1492,7 +1481,9 @@ { "data": { "text/plain": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + "{'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", " 'location_data': 'dudgeon_array',\n", " 'average_exclusion_percent': 0.05},\n", " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", @@ -1514,7 +1505,16 @@ "cell_type": "code", "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/rhammond/GitHub_Public/ORBIT/ORBIT/phases/design/array_system_design.py:1088\n", + "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." + ] + } + ], "source": [ "array_exclusion = CustomArraySystemDesign(config)\n", "array_exclusion.run()" @@ -1530,9 +1530,10 @@ "output_type": "stream", "text": [ "Cable Type | Cost in USD\n", - "XLPE_400mm_33kV | $ 20,826,227.86\n", - "XLPE_630mm_33kV | $ 5,729,721.17\n", - "Total | $ 26,555,949.03\n" + "XLPE_400mm_33kV | $ 19,601,240.84\n", + "XLPE_630mm_33kV | $ 8,538,527.60\n", + "XLPE_630mm_220kV| $ 10,868,096.91\n", + "Total | $ 39,007,865.35\n" ] } ], @@ -1573,7 +1574,9 @@ { "data": { "text/plain": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + "{'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", " 'location_data': 'dudgeon_custom'},\n", " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", " 'site': {'depth': 20},\n", @@ -1889,9 +1892,10 @@ "output_type": "stream", "text": [ "Cable Type | Cost in USD\n", - "XLPE_400mm_33kV | $ 22,269,793.09\n", - "XLPE_630mm_33kV | $ 5,355,606.02\n", - "Total | $ 27,625,399.10\n" + "XLPE_400mm_33kV | $ 20,841,928.36\n", + "XLPE_630mm_33kV | $ 9,307,325.71\n", + "XLPE_630mm_220kV| $ 10,158,477.79\n", + "Total | $ 40,307,731.86\n" ] } ], @@ -1989,10 +1993,10 @@ "output_type": "stream", "text": [ "Simulation | Cost (in USD) | Time (in hours)\n", - "straight-line distance | $11,444,455.51 | 2,211\n", - "distance-based coordinates | $11,447,877.14 | 2,212\n", - "with exclusions | $11,501,377.80 | 2,222\n", - "custom | $15,600,938.01 | 3,040\n" + "straight-line distance | $24,594,075.16 | 2,372\n", + "distance-based coordinates | $24,605,520.50 | 2,373\n", + "with exclusions | $24,784,480.17 | 2,391\n", + "custom | $31,792,520.58 | 3,088\n" ] } ], @@ -2020,9 +2024,9 @@ "metadata": {}, "source": [ "\n", - "## Let's put this all together\n", + "## Let's put this all together and load with a data frame\n", "\n", - "#### Using `ProjectManager` we will run Case 4 from design to installation.\n", + "### Using `ProjectManager` we will run Case 4 from design to installation.\n", "\n", "We'll see here at the end that we end up with the same results running a custom array cabling project piecemeal and as a whole." ] @@ -2041,8 +2045,36 @@ " 'port': {'monthly_rate': 10000},\n", " 'site': {'depth': 20, 'distance': 50},\n", " 'turbine': 'SWT_6MW_154m_110m',\n", - " 'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_custom',\n", + " 'array_system_design': {'cables': ['XLPE_400mm_33kV',\n", + " 'XLPE_630mm_33kV',\n", + " 'XLPE_630mm_220kV'],\n", + " 'location_data': id substation_id name latitude longitude string order \\\n", + " 0 DOW_OSS DOW_OSS DOW_OSS 53.264800 1.378767 NaN NaN \n", + " 1 DAE_A1 DOW_OSS DAE_A1 53.243950 1.358783 0.0 0.0 \n", + " 2 DAD_A2 DOW_OSS DAD_A2 53.248467 1.349033 0.0 1.0 \n", + " 3 DAC_A3 DOW_OSS DAC_A3 53.252983 1.339283 0.0 2.0 \n", + " 4 DAB_A4 DOW_OSS DAB_A4 53.257500 1.329550 0.0 3.0 \n", + " .. ... ... ... ... ... ... ... \n", + " 63 DCE_L1 DOW_OSS DCE_L1 53.251783 1.368833 11.0 0.0 \n", + " 64 DAF_L2 DOW_OSS DAF_L2 53.239433 1.368533 11.0 1.0 \n", + " 65 DAG_L3 DOW_OSS DAG_L3 53.234917 1.378250 11.0 2.0 \n", + " 66 DAH_L4 DOW_OSS DAH_L4 53.230400 1.388000 11.0 3.0 \n", + " 67 DAJ_L5 DOW_OSS DAJ_L5 53.225883 1.397750 11.0 4.0 \n", + " \n", + " cable_length bury_speed \n", + " 0 NaN NaN \n", + " 1 3.135279 0.50 \n", + " 2 0.993860 0.50 \n", + " 3 0.993719 0.50 \n", + " 4 0.992699 0.50 \n", + " .. ... ... \n", + " 63 1.712822 0.05 \n", + " 64 1.483318 0.05 \n", + " 65 0.901721 0.05 \n", + " 66 0.903679 0.05 \n", + " 67 0.903736 0.05 \n", + " \n", + " [68 rows x 9 columns],\n", " 'distance': False},\n", " 'array_cable_install_vessel': 'example_cable_lay_vessel',\n", " 'array_cable_bury_vessel': 'example_cable_lay_vessel'}" @@ -2055,6 +2087,9 @@ ], "source": [ "config = library.extract_library_specs(\"config\", \"example_custom_array_project_manager\")\n", + "config[\"array_system_design\"][\"location_data\"] = library.extract_library_specs(\n", + " \"cables\", config[\"array_system_design\"][\"location_data\"], file_type=\"csv\"\n", + ")\n", "config" ] }, @@ -2077,10 +2112,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "Custom Design | $27,625,399.10\n", - "Custom Installation | $15,600,938.01\n", - "Total Cost. | $43,226,337.11\n", - "Project Manager Cost | $43,226,337.11\n" + "Custom Design | $40,307,731.86\n", + "Custom Installation | $31,792,520.58\n", + "Total Cost. | $72,100,252.44\n", + "Project Manager Cost | $72,100,252.44\n" ] } ], @@ -2110,7 +2145,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2124,7 +2159,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/examples/Example - Using Monopile or GBF Intallation.ipynb b/examples/Example - Using Monopile or GBF Intallation.ipynb new file mode 100644 index 00000000..6d106889 --- /dev/null +++ b/examples/Example - Using Monopile or GBF Intallation.ipynb @@ -0,0 +1,1810 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example - Using Monopile or GBF Installation\n", + "\n", + "This tutorial uses pre compiled ORBIT configs that are stored as .yaml files in the '~/configs/ folder. There are load and save methods available in ORBIT for working with .yaml files. \n", + "\n", + "This specific notebook runs the turbine and substructure installation of a project using different intallation methods: \n", + "- Monopile and Turbine Installation (Heavy Lift Vessel for Monopile Installation, WTIV for Turbine Installation)\n", + "- Gravity-Based Foundation Intallation (Substructure-Turbine Assembly Tow-out, no WTIV)\n", + "- Gravity-Based Foundation and Turbine Intallation (Substructure Tow-out, WTIV for Turbine Installation)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\dmulash\\AppData\\Local\\Temp\\1\\ipykernel_8540\\3577394900.py:6\n", + "Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format." + ] + } + ], + "source": [ + "import os\n", + "import pandas as pd\n", + "from ORBIT import ProjectManager, load_config\n", + "import copy\n", + "\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the project configuration for the Gravity-Based Foundation Intallation (Substructure-Turbine Assembly Tow-out, no WTIV)\n", + "This configuration represents a substructure-turbine assembly tow-out using a gravity-based foundation, with no WTIV involved in the installation." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "gbf_no_wtiv_config = load_config(\"configs/example_gravity-based_project.yaml\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a project configuration for the Gravity-Based Foundation and Turbine Intallation (Substructure Tow-out, WTIV for Turbine Installation)\n", + "This modified configuration uses a substructure assembly tow-out using a gravity-based foundation and a WTIV for turbine installation, while retaining all other inputs from the original Gravity-Based project setup." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a copy to avoid modifying the original gbf_no_wtiv_config\n", + "gbf_with_wtiv_config = copy.deepcopy(gbf_no_wtiv_config)\n", + "\n", + "# Add 'wtiv' key if not already set\n", + "if \"wtiv\" not in gbf_with_wtiv_config:\n", + " gbf_with_wtiv_config[\"wtiv\"] = \"example_wtiv\"\n", + "\n", + "# Add 'TurbineInstallation' to install_phases if not already present\n", + "if \"TurbineInstallation\" not in gbf_with_wtiv_config[\"install_phases\"]:\n", + " gbf_with_wtiv_config[\"install_phases\"][\"TurbineInstallation\"] = 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a project configuration for the Monopile and Turbine Installation (Heavy Lift Vessel for Monopile Installation, WTIV for Turbine Installation)\n", + "This modified configuration uses a Heavy Lift Vessel for monopile installation and a WTIV for turbine installation, while retaining all other inputs from the original Gravity-Based project setup." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a copy to avoid modifying the original gbf_no_wtiv_config\n", + "monopile_config = copy.deepcopy(gbf_no_wtiv_config)\n", + "\n", + "# Add 'wtiv' key if not already set\n", + "if \"wtiv\" not in monopile_config:\n", + " monopile_config[\"wtiv\"] = \"example_wtiv\"\n", + "\n", + "# Add 'MonopileDesign' to design_phases if not already present\n", + "if \"MonopileDesign\" not in monopile_config[\"design_phases\"]:\n", + " monopile_config[\"design_phases\"].append(\"MonopileDesign\")\n", + "\n", + "# Add 'MonopileInstallation' to install_phases if not already present\n", + "if \"MonopileInstallation\" not in monopile_config[\"install_phases\"]:\n", + " monopile_config[\"install_phases\"][\"MonopileInstallation\"] = 0\n", + "\n", + "# Add 'TurbineInstallation' to install_phases if not already present\n", + "if \"TurbineInstallation\" not in monopile_config[\"install_phases\"]:\n", + " monopile_config[\"install_phases\"][\"TurbineInstallation\"] = 0\n", + "\n", + "# Add 'ScourProtectionDesign' to design_phases if not already present\n", + "if \"ScourProtectionDesign\" not in monopile_config[\"design_phases\"]:\n", + " monopile_config[\"design_phases\"].append(\"ScourProtectionDesign\")\n", + "\n", + "# Ensure 'scour_protection_design' exists\n", + "if \"scour_protection_design\" not in monopile_config:\n", + " monopile_config[\"scour_protection_design\"] = {}\n", + "\n", + "# Set 'cost_per_tonne' only if not already defined\n", + "if \"cost_per_tonne\" not in monopile_config[\"scour_protection_design\"]:\n", + " monopile_config[\"scour_protection_design\"][\"cost_per_tonne\"] = 40\n", + "\n", + "# Add 'ScourProtectionInstallation' to install_phases if not already present\n", + "if \"ScourProtectionInstallation\" not in monopile_config[\"install_phases\"]:\n", + " monopile_config[\"install_phases\"][\"ScourProtectionInstallation\"] = 0\n", + "\n", + "# Remove 'GravityBasedInstallation' from install_phases if it exists\n", + "monopile_config[\"install_phases\"].pop(\"GravityBasedInstallation\", None)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Each Project Has Different Installation Phases\n", + "\n", + "The 'TurbineInstallation' module is only required for projects involving a WTIV. The 'GravityBasedInstallation' module offers flexibility—if a WTIV is not specified in the configuration file, it models the tow-out of a fully assembled substructure and turbine; if a WTIV is present, it models the tow-out of the substructure alone.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Monopile and Turbine Installation (Heavy Lift Vessel for Monopile Installation, WTIV for Turbine Installation)\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'OffshoreSubstationInstallation', 'MonopileInstallation', 'TurbineInstallation', 'ScourProtectionInstallation']\n", + "\n", + "Gravity-Based Foundation Intallation (Substructure-Turbine Assembly Tow-out, no WTIV)\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'GravityBasedInstallation', 'OffshoreSubstationInstallation']\n", + "\n", + "Gravity-Based Foundation and Turbine Intallation (Substructure Tow-out, WTIV for Turbine Installation)\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'GravityBasedInstallation', 'OffshoreSubstationInstallation', 'TurbineInstallation']\n", + "\n" + ] + } + ], + "source": [ + "print(f\"Monopile and Turbine Installation (Heavy Lift Vessel for Monopile Installation, WTIV for Turbine Installation)\")\n", + "print(f\"Install phases: {list(monopile_config['install_phases'].keys())}\\n\")\n", + "print(f\"Gravity-Based Foundation Intallation (Substructure-Turbine Assembly Tow-out, no WTIV)\")\n", + "print(f\"Install phases: {list(gbf_no_wtiv_config['install_phases'].keys())}\\n\")\n", + "print(f\"Gravity-Based Foundation and Turbine Intallation (Substructure Tow-out, WTIV for Turbine Installation)\")\n", + "print(f\"Install phases: {list(gbf_with_wtiv_config['install_phases'].keys())}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run Three Cases\n", + "\n", + "This project is always being modeled with the example weather project supplied that is representative of US East Coast wind farm locations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\esteyco-no-cost-extension\\ORBIT\\library'\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: C:\\esteyco-no-cost-extension\\ORBIT\\ORBIT\\manager.py:730\n", + "landfall dictionary will be deprecated and moved into [export_system_design][landfall].DeprecationWarning: C:\\esteyco-no-cost-extension\\ORBIT\\ORBIT\\phases\\install\\cable_install\\export.py:84\n", + "landfall dictionary will be deprecated and moved into [export_system][landfall]." + ] + } + ], + "source": [ + "project_monopile = ProjectManager(monopile_config, weather=weather)\n", + "project_monopile.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: C:\\esteyco-no-cost-extension\\ORBIT\\ORBIT\\phases\\install\\quayside_assembly_tow\\gravity_base.py:91\n", + "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", + "DeprecationWarning: C:\\esteyco-no-cost-extension\\ORBIT\\ORBIT\\phases\\install\\quayside_assembly_tow\\gravity_base.py:91\n", + "['towing_vessl_groups]['station_keeping_vessels'] will be deprecated and replaced with ['towing_vessl_groups]['ahts_vessels'].\n" + ] + } + ], + "source": [ + "project_gbf_no_wtiv = ProjectManager(gbf_no_wtiv_config, weather=weather)\n", + "project_gbf_no_wtiv.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "project_gbf_with_wtiv = ProjectManager(gbf_with_wtiv_config, weather=weather)\n", + "project_gbf_with_wtiv.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CapEx ComponentMonopiles + WTIVGBF-Turbine Assembly Tow-outGBF Tow-out + WTIV
0Array System50,455,75750,455,75750,455,757
1Array System Installation58,448,33558,448,33558,448,335
2Export System358,235,289358,235,289358,235,289
3Export System Installation24,502,08224,502,08224,502,082
4Offshore Substation307,307,330307,307,330307,307,330
5Offshore Substation Installation5,095,6005,095,6005,095,600
6Project185,582,083185,582,083185,582,083
7Scour Protection6,618,00000
8Scour Protection Installation14,748,98900
9Soft576,480,426459,880,708510,384,883
10Substructure554,716,392285,000,000285,000,000
11Substructure Installation53,356,40350,175,12632,559,297
12Turbine1,275,000,0001,275,000,0001,275,000,000
13Turbine Installation95,293,403095,293,403
14Total3,565,840,0903,059,682,3113,187,864,060
\n", + "
" + ], + "text/plain": [ + " CapEx Component Monopiles + WTIV \\\n", + "0 Array System 50,455,757 \n", + "1 Array System Installation 58,448,335 \n", + "2 Export System 358,235,289 \n", + "3 Export System Installation 24,502,082 \n", + "4 Offshore Substation 307,307,330 \n", + "5 Offshore Substation Installation 5,095,600 \n", + "6 Project 185,582,083 \n", + "7 Scour Protection 6,618,000 \n", + "8 Scour Protection Installation 14,748,989 \n", + "9 Soft 576,480,426 \n", + "10 Substructure 554,716,392 \n", + "11 Substructure Installation 53,356,403 \n", + "12 Turbine 1,275,000,000 \n", + "13 Turbine Installation 95,293,403 \n", + "14 Total 3,565,840,090 \n", + "\n", + " GBF-Turbine Assembly Tow-out GBF Tow-out + WTIV \n", + "0 50,455,757 50,455,757 \n", + "1 58,448,335 58,448,335 \n", + "2 358,235,289 358,235,289 \n", + "3 24,502,082 24,502,082 \n", + "4 307,307,330 307,307,330 \n", + "5 5,095,600 5,095,600 \n", + "6 185,582,083 185,582,083 \n", + "7 0 0 \n", + "8 0 0 \n", + "9 459,880,708 510,384,883 \n", + "10 285,000,000 285,000,000 \n", + "11 50,175,126 32,559,297 \n", + "12 1,275,000,000 1,275,000,000 \n", + "13 0 95,293,403 \n", + "14 3,059,682,311 3,187,864,060 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The breakdown of project costs by module is available at 'capex_breakdown'\n", + "\n", + "df = pd.DataFrame({\n", + " 'Monopiles + WTIV': pd.Series(project_monopile.capex_breakdown),\n", + " 'GBF-Turbine Assembly Tow-out': project_gbf_no_wtiv.capex_breakdown,\n", + " 'GBF Tow-out + WTIV': pd.Series(project_gbf_with_wtiv.capex_breakdown)\n", + "}).fillna(0)\n", + "\n", + "# Add Total row\n", + "df.loc['Total'] = df.sum()\n", + "\n", + "# Move index to a column\n", + "df = df.reset_index().rename(columns={'index': 'CapEx Component'})\n", + "\n", + "# Create a copy for display with formatting (as strings)\n", + "df_display = df.copy()\n", + "\n", + "# Format numeric columns with commas (leave 'CapEx Component' alone)\n", + "for col in df_display.columns[1:]:\n", + " df_display[col] = df_display[col].apply(lambda x: f\"{x:,.0f}\")\n", + "\n", + "# Display the formatted version (but original df remains numeric)\n", + "df_display" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_capex_comparison(df, num_turbines, project_capacity_mw, top_limit=4000):\n", + " import pandas as pd\n", + " import matplotlib.pyplot as plt\n", + " import matplotlib.ticker as ticker\n", + " import numpy as np\n", + "\n", + " # Clean column names and remove total row\n", + " df.columns = df.columns.str.strip()\n", + " df = df[~df['CapEx Component'].str.lower().str.contains('total')]\n", + "\n", + " # Melt to long format\n", + " df_long = df.melt(id_vars='CapEx Component', var_name='Configuration', value_name='CapEx ($)')\n", + " \n", + " # Clean and convert CapEx values to float\n", + " df_long['CapEx ($)'] = df_long['CapEx ($)'].replace(',', '', regex=True).astype(float)\n", + "\n", + " # Convert to million USD\n", + " df_long['CapEx (Million USD)'] = df_long['CapEx ($)'] / 1e6\n", + "\n", + " # Pivot: Configuration as index, components as columns (Million USD)\n", + " pivot_musd = df_long.pivot(index='Configuration', columns='CapEx Component', values='CapEx (Million USD)').fillna(0)\n", + "\n", + " # Set the order of configurations explicitly\n", + " desired_order = [\"Monopiles + WTIV\", \"GBF-Turbine Assembly Tow-out\", \"GBF Tow-out + WTIV\"]\n", + " pivot_musd = pivot_musd.reindex(desired_order)\n", + "\n", + " capacity_kw = project_capacity_mw * 1000\n", + "\n", + " # Colors for components\n", + " colors = plt.get_cmap('tab20').colors\n", + " component_order = pivot_musd.columns.tolist()\n", + " color_map = {component: colors[i % len(colors)] for i, component in enumerate(component_order)}\n", + "\n", + " # Plot with black edges on bars\n", + " fig, ax = plt.subplots(figsize=(14, 10))\n", + " bottoms = np.zeros(len(pivot_musd))\n", + " bar_width = 0.7 # Slightly thinner bars\n", + "\n", + " for comp in component_order:\n", + " vals = pivot_musd[comp].values\n", + " bars = ax.bar(pivot_musd.index, vals, bottom=bottoms, width=bar_width,\n", + " color=color_map[comp], edgecolor='black', linewidth=0.8, label=comp)\n", + " # Update bottoms for next stack\n", + " bottoms += vals\n", + "\n", + " # Add text inside each stacked segment if $/kW >= 40\n", + " for i, val_musd in enumerate(vals):\n", + " if val_musd == 0:\n", + " continue\n", + " val_usd = val_musd * 1e6\n", + " val_per_kw = val_usd / capacity_kw\n", + " val_per_wtg_musd = val_musd / num_turbines\n", + "\n", + " if val_per_kw >= 40:\n", + " y_pos = bars[i].get_y() + bars[i].get_height() / 2\n", + " text = (\n", + " f\"${val_musd:,.1f}M | \"\n", + " f\"${val_per_kw:,.0f}/kW | \"\n", + " f\"${val_per_wtg_musd:,.2f}M/WTG\"\n", + " )\n", + " ax.text(i, y_pos, text, ha='center', va='center', fontsize=8, color='black')\n", + "\n", + " # Add total values text on top of bars\n", + " total_musd = pivot_musd.sum(axis=1)\n", + " for i, total in enumerate(total_musd):\n", + " total_usd = total * 1e6\n", + " total_per_kw = total_usd / capacity_kw\n", + " total_per_wtg_musd = total / num_turbines\n", + " text = (\n", + " f\"Total:\\n\"\n", + " f\"${total:,.1f}M | \"\n", + " f\"${total_per_kw:,.0f}/kW | \"\n", + " f\"${total_per_wtg_musd:,.2f}M/WTG\"\n", + " )\n", + " ax.text(i, total * 1.005, text, ha='center', va='bottom', fontsize=8, color='black', fontweight='bold')\n", + "\n", + " # Format y-axis ticks with commas\n", + " ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f'{x:,.0f}'))\n", + "\n", + " plt.ylabel('CapEx ($ Million)', fontweight='bold')\n", + " plt.xlabel('Configuration', fontweight='bold')\n", + " plt.title('CapEx Breakdown by Component')\n", + " plt.ylim(0, top_limit)\n", + " plt.xticks()\n", + " plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + "\n", + " plt.legend(title='CapEx Component', bbox_to_anchor=(1.01, 1), loc='upper left')\n", + " plt.tight_layout()\n", + " #plt.savefig(\"results/capex_comparison.png\", dpi=300)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_capex_comparison(df_display, 50, 750, top_limit=4000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Substructure and Turbine Installation CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CapEx ComponentMonopiles + WTIVGBF-Turbine Assembly Tow-outGBF Tow-out + WTIV
0Substructure Installation53,356,40350,175,12632,559,297
1Turbine Installation95,293,403095,293,403
2Total148,649,80750,175,126127,852,700
\n", + "
" + ], + "text/plain": [ + " CapEx Component Monopiles + WTIV GBF-Turbine Assembly Tow-out \\\n", + "0 Substructure Installation 53,356,403 50,175,126 \n", + "1 Turbine Installation 95,293,403 0 \n", + "2 Total 148,649,807 50,175,126 \n", + "\n", + " GBF Tow-out + WTIV \n", + "0 32,559,297 \n", + "1 95,293,403 \n", + "2 127,852,700 " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filter only the rows of interest\n", + "subset_df = df[df['CapEx Component'].isin(['Substructure Installation', 'Turbine Installation'])].copy()\n", + "\n", + "# Add Total row (sum of these two rows)\n", + "total_row = {\n", + " 'CapEx Component': 'Total',\n", + "}\n", + "for col in subset_df.columns[1:]:\n", + " total_row[col] = subset_df[col].sum()\n", + "subset_df = pd.concat([subset_df, pd.DataFrame([total_row])], ignore_index=True)\n", + "\n", + "# Optional: format for display (with commas)\n", + "subset_display = subset_df.copy()\n", + "for col in subset_display.columns[1:]:\n", + " subset_display[col] = subset_display[col].apply(lambda x: f\"{x:,.0f}\")\n", + "\n", + "# Show formatted version\n", + "subset_display" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Actions\n", + "\n", + "Display the installation sequences from each configuration file (just for substructure and turbine), and show total durations by installation step." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cost_multiplieragentactiondurationcostleveltimephasesite_depthhub_heightphase_nameper_triplocationmax_waveheightmax_windspeedtransit_speed
31.0WTIVMobilize168.0000002.800000e+06ACTION0.000000MonopileInstallationNaNNaNNaNNaNNaNNaNNaNNaN
11NaNWTIVFasten Monopile12.0000002.000000e+05ACTION12.000000MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
20NaNWTIVFasten Transition Piece8.0000001.333333e+05ACTION20.000000MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
31NaNWTIVFasten Monopile12.0000002.000000e+05ACTION32.000000MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
35NaNWTIVFasten Transition Piece8.0000001.333333e+05ACTION40.000000MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
...................................................
2285NaNWTIVRelease Transition Piece2.0000003.333333e+04ACTION2843.966890MonopileInstallationNaNNaNNaNNaNNaNNaNNaNNaN
2286NaNWTIVCrane Reequip1.0000001.666667e+04ACTION2844.966890MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
2287NaNWTIVLower TP1.0000001.666667e+04ACTION2845.966890MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
2290NaNWTIVBolt TP4.0000006.666667e+04ACTION2849.966890MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
2292NaNWTIVJackdown0.4333337.222222e+03ACTION2850.400223MonopileInstallation40.0150.0MonopileInstallation3.0NaNNaNNaNNaN
\n", + "

821 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration \\\n", + "3 1.0 WTIV Mobilize 168.000000 \n", + "11 NaN WTIV Fasten Monopile 12.000000 \n", + "20 NaN WTIV Fasten Transition Piece 8.000000 \n", + "31 NaN WTIV Fasten Monopile 12.000000 \n", + "35 NaN WTIV Fasten Transition Piece 8.000000 \n", + "... ... ... ... ... \n", + "2285 NaN WTIV Release Transition Piece 2.000000 \n", + "2286 NaN WTIV Crane Reequip 1.000000 \n", + "2287 NaN WTIV Lower TP 1.000000 \n", + "2290 NaN WTIV Bolt TP 4.000000 \n", + "2292 NaN WTIV Jackdown 0.433333 \n", + "\n", + " cost level time phase site_depth \\\n", + "3 2.800000e+06 ACTION 0.000000 MonopileInstallation NaN \n", + "11 2.000000e+05 ACTION 12.000000 MonopileInstallation 40.0 \n", + "20 1.333333e+05 ACTION 20.000000 MonopileInstallation 40.0 \n", + "31 2.000000e+05 ACTION 32.000000 MonopileInstallation 40.0 \n", + "35 1.333333e+05 ACTION 40.000000 MonopileInstallation 40.0 \n", + "... ... ... ... ... ... \n", + "2285 3.333333e+04 ACTION 2843.966890 MonopileInstallation NaN \n", + "2286 1.666667e+04 ACTION 2844.966890 MonopileInstallation 40.0 \n", + "2287 1.666667e+04 ACTION 2845.966890 MonopileInstallation 40.0 \n", + "2290 6.666667e+04 ACTION 2849.966890 MonopileInstallation 40.0 \n", + "2292 7.222222e+03 ACTION 2850.400223 MonopileInstallation 40.0 \n", + "\n", + " hub_height phase_name per_trip location max_waveheight \\\n", + "3 NaN NaN NaN NaN NaN \n", + "11 150.0 MonopileInstallation 3.0 NaN NaN \n", + "20 150.0 MonopileInstallation 3.0 NaN NaN \n", + "31 150.0 MonopileInstallation 3.0 NaN NaN \n", + "35 150.0 MonopileInstallation 3.0 NaN NaN \n", + "... ... ... ... ... ... \n", + "2285 NaN NaN NaN NaN NaN \n", + "2286 150.0 MonopileInstallation 3.0 NaN NaN \n", + "2287 150.0 MonopileInstallation 3.0 NaN NaN \n", + "2290 150.0 MonopileInstallation 3.0 NaN NaN \n", + "2292 150.0 MonopileInstallation 3.0 NaN NaN \n", + "\n", + " max_windspeed transit_speed \n", + "3 NaN NaN \n", + "11 NaN NaN \n", + "20 NaN NaN \n", + "31 NaN NaN \n", + "35 NaN NaN \n", + "... ... ... \n", + "2285 NaN NaN \n", + "2286 NaN NaN \n", + "2287 NaN NaN \n", + "2290 NaN NaN \n", + "2292 NaN NaN \n", + "\n", + "[821 rows x 16 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "action\n", + "Bolt TP 200.000000\n", + "Crane Reequip 100.000000\n", + "Delay 545.000000\n", + "Drive Monopile 75.000000\n", + "Fasten Monopile 600.000000\n", + "Fasten Transition Piece 400.000000\n", + "Jackdown 21.666667\n", + "Jackup 21.666667\n", + "Lower Monopile 0.250000\n", + "Lower TP 50.000000\n", + "Mobilize 168.000000\n", + "Position Onsite 100.000000\n", + "Release Monopile 150.000000\n", + "Release Transition Piece 100.000000\n", + "RovSurvey 50.000000\n", + "Transit 396.000000\n", + "Upend Monopile 40.816890\n", + "Name: duration, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.DataFrame(project_monopile.actions) \n", + "project_monopile_turbine_install = df.loc[df['phase']==\"TurbineInstallation\"]\n", + "project_monopile_monopile_install = df.loc[df['phase']==\"MonopileInstallation\"]\n", + "display(project_monopile_monopile_install)\n", + "display(project_monopile_monopile_install.groupby([\"action\"]).sum()['duration'])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cost_multiplieragentactiondurationcostleveltimephasephase_namelocationsite_depthmax_waveheightmax_windspeedtransit_speednum_vesselsnum_ahts_vessels
1NaNSubstructure Assembly Line 1Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
2NaNSubstructure Assembly Line 2Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
3NaNSubstructure Assembly Line 1Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4NaNSubstructure Assembly Line 2Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
5NaNSubstructure Assembly Line 1Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
...................................................
1819NaNMulti-Purpose AHTS VesselPump Ballast12.00000053593.500000ACTION5632.714286GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
1820NaNMulti-Purpose AHTS VesselGrout GBF6.00000026796.750000ACTION5638.714286GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
1821NaNTowing Group 1Positioning Support24.00000037516.000000ACTION5638.714286GravityBasedInstallationNaNsiteNaNNaNNaNNaN1.0NaN
1822NaNTowing Group 1Transit8.57142940195.714286ACTION5647.285714GravityBasedInstallationNaNNaNNaNNaNNaNNaN3.00.0
1823NaNMulti-Purpose AHTS VesselTransit8.57142938281.071429ACTION5647.285714GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaN
\n", + "

1125 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action \\\n", + "1 NaN Substructure Assembly Line 1 Substructure Assembly \n", + "2 NaN Substructure Assembly Line 2 Substructure Assembly \n", + "3 NaN Substructure Assembly Line 1 Substructure Assembly \n", + "4 NaN Substructure Assembly Line 2 Substructure Assembly \n", + "5 NaN Substructure Assembly Line 1 Substructure Assembly \n", + "... ... ... ... \n", + "1819 NaN Multi-Purpose AHTS Vessel Pump Ballast \n", + "1820 NaN Multi-Purpose AHTS Vessel Grout GBF \n", + "1821 NaN Towing Group 1 Positioning Support \n", + "1822 NaN Towing Group 1 Transit \n", + "1823 NaN Multi-Purpose AHTS Vessel Transit \n", + "\n", + " duration cost level time phase \\\n", + "1 0.000000 0.000000 ACTION 0.000000 GravityBasedInstallation \n", + "2 0.000000 0.000000 ACTION 0.000000 GravityBasedInstallation \n", + "3 0.000000 0.000000 ACTION 0.000000 GravityBasedInstallation \n", + "4 0.000000 0.000000 ACTION 0.000000 GravityBasedInstallation \n", + "5 0.000000 0.000000 ACTION 0.000000 GravityBasedInstallation \n", + "... ... ... ... ... ... \n", + "1819 12.000000 53593.500000 ACTION 5632.714286 GravityBasedInstallation \n", + "1820 6.000000 26796.750000 ACTION 5638.714286 GravityBasedInstallation \n", + "1821 24.000000 37516.000000 ACTION 5638.714286 GravityBasedInstallation \n", + "1822 8.571429 40195.714286 ACTION 5647.285714 GravityBasedInstallation \n", + "1823 8.571429 38281.071429 ACTION 5647.285714 GravityBasedInstallation \n", + "\n", + " phase_name location site_depth max_waveheight max_windspeed \\\n", + "1 NaN NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "5 NaN NaN NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "1819 NaN NaN NaN NaN NaN \n", + "1820 NaN NaN NaN NaN NaN \n", + "1821 NaN site NaN NaN NaN \n", + "1822 NaN NaN NaN NaN NaN \n", + "1823 NaN NaN NaN NaN NaN \n", + "\n", + " transit_speed num_vessels num_ahts_vessels \n", + "1 NaN NaN NaN \n", + "2 NaN NaN NaN \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "5 NaN NaN NaN \n", + "... ... ... ... \n", + "1819 NaN NaN NaN \n", + "1820 NaN NaN NaN \n", + "1821 NaN 1.0 NaN \n", + "1822 NaN 3.0 0.0 \n", + "1823 NaN NaN NaN \n", + "\n", + "[1125 rows x 16 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "action\n", + "Delay 4532.000000\n", + "Delay: No Assembly Storage Available 11.928571\n", + "Delay: No Completed Assemblies Available 2226.142857\n", + "Delay: No Substructure Storage Available 10462.428571\n", + "Delay: Not enough vessels for gravity foundations 3309.642857\n", + "Electrical Completion 3600.000000\n", + "Grout GBF 300.000000\n", + "Lift and Attach Blade 525.000000\n", + "Lift and Attach Nacelle 600.000000\n", + "Lift and Attach Tower Section 400.000000\n", + "Mechanical Completion 1200.000000\n", + "Mobilize 72.000000\n", + "Move Substructure 400.000000\n", + "Position Substructure 250.000000\n", + "Positioning Support 1992.571429\n", + "Prepare for Turbine Assembly 600.000000\n", + "Pump Ballast 600.000000\n", + "ROV Survey 50.000000\n", + "Substructure Assembly 0.000000\n", + "Tow Substructure 1000.000000\n", + "Transit 445.714286\n", + "Name: duration, dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df = pd.DataFrame(project_gbf_no_wtiv.actions) \n", + "project_gbf_no_wtiv_turbine_install = df.loc[df['phase']==\"TurbineInstallation\"]\n", + "project_gbf_no_wtiv_gbf_install = df.loc[df['phase']==\"GravityBasedInstallation\"]\n", + "display(project_gbf_no_wtiv_gbf_install)\n", + "display(project_gbf_no_wtiv_gbf_install.groupby([\"action\"]).sum()['duration'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
cost_multiplieragentactiondurationcostleveltimephasesite_depthhub_heightphase_namenum_vesselsnum_ahts_vesselslocationmax_waveheightmax_windspeedtransit_speed
1NaNSubstructure Assembly Line 1Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
2NaNSubstructure Assembly Line 2Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
3NaNSubstructure Assembly Line 1Move GBF from Wet Storage to Assembly Storage0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
4NaNSubstructure Assembly Line 1Substructure Assembly0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
5NaNSubstructure Assembly Line 2Move GBF from Wet Storage to Assembly Storage0.0000000.000000ACTION0.000000GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
......................................................
2285NaNMulti-Purpose AHTS VesselPump Ballast12.00000053593.500000ACTION3932.571429GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
2289NaNMulti-Purpose AHTS VesselGrout GBF6.00000026796.750000ACTION3938.571429GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
2290NaNTowing Group 1Positioning Support24.00000037516.000000ACTION3938.571429GravityBasedInstallationNaNNaNNaN1.0NaNsiteNaNNaNNaN
2295NaNTowing Group 1Transit8.57142940195.714286ACTION3947.142857GravityBasedInstallationNaNNaNNaN3.00.0NaNNaNNaNNaN
2296NaNMulti-Purpose AHTS VesselTransit8.57142938281.071429ACTION3947.142857GravityBasedInstallationNaNNaNNaNNaNNaNNaNNaNNaNNaN
\n", + "

591 rows × 17 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent \\\n", + "1 NaN Substructure Assembly Line 1 \n", + "2 NaN Substructure Assembly Line 2 \n", + "3 NaN Substructure Assembly Line 1 \n", + "4 NaN Substructure Assembly Line 1 \n", + "5 NaN Substructure Assembly Line 2 \n", + "... ... ... \n", + "2285 NaN Multi-Purpose AHTS Vessel \n", + "2289 NaN Multi-Purpose AHTS Vessel \n", + "2290 NaN Towing Group 1 \n", + "2295 NaN Towing Group 1 \n", + "2296 NaN Multi-Purpose AHTS Vessel \n", + "\n", + " action duration cost \\\n", + "1 Substructure Assembly 0.000000 0.000000 \n", + "2 Substructure Assembly 0.000000 0.000000 \n", + "3 Move GBF from Wet Storage to Assembly Storage 0.000000 0.000000 \n", + "4 Substructure Assembly 0.000000 0.000000 \n", + "5 Move GBF from Wet Storage to Assembly Storage 0.000000 0.000000 \n", + "... ... ... ... \n", + "2285 Pump Ballast 12.000000 53593.500000 \n", + "2289 Grout GBF 6.000000 26796.750000 \n", + "2290 Positioning Support 24.000000 37516.000000 \n", + "2295 Transit 8.571429 40195.714286 \n", + "2296 Transit 8.571429 38281.071429 \n", + "\n", + " level time phase site_depth hub_height \\\n", + "1 ACTION 0.000000 GravityBasedInstallation NaN NaN \n", + "2 ACTION 0.000000 GravityBasedInstallation NaN NaN \n", + "3 ACTION 0.000000 GravityBasedInstallation NaN NaN \n", + "4 ACTION 0.000000 GravityBasedInstallation NaN NaN \n", + "5 ACTION 0.000000 GravityBasedInstallation NaN NaN \n", + "... ... ... ... ... ... \n", + "2285 ACTION 3932.571429 GravityBasedInstallation NaN NaN \n", + "2289 ACTION 3938.571429 GravityBasedInstallation NaN NaN \n", + "2290 ACTION 3938.571429 GravityBasedInstallation NaN NaN \n", + "2295 ACTION 3947.142857 GravityBasedInstallation NaN NaN \n", + "2296 ACTION 3947.142857 GravityBasedInstallation NaN NaN \n", + "\n", + " phase_name num_vessels num_ahts_vessels location max_waveheight \\\n", + "1 NaN NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "5 NaN NaN NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "2285 NaN NaN NaN NaN NaN \n", + "2289 NaN NaN NaN NaN NaN \n", + "2290 NaN 1.0 NaN site NaN \n", + "2295 NaN 3.0 0.0 NaN NaN \n", + "2296 NaN NaN NaN NaN NaN \n", + "\n", + " max_windspeed transit_speed \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "5 NaN NaN \n", + "... ... ... \n", + "2285 NaN NaN \n", + "2289 NaN NaN \n", + "2290 NaN NaN \n", + "2295 NaN NaN \n", + "2296 NaN NaN \n", + "\n", + "[591 rows x 17 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "action\n", + "Delay 1310.000000\n", + "Delay: No Substructure Storage Available 7248.286715\n", + "Delay: Not enough vessels for gravity foundations 1400.000000\n", + "Grout GBF 300.000000\n", + "Mobilize 72.000000\n", + "Move GBF from Wet Storage to Assembly Storage 0.000000\n", + "Position Substructure 250.000000\n", + "Positioning Support 2518.571429\n", + "Pump Ballast 600.000000\n", + "ROV Survey 50.000000\n", + "Substructure Assembly 0.000000\n", + "Tow Substructure 1000.000000\n", + "Transit 445.714286\n", + "Name: duration, dtype: float64" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(project_gbf_with_wtiv.actions) \n", + "project_gbf_with_wtiv_turbine_install = df.loc[df['phase']==\"TurbineInstallation\"]\n", + "project_gbf_with_wtiv_gbf_install = df.loc[df['phase']==\"GravityBasedInstallation\"]\n", + "display(project_gbf_with_wtiv_gbf_install)\n", + "project_gbf_with_wtiv_gbf_install.groupby([\"action\"]).sum()['duration']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.18" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/configs/example_gravity-based_project.yaml b/examples/configs/example_gravity-based_project.yaml new file mode 100644 index 00000000..f679d195 --- /dev/null +++ b/examples/configs/example_gravity-based_project.yaml @@ -0,0 +1,68 @@ +# Site + Plant Parameters +site: + depth: 40 # 34 COE + distance: 120 + distance_to_landfall: 50 + mean_windspeed: 9 +plant: + layout: grid + num_turbines: 50 # 40 COE + row_spacing: 7 + substation_distance: 1 + turbine_spacing: 7 +landfall: + interconnection_distance: 3 + trench_length: 2 +turbine: 15MW_generic +# Vessels +support_vessel: example_support_vessel +towing_vessel: example_towing_vessel +towing_vessel_groups: + towing_vessels: 3 + station_keeping_vessels: 2 +array_cable_install_vessel: example_cable_lay_vessel +export_cable_install_vessel: example_cable_lay_vessel +export_cable_bury_vessel: example_cable_lay_vessel +oss_install_vessel: example_heavy_lift_vessel +spi_vessel: example_scour_protection_vessel +ahts_vessel: example_ahts_vessel +#wtiv: example_wtiv # GBF installation without WTIV +# Substructure +substructure: + unit_cost: 5700000 + takt_time: 0 + #towing_speed: 6.5, considered on towing vessel file. +port: + monthly_rate: 520700 # This is the turbine assembly crane monthly rate. The port rental costs are put in as line items in the LCOE calc (where CapEx breakdown is updated) to include the summed port & quayside cost assumed at 8 months. This 8 months includeds 6 months takt time and 2 months storage (why takt is set to 0). + sub_assembly_lines: 2 # how many you can produce in parallel + turbine_assembly_cranes: 2 + sub_storage: 1 + assembly_storage: 1 +# Module Specific +OffshoreSubstationInstallation: + feeder: example_heavy_feeder + num_feeders: 1 +array_system_design: + cables: + - XLPE_185mm_66kV + - XLPE_630mm_66kV +export_system_design: + cables: XLPE_1000mm_220kV + percent_added_length: 0.5 +# Configured Phases +design_phases: +# Do not have a design phase for GBFs, we input unit_cost +#- ScourProtectionDesign, not modeled +- ArraySystemDesign +- ExportSystemDesign +- OffshoreSubstationDesign +install_phases: + ArrayCableInstallation: 0 + ExportCableInstallation: 2000 + GravityBasedInstallation: 0 + #TurbineInstallation: 0 # GBF installation without WTIV + OffshoreSubstationInstallation: 0 +# ScourProtectionInstallation: 0, not modeled +# Project Inputs +project_parameters: + turbine_capex: 1700 diff --git a/library/cables/XLPE_1200mm_220kV_dynamic.yaml b/library/cables/XLPE_1200mm_220kV_dynamic.yaml new file mode 100644 index 00000000..d3308df7 --- /dev/null +++ b/library/cables/XLPE_1200mm_220kV_dynamic.yaml @@ -0,0 +1,13 @@ +# Caveat: cable specs not from a spec sheet +# Assumed to have a cable with these costs +# and a capacity of 400 MW (seen on industry) +ac_resistance: 0.16 # ohm/km +capacitance: 190 # nF/km +conductor_size: 1200 # mm^2 +cost_per_km: 1801082 # $ +current_capacity: 1125 # A +inductance: 0.38 # mH/km +linear_density: 115 # t/km +rated_voltage: 220 # kV +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1200mm_220kV_dynamic diff --git a/library/cables/XLPE_630mm_66kV.yaml b/library/cables/XLPE_630mm_66kV.yaml index 3697f6e0..72d11be2 100644 --- a/library/cables/XLPE_630mm_66kV.yaml +++ b/library/cables/XLPE_630mm_66kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.04 capacitance: 300 conductor_size: 630 -cost_per_km: 483084 +cost_per_km: 650000 current_capacity: 775 inductance: 0.35 linear_density: 42.5 diff --git a/library/cables/XLPE_630mm_66kV_dynamic.yaml b/library/cables/XLPE_630mm_66kV_dynamic.yaml index 7a3737e8..4220f671 100644 --- a/library/cables/XLPE_630mm_66kV_dynamic.yaml +++ b/library/cables/XLPE_630mm_66kV_dynamic.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.04 capacitance: 300 conductor_size: 630 -cost_per_km: 579700 # $ (20% adder over XLPE_630mm_66kV) +cost_per_km: 780000 # $ (20% adder over XLPE_630mm_66kV) current_capacity: 775 inductance: 0.35 linear_density: 42.5 diff --git a/library/cables/dudgeon_array_no_data.csv b/library/cables/dudgeon_array_no_data.csv index 2ee8c2e0..17f6a243 100644 --- a/library/cables/dudgeon_array_no_data.csv +++ b/library/cables/dudgeon_array_no_data.csv @@ -5,65 +5,65 @@ t1,oss1,turbine-1,0.0,0.0,0,1,0,0 t2,oss1,turbine-2,0.0,0.0,0,2,0,0 t3,oss1,turbine-3,0.0,0.0,0,3,0,0 t4,oss1,turbine-4,0.0,0.0,0,4,0,0 -t5,oss1,turbine-5,0.0,0.0,0,5,0,0 -t6,oss1,turbine-6,0.0,0.0,1,0,0,0 -t7,oss1,turbine-7,0.0,0.0,1,1,0,0 -t8,oss1,turbine-8,0.0,0.0,1,2,0,0 -t9,oss1,turbine-9,0.0,0.0,1,3,0,0 -t10,oss1,turbine-10,0.0,0.0,1,4,0,0 -t11,oss1,turbine-11,0.0,0.0,1,5,0,0 -t12,oss1,turbine-12,0.0,0.0,2,0,0,0 -t13,oss1,turbine-13,0.0,0.0,2,1,0,0 -t14,oss1,turbine-14,0.0,0.0,2,2,0,0 -t15,oss1,turbine-15,0.0,0.0,2,3,0,0 -t16,oss1,turbine-16,0.0,0.0,2,4,0,0 -t17,oss1,turbine-17,0.0,0.0,2,5,0,0 -t18,oss1,turbine-18,0.0,0.0,3,0,0,0 -t19,oss1,turbine-19,0.0,0.0,3,1,0,0 -t20,oss1,turbine-20,0.0,0.0,3,2,0,0 -t21,oss1,turbine-21,0.0,0.0,3,3,0,0 -t22,oss1,turbine-22,0.0,0.0,3,4,0,0 -t23,oss1,turbine-23,0.0,0.0,3,5,0,0 -t24,oss1,turbine-24,0.0,0.0,4,0,0,0 -t25,oss1,turbine-25,0.0,0.0,4,1,0,0 -t26,oss1,turbine-26,0.0,0.0,4,2,0,0 -t27,oss1,turbine-27,0.0,0.0,4,3,0,0 -t28,oss1,turbine-28,0.0,0.0,4,4,0,0 -t29,oss1,turbine-29,0.0,0.0,4,5,0,0 -t30,oss1,turbine-30,0.0,0.0,5,0,0,0 -t31,oss1,turbine-31,0.0,0.0,5,1,0,0 -t32,oss1,turbine-32,0.0,0.0,5,2,0,0 -t33,oss1,turbine-33,0.0,0.0,5,3,0,0 -t34,oss1,turbine-34,0.0,0.0,5,4,0,0 -t35,oss1,turbine-35,0.0,0.0,5,5,0,0 -t36,oss1,turbine-36,0.0,0.0,6,0,0,0 -t37,oss1,turbine-37,0.0,0.0,6,1,0,0 -t38,oss1,turbine-38,0.0,0.0,6,2,0,0 -t39,oss1,turbine-39,0.0,0.0,6,3,0,0 -t40,oss1,turbine-40,0.0,0.0,6,4,0,0 -t41,oss1,turbine-41,0.0,0.0,6,5,0,0 -t42,oss1,turbine-42,0.0,0.0,7,0,0,0 -t43,oss1,turbine-43,0.0,0.0,7,1,0,0 -t44,oss1,turbine-44,0.0,0.0,7,2,0,0 -t45,oss1,turbine-45,0.0,0.0,7,3,0,0 -t46,oss1,turbine-46,0.0,0.0,7,4,0,0 -t47,oss1,turbine-47,0.0,0.0,7,5,0,0 -t48,oss1,turbine-48,0.0,0.0,8,0,0,0 -t49,oss1,turbine-49,0.0,0.0,8,1,0,0 -t50,oss1,turbine-50,0.0,0.0,8,2,0,0 -t51,oss1,turbine-51,0.0,0.0,8,3,0,0 -t52,oss1,turbine-52,0.0,0.0,8,4,0,0 -t53,oss1,turbine-53,0.0,0.0,8,5,0,0 -t54,oss1,turbine-54,0.0,0.0,9,0,0,0 -t55,oss1,turbine-55,0.0,0.0,9,1,0,0 -t56,oss1,turbine-56,0.0,0.0,9,2,0,0 -t57,oss1,turbine-57,0.0,0.0,9,3,0,0 -t58,oss1,turbine-58,0.0,0.0,9,4,0,0 -t59,oss1,turbine-59,0.0,0.0,9,5,0,0 -t60,oss1,turbine-60,0.0,0.0,10,0,0,0 -t61,oss1,turbine-61,0.0,0.0,10,1,0,0 -t62,oss1,turbine-62,0.0,0.0,10,2,0,0 -t63,oss1,turbine-63,0.0,0.0,10,3,0,0 -t64,oss1,turbine-64,0.0,0.0,10,4,0,0 -t65,oss1,turbine-65,0.0,0.0,10,5,0,0 -t66,oss1,turbine-66,0.0,0.0,11,0,0,0 +t5,oss1,turbine-5,0.0,0.0,1,0,0,0 +t6,oss1,turbine-6,0.0,0.0,1,1,0,0 +t7,oss1,turbine-7,0.0,0.0,1,2,0,0 +t8,oss1,turbine-8,0.0,0.0,1,3,0,0 +t9,oss1,turbine-9,0.0,0.0,1,4,0,0 +t10,oss1,turbine-10,0.0,0.0,2,0,0,0 +t11,oss1,turbine-11,0.0,0.0,2,1,0,0 +t12,oss1,turbine-12,0.0,0.0,2,2,0,0 +t13,oss1,turbine-13,0.0,0.0,2,3,0,0 +t14,oss1,turbine-14,0.0,0.0,2,4,0,0 +t15,oss1,turbine-15,0.0,0.0,3,0,0,0 +t16,oss1,turbine-16,0.0,0.0,3,1,0,0 +t17,oss1,turbine-17,0.0,0.0,3,2,0,0 +t18,oss1,turbine-18,0.0,0.0,3,3,0,0 +t19,oss1,turbine-19,0.0,0.0,3,4,0,0 +t20,oss1,turbine-20,0.0,0.0,4,0,0,0 +t21,oss1,turbine-21,0.0,0.0,4,1,0,0 +t22,oss1,turbine-22,0.0,0.0,4,2,0,0 +t23,oss1,turbine-23,0.0,0.0,4,3,0,0 +t24,oss1,turbine-24,0.0,0.0,4,4,0,0 +t25,oss1,turbine-25,0.0,0.0,5,0,0,0 +t26,oss1,turbine-26,0.0,0.0,5,1,0,0 +t27,oss1,turbine-27,0.0,0.0,5,2,0,0 +t28,oss1,turbine-28,0.0,0.0,5,3,0,0 +t29,oss1,turbine-29,0.0,0.0,5,4,0,0 +t30,oss1,turbine-30,0.0,0.0,6,0,0,0 +t31,oss1,turbine-31,0.0,0.0,6,1,0,0 +t32,oss1,turbine-32,0.0,0.0,6,2,0,0 +t33,oss1,turbine-33,0.0,0.0,6,3,0,0 +t34,oss1,turbine-34,0.0,0.0,6,4,0,0 +t35,oss1,turbine-35,0.0,0.0,7,0,0,0 +t36,oss1,turbine-36,0.0,0.0,7,1,0,0 +t37,oss1,turbine-37,0.0,0.0,7,2,0,0 +t38,oss1,turbine-38,0.0,0.0,7,3,0,0 +t39,oss1,turbine-39,0.0,0.0,7,4,0,0 +t40,oss1,turbine-40,0.0,0.0,8,0,0,0 +t41,oss1,turbine-41,0.0,0.0,8,1,0,0 +t42,oss1,turbine-42,0.0,0.0,8,2,0,0 +t43,oss1,turbine-43,0.0,0.0,8,3,0,0 +t44,oss1,turbine-44,0.0,0.0,8,4,0,0 +t45,oss1,turbine-45,0.0,0.0,9,0,0,0 +t46,oss1,turbine-46,0.0,0.0,9,1,0,0 +t47,oss1,turbine-47,0.0,0.0,9,2,0,0 +t48,oss1,turbine-48,0.0,0.0,9,3,0,0 +t49,oss1,turbine-49,0.0,0.0,9,4,0,0 +t50,oss1,turbine-50,0.0,0.0,10,0,0,0 +t51,oss1,turbine-51,0.0,0.0,10,1,0,0 +t52,oss1,turbine-52,0.0,0.0,10,2,0,0 +t53,oss1,turbine-53,0.0,0.0,10,3,0,0 +t54,oss1,turbine-54,0.0,0.0,10,4,0,0 +t55,oss1,turbine-55,0.0,0.0,11,0,0,0 +t56,oss1,turbine-56,0.0,0.0,11,1,0,0 +t57,oss1,turbine-57,0.0,0.0,11,2,0,0 +t58,oss1,turbine-58,0.0,0.0,11,3,0,0 +t59,oss1,turbine-59,0.0,0.0,11,4,0,0 +t60,oss1,turbine-60,0.0,0.0,12,0,0,0 +t61,oss1,turbine-61,0.0,0.0,12,1,0,0 +t62,oss1,turbine-62,0.0,0.0,12,2,0,0 +t63,oss1,turbine-63,0.0,0.0,12,3,0,0 +t64,oss1,turbine-64,0.0,0.0,12,4,0,0 +t65,oss1,turbine-65,0.0,0.0,13,0,0,0 +t66,oss1,turbine-66,0.0,0.0,13,1,0,0 diff --git a/library/project/config/example_custom_array_custom.yaml b/library/project/config/example_custom_array_custom.yaml index 186d80f0..a7164812 100644 --- a/library/project/config/example_custom_array_custom.yaml +++ b/library/project/config/example_custom_array_custom.yaml @@ -2,6 +2,7 @@ array_system_design: cables: - XLPE_400mm_33kV - XLPE_630mm_33kV + - XLPE_630mm_220kV location_data: dudgeon_custom plant: layout: custom diff --git a/library/project/config/example_custom_array_exclusions.yaml b/library/project/config/example_custom_array_exclusions.yaml index 27812cea..9da9f3cd 100644 --- a/library/project/config/example_custom_array_exclusions.yaml +++ b/library/project/config/example_custom_array_exclusions.yaml @@ -2,6 +2,7 @@ array_system_design: cables: - XLPE_400mm_33kV - XLPE_630mm_33kV + - XLPE_630mm_220kV location_data: dudgeon_array average_exclusion_percent: 0.05 plant: diff --git a/library/project/config/example_custom_array_project_manager.yaml b/library/project/config/example_custom_array_project_manager.yaml index 3ca16364..580de249 100644 --- a/library/project/config/example_custom_array_project_manager.yaml +++ b/library/project/config/example_custom_array_project_manager.yaml @@ -15,6 +15,7 @@ array_system_design: cables: - XLPE_400mm_33kV - XLPE_630mm_33kV + - XLPE_630mm_220kV location_data: dudgeon_custom distance: False array_cable_install_vessel: example_cable_lay_vessel diff --git a/library/project/config/example_custom_array_simple.yaml b/library/project/config/example_custom_array_simple.yaml index f456e8f2..434d1f4d 100644 --- a/library/project/config/example_custom_array_simple.yaml +++ b/library/project/config/example_custom_array_simple.yaml @@ -2,6 +2,7 @@ array_system_design: cables: - XLPE_400mm_33kV - XLPE_630mm_33kV + - XLPE_630mm_220kV location_data: dudgeon_array plant: layout: custom diff --git a/library/project/config/example_custom_array_simple_distance_based.yaml b/library/project/config/example_custom_array_simple_distance_based.yaml index b7f8315e..faafef03 100644 --- a/library/project/config/example_custom_array_simple_distance_based.yaml +++ b/library/project/config/example_custom_array_simple_distance_based.yaml @@ -2,6 +2,7 @@ array_system_design: cables: - XLPE_400mm_33kV - XLPE_630mm_33kV + - XLPE_630mm_220kV location_data: dudgeon_distance_based distance: True plant: diff --git a/library/vessels/example_towing_vessel.yaml b/library/vessels/example_towing_vessel.yaml index 938d1606..10c82e6f 100644 --- a/library/vessels/example_towing_vessel.yaml +++ b/library/vessels/example_towing_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: max_waveheight: 3.0 # m max_windspeed: 15 # m/s - transit_speed: 14 # km/h + transit_speed: 14 # km/h vessel_specs: day_rate: 37516 # USD/day diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 82ceff95..7fabe212 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -948,22 +948,22 @@ def test_project_costs(): baseline = project.project_capex config = deepcopy(complete_project) - config["project_parameters"] = {"site_auction_price": 50e6} + config["project_parameters"] = {"site_auction_price": 30e6} project = ProjectManager(config) assert project.project_capex != baseline config = deepcopy(complete_project) - config["project_parameters"] = {"site_assessment_cost": 25e6} + config["project_parameters"] = {"site_assessment_cost": 30e6} project = ProjectManager(config) assert project.project_capex != baseline config = deepcopy(complete_project) - config["project_parameters"] = {"construction_plan_cost": 25e6} + config["project_parameters"] = {"construction_plan_cost": 30e6} project = ProjectManager(config) assert project.project_capex != baseline config = deepcopy(complete_project) - config["project_parameters"] = {"installation_plan_cost": 25e6} + config["project_parameters"] = {"installation_plan_cost": 30e6} project = ProjectManager(config) assert project.project_capex != baseline @@ -995,14 +995,14 @@ def test_total_capex(): fix_project.run() assert fix_project.total_capex == pytest.approx( - 1593220043.059402, abs=1e-1 + 1843929494.9506452, abs=1e-1 ) flt_project = ProjectManager(complete_floating_project) flt_project.run() assert flt_project.total_capex == pytest.approx( - 4087665127.1458263, abs=1e-1 + 4448212431.513601, abs=1e-1 )