From 471c342691c058c318444fc7be693bcba645e884 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Thu, 8 Jul 2021 14:49:18 -0600 Subject: [PATCH 001/240] Initial commit. --- ORBIT/phases/design/__init__.py | 1 + ORBIT/phases/design/electrical_export.py | 98 ++++++++++++++++++++++++ library/cables/XLPE_630mm_66kV.yaml | 1 + 3 files changed, 100 insertions(+) create mode 100644 ORBIT/phases/design/electrical_export.py diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index d234df4c..8ef543e0 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -10,6 +10,7 @@ from .oss_design import OffshoreSubstationDesign from .spar_design import SparDesign from .monopile_design import MonopileDesign +from .electrical_export import ElectricalDesign from .array_system_design import ArraySystemDesign, CustomArraySystemDesign from .export_system_design import ExportSystemDesign from .mooring_system_design import MooringSystemDesign diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py new file mode 100644 index 00000000..e9f78bb1 --- /dev/null +++ b/ORBIT/phases/design/electrical_export.py @@ -0,0 +1,98 @@ +__author__ = [] +__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" +__maintainer__ = "" +__email__ = [] + + +from ORBIT.core.library import extract_library_specs +from ORBIT.phases.design import DesignPhase + +INPUTS = {} + + +class ElectricalDesign(DesignPhase): + """Template Design Phase""" + + expected_config = { + "site": {"depth": "m"}, + "plant": {"num_turbines": "int", "capacity": "MW"}, + "turbine": {"turbine_rating": "MW"}, + "new_electrical_inputs": {"inputa": "optional", "inputb": "optional"}, + "export_system_design": { + "cables": "str", + "num_redundant": "int (optional)", + "touchdown_distance": "m (optional, default: 0)", + "percent_added_length": "float (optional)", + }, + } + + output_config = { + # "offshore_substation_topside": { + # "deck_space": "m2", + # "mass": "t", + # "unit_cost": "USD", + # }, + # "offshore_substation_substructure": { + # "type": "Monopile", + # "deck_space": "m2", + # "mass": "t", + # "length": "m", + # "unit_cost": "USD", + # }, + # "export_system": { + # "cable": { + # "linear_density": "t/km", + # "sections": [("length, km", "speed, km/h (optional)")], + # "number": "int (optional)", + # }, + # }, + } + + def __init__(self, config, **kwargs): + """Creates an instance of `TemplateDesign`.""" + + config = self.initialize_library(config, **kwargs) + self.config = self.validate_config(config) + + self._outputs = {} + self._export_design = self.config["export_system_design"] + self.initialize_cables() + + def run(self): + """Main run function.""" + + self.example_computation() + + def example_computation(self): + """Example computation method.""" + + depth = self.config["site"]["depth"] + var2 = self.config.get("optional_input", "default") + + self.result = var1 + var2 + self._outputs["example_output"] = self.result + + def initialize_cables(self): + + self.cable = extract_library_specs( + "cables", self._export_design["cables"] + ) + + @property + def detailed_output(self): + """Returns detailed output dictionary.""" + + return {"example_detailed_output": self.result} + + @property + def total_cost(self): + """Returns total cost of subcomponent(s).""" + + num_turbines = 100 # Where applicable + return self.result * num_turbines + + @property + def design_result(self): + """Must match `self.output_config` structure.""" + + return {"example_output": self.result} diff --git a/library/cables/XLPE_630mm_66kV.yaml b/library/cables/XLPE_630mm_66kV.yaml index fa5dcc22..150a0149 100644 --- a/library/cables/XLPE_630mm_66kV.yaml +++ b/library/cables/XLPE_630mm_66kV.yaml @@ -7,3 +7,4 @@ inductance: 0.35 linear_density: 42.5 name: XLPE_630mm_66kV rated_voltage: 66 +switchgear_cost: 1e6 From fc50640f7dbd6c97ea4e8e694d6f760a6d3c0490 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Mon, 12 Jul 2021 16:36:26 -0600 Subject: [PATCH 002/240] export cable functions, diameter calc --- ORBIT/phases/design/electrical_export.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index e9f78bb1..957c822c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -71,6 +71,26 @@ def example_computation(self): self.result = var1 + var2 self._outputs["example_output"] = self.result + + def number_cables(self): + """Returns number of export cables.""" + + # max_cap = 181.5 MW **220kV * 825A** + # project_cap = self.config[""] + # + # num_cables = ceiling(project_cap/max_cap) + # + # + + def cable_current(self): + """Returns cabel current rating.""" + + # cable_cap = project_cap / num_cables + # cable_current = cable_cap / cable_voltage + # + # current -> diameter + # + # def initialize_cables(self): From f3bf3f2fad58eec65be27590ab432887ec4b1895 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Mon, 19 Jul 2021 17:27:34 -0600 Subject: [PATCH 003/240] new hvac cables for lib and some substation cost scaffolding --- library/cables/XLPE_500mm_220kV.yaml | 9 +++++++++ library/cables/XLPE_630mm_220kV.yaml | 9 +++++++++ library/cables/XLPE_800mm_220kV.yaml | 9 +++++++++ library/cables/XPLE_800mm_220kV.yaml | 9 +++++++++ 4 files changed, 36 insertions(+) create mode 100644 library/cables/XLPE_500mm_220kV.yaml create mode 100644 library/cables/XLPE_630mm_220kV.yaml create mode 100644 library/cables/XLPE_800mm_220kV.yaml create mode 100644 library/cables/XPLE_800mm_220kV.yaml diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml new file mode 100644 index 00000000..5619d51d --- /dev/null +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -0,0 +1,9 @@ +ac_resistance: 0.03 # ohm/km +capacitance: 140 # nF/km +conductor_size: 500 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 655 # A +inductance: 0.43 # mH/km +linear_density: 90 # t/km +name: XLPE_500mm_220kV +rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml new file mode 100644 index 00000000..8b93a4df --- /dev/null +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -0,0 +1,9 @@ +ac_resistance: 0.25 # ohm/km +capacitance: 160 # nF/km +conductor_size: 630 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 655 # A +inductance: 0.41 # mH/km +linear_density: 90 # t/km +name: XLPE_630mm_220kV +rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml new file mode 100644 index 00000000..4ba3bf33 --- /dev/null +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -0,0 +1,9 @@ +ac_resistance: 0.20 # ohm/km +capacitance: 170 # nF/km +conductor_size: 800 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 655 # A +inductance: 0.40 # mH/km +linear_density: 90 # t/km +name: XLPE_800mm_220kV +rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XPLE_800mm_220kV.yaml b/library/cables/XPLE_800mm_220kV.yaml new file mode 100644 index 00000000..4ba3bf33 --- /dev/null +++ b/library/cables/XPLE_800mm_220kV.yaml @@ -0,0 +1,9 @@ +ac_resistance: 0.20 # ohm/km +capacitance: 170 # nF/km +conductor_size: 800 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 655 # A +inductance: 0.40 # mH/km +linear_density: 90 # t/km +name: XLPE_800mm_220kV +rated_voltage: 220 \ No newline at end of file From 0b2fa24f989087fdb55f82f8a5556b5a0f2a214f Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Mon, 19 Jul 2021 17:31:37 -0600 Subject: [PATCH 004/240] substation scaffolding updates pt 2 --- ORBIT/phases/design/electrical_export.py | 97 ++++++++++++++++-------- library/cables/XLPE_1000m_220kV.yaml | 14 ++-- library/cables/XPLE_800mm_220kV.yaml | 9 --- 3 files changed, 73 insertions(+), 47 deletions(-) delete mode 100644 library/cables/XPLE_800mm_220kV.yaml diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 957c822c..2c2bd85a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -3,6 +3,7 @@ __maintainer__ = "" __email__ = [] +import numpy as np from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import DesignPhase @@ -39,13 +40,23 @@ class ElectricalDesign(DesignPhase): # "length": "m", # "unit_cost": "USD", # }, - # "export_system": { - # "cable": { - # "linear_density": "t/km", - # "sections": [("length, km", "speed, km/h (optional)")], - # "number": "int (optional)", - # }, + + # "offshore_substation_electrical":{ + # "switchgear": "int", + # "compensation": "int", + # "transformer": "int", + + # }, + + "export_system": { + "cable": { + "linear_density": "t/km", + "sections": [("length, km", "speed, km/h (optional)")], + "number": "int (optional)", + "diameter": "int", + }, + }, } def __init__(self, config, **kwargs): @@ -54,49 +65,73 @@ def __init__(self, config, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) - self._outputs = {} + self._plant_capacity = self.config["plant"]["capacity"] + # self.max_cable_capacity = 181.5 # MW , 220kV * 825A self._export_design = self.config["export_system_design"] self.initialize_cables() def run(self): """Main run function.""" - self.example_computation() - - def example_computation(self): - """Example computation method.""" + self.initialize_cables() + self.cable = self.cables[[*self.cables][0]] + self.compute_number_cables() + self.compute_cable_diameter() + self.compute_cable_length() + + def compute_number_cables(self): + """ + Calculate the total number of required and redundant cables to + transmit power to the onshore interconnection. + """ - depth = self.config["site"]["depth"] - var2 = self.config.get("optional_input", "default") + num_required = np.ceil(self._plant_capacity / self.cable.cable_power) + num_redundant = self._design.get("num_redundant", 0) - self.result = var1 + var2 - self._outputs["example_output"] = self.result + self.num_cables = int(num_required + num_redundant) - def number_cables(self): - """Returns number of export cables.""" + def compute_cable_current(self): + """Computes cable diameter.""" - # max_cap = 181.5 MW **220kV * 825A** - # project_cap = self.config[""] - # - # num_cables = ceiling(project_cap/max_cap) - # - # + cable_cap = self._plant_capacity / self.num_cables + self.cable_current = cable_cap / self.cable.rated_voltage # cable_voltage - def cable_current(self): - """Returns cabel current rating.""" + # Using line of best fit + # self.cable_diameter = 36.958 * np.exp(0.004 * cable_current) + + def compute_cable_length(self): + """ + Calculates the total distance an export cable must travel. + """ + + added_length = 1.0 + self._design.get("percent_added_length", 0.0) + self.length = round( + ( + self.free_cable_length + + (self._distance_to_landfall - self.touchdown / 1000) + + self._distance_to_interconnection + ) + * added_length, + 10, + ) + + def compute_oss_electrical_components(self): + """"Computes number of offshore substation electrical components.""" + + self.num_switchgear = self.num_cables * 2 - # cable_cap = project_cap / num_cables - # cable_current = cable_cap / cable_voltage - # - # current -> diameter - # - # + # dependent on plant capacity + self.num_transformers = int + self.num_compensation = int + def initialize_cables(self): self.cable = extract_library_specs( "cables", self._export_design["cables"] ) + + @property def detailed_output(self): diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index 62fc48e3..3d23b77e 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -1,9 +1,9 @@ -ac_resistance: 0.03 # -capacitance: 300 # -conductor_size: 1000 # -cost_per_km: 850000 # -current_capacity: 900 # Guess -inductance: 0.35 # -linear_density: 90 # From BVG Guide to OSW +ac_resistance: 0.16 # ohm/km +capacitance: 190 # nF/km +conductor_size: 1000 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 825 # A +inductance: 0.38 # mH/km +linear_density: 90 # t/km name: XLPE_1000m_220kV rated_voltage: 220 diff --git a/library/cables/XPLE_800mm_220kV.yaml b/library/cables/XPLE_800mm_220kV.yaml deleted file mode 100644 index 4ba3bf33..00000000 --- a/library/cables/XPLE_800mm_220kV.yaml +++ /dev/null @@ -1,9 +0,0 @@ -ac_resistance: 0.20 # ohm/km -capacitance: 170 # nF/km -conductor_size: 800 # mm^2 -cost_per_km: 850000 # $ -current_capacity: 655 # A -inductance: 0.40 # mH/km -linear_density: 90 # t/km -name: XLPE_800mm_220kV -rated_voltage: 220 \ No newline at end of file From 4c6f8e81005ae135627af6aa3ec0d0528b104e8b Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Wed, 21 Jul 2021 10:10:31 -0600 Subject: [PATCH 005/240] update to cable lib --- library/cables/XLPE_630mm_220kV.yaml | 2 +- library/cables/XLPE_800mm_220kV.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index 8b93a4df..bfe09c5d 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.25 # ohm/km capacitance: 160 # nF/km conductor_size: 630 # mm^2 cost_per_km: 850000 # $ -current_capacity: 655 # A +current_capacity: 715 # A inductance: 0.41 # mH/km linear_density: 90 # t/km name: XLPE_630mm_220kV diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index 4ba3bf33..a6d4ebd6 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.20 # ohm/km capacitance: 170 # nF/km conductor_size: 800 # mm^2 cost_per_km: 850000 # $ -current_capacity: 655 # A +current_capacity: 775 # A inductance: 0.40 # mH/km linear_density: 90 # t/km name: XLPE_800mm_220kV From 6aa576711e2572d140b9045ed29e4b1c6b1e3d63 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Wed, 21 Jul 2021 10:20:34 -0600 Subject: [PATCH 006/240] more scaffolding for substation --- ORBIT/phases/design/electrical_export.py | 89 +++++++++++++++++------- 1 file changed, 65 insertions(+), 24 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 2c2bd85a..8f0a4154 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -75,11 +75,14 @@ def run(self): self.initialize_cables() self.cable = self.cables[[*self.cables][0]] - self.compute_number_cables() - self.compute_cable_diameter() - self.compute_cable_length() + self.calc_number_cables() + self.calc_cable_diameter() + self.calc_cable_length() - def compute_number_cables(self): + + #################### CABLES ######################## + + def calc_number_cables(self): """ Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. @@ -89,17 +92,8 @@ def compute_number_cables(self): num_redundant = self._design.get("num_redundant", 0) self.num_cables = int(num_required + num_redundant) - - def compute_cable_current(self): - """Computes cable diameter.""" - - cable_cap = self._plant_capacity / self.num_cables - self.cable_current = cable_cap / self.cable.rated_voltage # cable_voltage - - # Using line of best fit - # self.cable_diameter = 36.958 * np.exp(0.004 * cable_current) - def compute_cable_length(self): + def calc_cable_length(self): """ Calculates the total distance an export cable must travel. """ @@ -115,22 +109,69 @@ def compute_cable_length(self): 10, ) - def compute_oss_electrical_components(self): - """"Computes number of offshore substation electrical components.""" - - self.num_switchgear = self.num_cables * 2 - - # dependent on plant capacity - self.num_transformers = int - self.num_compensation = int - - def initialize_cables(self): self.cable = extract_library_specs( "cables", self._export_design["cables"] ) + #################### SUBSTATION #################### + + + def calc_num_substation(self): + """Computes number of substations""" + self.num_substations = self._plant_capacity / 800 # store this somewhere else? + + + + + + @property + def substation_cost(self): + """Returns total procuremet cost of the topside.""" + + return ( + self.mpt_cost + + self.shunt_reactor_cost + + self.switchgear_costs + + self.topside_cost + + self.ancillary_system_costs + + self.land_assembly_cost + ) + + def calc_mpt_cost(self): + """Computes transformer cost""" + num_mpt = self.num_cables + # self.mpt_cost = num_mpt * cost_mpt(cable) + + + def calc_shunt_reactor_cost(self): + """Computes shunt reactor cost""" + # get distance to shore + dist2shore = self._export_design.touchdown_distance # meters + # compensation = dist2shore * scaling_factor # MW + # self.shunt_reactor_cost = cost_sr(MW) * compensation + + def calc_switchgear_costs(self): + """Computes switchgear cost""" + + num_swtichgear = self.num_cables + # self.swtichgear_costs = num_switchgear * cost_sg(cable) + + def calc_topside_cost(self): + """Computes topside cost""" + + + def calc_ancillary_system_cost(self): + """Copmutes ancillary system cost""" + + + # def calc_land_assembly_cost(self): include? + # """Computes land assembly cost""" + + + + @property From 38069cafdf5f9aa9a9b4b69cdcba984cd8102f49 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Tue, 27 Jul 2021 15:55:03 -0600 Subject: [PATCH 007/240] added compensation factor to lib and cost estimations to electrical_export --- ORBIT/phases/design/_cables.py | 3 +++ ORBIT/phases/design/electrical_export.py | 16 ++++++---------- library/cables/XLPE_1000m_220kV.yaml | 15 ++++++++------- library/cables/XLPE_500mm_220kV.yaml | 15 ++++++++------- library/cables/XLPE_630mm_220kV.yaml | 15 ++++++++------- library/cables/XLPE_800mm_220kV.yaml | 15 ++++++++------- 6 files changed, 41 insertions(+), 38 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 27343a58..f1774c77 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -36,6 +36,8 @@ class Cable: Cable capacitance, :math:`\\frac{nF}{km}`. linear_density : float Dry mass per kilometer, :math:`\\frac{tonnes}{km}`. + compensation_factor : float + Required reactive power compensation per km, :math: `\\frac{MVAr}{km} cost_per_km : int Cable cost per kilometer, :math:`\\frac{USD}{km}`. char_impedance : float @@ -56,6 +58,7 @@ class Cable: "inductance", "capacitance", "linear_density", + "compensation_factor", "cost_per_km", "name", ) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 8f0a4154..4e4ed740 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -121,10 +121,7 @@ def initialize_cables(self): def calc_num_substation(self): """Computes number of substations""" self.num_substations = self._plant_capacity / 800 # store this somewhere else? - - - - + @property def substation_cost(self): @@ -142,21 +139,20 @@ def substation_cost(self): def calc_mpt_cost(self): """Computes transformer cost""" num_mpt = self.num_cables - # self.mpt_cost = num_mpt * cost_mpt(cable) + self.mpt_cost = num_mpt * 1750000 def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" # get distance to shore - dist2shore = self._export_design.touchdown_distance # meters - # compensation = dist2shore * scaling_factor # MW - # self.shunt_reactor_cost = cost_sr(MW) * compensation + compensation = self.export_system_design.touchdown_distance * self.cables.compensation_factor # MW + self.shunt_reactor_cost = compensation * 120000 def calc_switchgear_costs(self): """Computes switchgear cost""" - num_swtichgear = self.num_cables - # self.swtichgear_costs = num_switchgear * cost_sg(cable) + num_switchgear = self.num_cables + self.swtichgear_costs = num_switchgear * 134000 def calc_topside_cost(self): """Computes topside cost""" diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index 3d23b77e..19256e9c 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -1,9 +1,10 @@ -ac_resistance: 0.16 # ohm/km -capacitance: 190 # nF/km -conductor_size: 1000 # mm^2 -cost_per_km: 850000 # $ -current_capacity: 825 # A -inductance: 0.38 # mH/km -linear_density: 90 # t/km +ac_resistance: 0.16 # ohm/km +capacitance: 190 # nF/km +conductor_size: 1000 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 825 # A +inductance: 0.38 # mH/km +linear_density: 90 # t/km +compensation_factor: 3.17 # MVAr/km name: XLPE_1000m_220kV rated_voltage: 220 diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index 5619d51d..ae206faf 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -1,9 +1,10 @@ -ac_resistance: 0.03 # ohm/km -capacitance: 140 # nF/km -conductor_size: 500 # mm^2 -cost_per_km: 850000 # $ -current_capacity: 655 # A -inductance: 0.43 # mH/km -linear_density: 90 # t/km +ac_resistance: 0.03 # ohm/km +capacitance: 140 # nF/km +conductor_size: 500 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 655 # A +inductance: 0.43 # mH/km +linear_density: 90 # t/km +compensation_factor: 2.35 # MVAr/km name: XLPE_500mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index bfe09c5d..be52391a 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -1,9 +1,10 @@ -ac_resistance: 0.25 # ohm/km -capacitance: 160 # nF/km -conductor_size: 630 # mm^2 -cost_per_km: 850000 # $ -current_capacity: 715 # A -inductance: 0.41 # mH/km -linear_density: 90 # t/km +ac_resistance: 0.25 # ohm/km +capacitance: 160 # nF/km +conductor_size: 630 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 715 # A +inductance: 0.41 # mH/km +linear_density: 90 # t/km +compensation_factor: 2.68 # MVAr/km name: XLPE_630mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index a6d4ebd6..bff89d12 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -1,9 +1,10 @@ -ac_resistance: 0.20 # ohm/km -capacitance: 170 # nF/km -conductor_size: 800 # mm^2 -cost_per_km: 850000 # $ -current_capacity: 775 # A -inductance: 0.40 # mH/km -linear_density: 90 # t/km +ac_resistance: 0.20 # ohm/km +capacitance: 170 # nF/km +conductor_size: 800 # mm^2 +cost_per_km: 850000 # $ +current_capacity: 775 # A +inductance: 0.40 # mH/km +linear_density: 90 # t/km +compensation_factor: 2.83 # MVAr/km name: XLPE_800mm_220kV rated_voltage: 220 \ No newline at end of file From f7c86f36d2dea2da840030e118bc0ae8dffa00d8 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Fri, 30 Jul 2021 17:23:34 -0600 Subject: [PATCH 008/240] added compensation factor to _cables.py, progress on ElectricalDesign --- ORBIT/phases/design/__init__.py | 1 + ORBIT/phases/design/_cables.py | 15 +- ORBIT/phases/design/electrical_export.py | 390 +++++++++++++++++++---- library/cables/XLPE_1000m_220kV.yaml | 3 +- library/cables/XLPE_500mm_220kV.yaml | 1 - library/cables/XLPE_630mm_220kV.yaml | 3 +- library/cables/XLPE_800mm_220kV.yaml | 3 +- 7 files changed, 337 insertions(+), 79 deletions(-) diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 8ef543e0..120d1e83 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -16,3 +16,4 @@ from .mooring_system_design import MooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign +from .electrical_export import ElectricalDesign diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index f1774c77..f3900ef6 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -36,8 +36,6 @@ class Cable: Cable capacitance, :math:`\\frac{nF}{km}`. linear_density : float Dry mass per kilometer, :math:`\\frac{tonnes}{km}`. - compensation_factor : float - Required reactive power compensation per km, :math: `\\frac{MVAr}{km} cost_per_km : int Cable cost per kilometer, :math:`\\frac{USD}{km}`. char_impedance : float @@ -58,7 +56,6 @@ class Cable: "inductance", "capacitance", "linear_density", - "compensation_factor", "cost_per_km", "name", ) @@ -92,6 +89,7 @@ def __init__(self, cable_specs, **kwargs): self.calc_char_impedance(**kwargs) self.calc_power_factor() self.calc_cable_power() + self.calc_compensation_factor() def calc_char_impedance(self): """ @@ -131,7 +129,16 @@ def calc_cable_power(self): * self.power_factor / 1000 ) - + + def calc_compensation_factor(self): + """ + Calculate compensation factor for shunt reactor cost + """ + capacitive_reactance = 1 / (2 * np.pi * self.line_frequency * (self.capacitance / 10e6)) + capacitive_losses = self.rated_voltage ** 2 / capacitive_reactance + inductive_reactance = 2 * np.pi * self.line_frequency * (self.inductance / 1000) + inductive_losses = 3 * inductive_reactance * self.current_capacity ** 2 + self.compensation_factor = capacitive_losses - inductive_losses class Plant: """ diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 4e4ed740..c124da10 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -1,53 +1,72 @@ -__author__ = [] +__author__ = ["Sophie Bredenkamp"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "" __email__ = [] import numpy as np -from ORBIT.core.library import extract_library_specs +# from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import DesignPhase +from ORBIT.phases.design._cables import CableSystem -INPUTS = {} - -class ElectricalDesign(DesignPhase): - """Template Design Phase""" +class ElectricalDesign(DesignPhase, CableSystem): + """ + Design phase for export cabling and offshore substation systems. + + Attributes + ---------- + num_cables : int + Total number of cables required for transmitting power. + length : float + Length of a single cable connecting the OSS to the interconnection in km. + mass : float + Mass of `length` in tonnes. + cable : `Cable` + Instance of `ORBIT.phases.design.Cable`. An export system will + only require a single type of cable. + total_length : float + Total length of cable required to trasmit power. + total_mass : float + Total mass of cable required to transmit power. + sections_cables : np.ndarray, shape: (`num_cables, ) + An array of `cable`. + sections_lengths : np.ndarray, shape: (`num_cables, ) + An array of `length`. + + """ expected_config = { - "site": {"depth": "m"}, - "plant": {"num_turbines": "int", "capacity": "MW"}, - "turbine": {"turbine_rating": "MW"}, - "new_electrical_inputs": {"inputa": "optional", "inputb": "optional"}, + "site": {"distance_to_landfall": "km", "depth": "m"}, + "landfall": {"interconnection_distance": "km (optional)"}, + "plant": {"capacity": "MW"}, "export_system_design": { "cables": "str", "num_redundant": "int (optional)", "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", }, + "substation_design": { + "mpt_cost_rate": "USD/MW (optional)", + "topside_fab_cost_rate": "USD/t (optional)", + "topside_design_cost": "USD (optional)", + "shunt_cost_rate": "USD/MW (optional)", + "switchgear_cost": "USD (optional)", + "backup_gen_cost": "USD (optional)", + "workspace_cost": "USD (optional)", + "other_ancillary_cost": "USD (optional)", + "topside_assembly_factor": "float (optional)", + "oss_substructure_cost_rate": "USD/t (optional)", + "oss_pile_cost_rate": "USD/t (optional)", + "num_substations": "int (optional)", + }, } output_config = { - # "offshore_substation_topside": { - # "deck_space": "m2", - # "mass": "t", - # "unit_cost": "USD", - # }, - # "offshore_substation_substructure": { - # "type": "Monopile", - # "deck_space": "m2", - # "mass": "t", - # "length": "m", - # "unit_cost": "USD", - # }, - - # "offshore_substation_electrical":{ - # "switchgear": "int", - # "compensation": "int", - # "transformer": "int", - - - # }, + + "num_substations": "int", + "offshore_substation_topside": "dict", + "offshore_substation_substructure": "dict", "export_system": { "cable": { @@ -65,24 +84,122 @@ def __init__(self, config, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) + # CABLES + super().__init__(config, "export", **kwargs) + + for name in self.expected_config["site"]: + setattr(self, "".join(("_", name)), config["site"][name]) + self._depth = config["site"]["depth"] + self._distance_to_landfall = config["site"]["distance_to_landfall"] self._plant_capacity = self.config["plant"]["capacity"] - # self.max_cable_capacity = 181.5 # MW , 220kV * 825A - self._export_design = self.config["export_system_design"] - self.initialize_cables() + self._get_touchdown_distance() + + try: + self._distance_to_interconnection = config["landfall"][ + "interconnection_distance" + ] + except KeyError: + self._distance_to_interconnection = 3 + + # SUBSTATION + self._outputs = {} def run(self): """Main run function.""" - - self.initialize_cables() + + # CABLES + self._initialize_cables() self.cable = self.cables[[*self.cables][0]] - self.calc_number_cables() - self.calc_cable_diameter() - self.calc_cable_length() + self.compute_number_cables() + self.compute_cable_length() + self.compute_cable_mass() + self.compute_total_cable() + + for name, cable in self.cables.items(): + self._outputs["export_system"]["cable"] = { + "linear_density": cable.linear_density, + "sections": [self.length], + "number": self.num_cables, + "cable_power": cable.cable_power, + } + # self._outputs["export_system"] = { + # "power_factor": self.cables.power_factor, + # "interconnection_distance": self._distance_to_interconnection, + # "system_cost": self.total_cost, + # } + # SUBSTATION + self.calc_substructure_length() + self.calc_substructure_deck_space() + self.calc_topside_deck_space() + + self.calc_num_mpt_and_rating() + self.calc_mpt_cost() + self.calc_topside_mass_and_cost() + self.calc_shunt_reactor_cost() + self.calc_switchgear_cost() + self.calc_ancillary_system_cost() + self.calc_assembly_cost() + self.calc_substructure_mass_and_cost() + + self._outputs["offshore_substation_substructure"] = { + "type": "Monopile", # Substation install only supports monopiles + "deck_space": self.substructure_deck_space, + "mass": self.substructure_mass, + "length": self.substructure_length, + "unit_cost": self.substructure_cost, + } + + self._outputs["offshore_substation_topside"] = { + "deck_space": self.topside_deck_space, + "mass": self.topside_mass, + "unit_cost": self.substation_cost, + } + + self._outputs["num_substations"] = self.num_substations + + + @property + def detailed_output(self): + """Returns export system design outputs.""" + + _output = { + **self.design_result, + "export_system_total_mass": self.total_mass, + "export_system_total_length": self.total_length, + "export_system_total_cost": self.total_cable_cost, + "export_system_cable_power": self.cable.cable_power, + "num_substations": self.num_substations, + "substation_mpt_rating": self.mpt_rating, + "substation_topside_mass": self.topside_mass, + "substation_topside_cost": self.topside_cost, + "substation_substructure_mass": self.substructure_mass, + "substation_substructure_cost": self.substructure_cost, + } + + return _output + + @property + def design_result(self): + """ + Returns the results of self.run(). + """ + if not self._outputs: + raise Exception("Has OffshoreSubstationDesign been ran yet?") + + return self._outputs + #################### CABLES ######################## - def calc_number_cables(self): + @property + def total_cable_cost(self): + """Returns total array system cable cost.""" + + return sum(self.cost_by_type.values()) + + + def compute_number_cables(self): """ Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. @@ -92,8 +209,8 @@ def calc_number_cables(self): num_redundant = self._design.get("num_redundant", 0) self.num_cables = int(num_required + num_redundant) - - def calc_cable_length(self): + + def compute_cable_length(self): """ Calculates the total distance an export cable must travel. """ @@ -108,19 +225,60 @@ def calc_cable_length(self): * added_length, 10, ) - - def initialize_cables(self): - self.cable = extract_library_specs( - "cables", self._export_design["cables"] - ) - + def compute_cable_mass(self): + """ + Calculates the total mass of a single length of export cable. + """ + + self.mass = round(self.length * self.cable.linear_density, 10) + + def compute_total_cable(self): + """ + Calculates the total length and mass of cables required to fully + connect the OSS to the interconnection point. + """ + + self.total_length = round(self.num_cables * self.length, 10) + self.total_mass = round(self.num_cables * self.mass, 10) + + @property + def sections_cable_lengths(self): + """ + Creates an array of section lengths to work with `CableSystem` + + Returns + ------- + np.ndarray + Array of `length` with shape (`num_cables`, ). + """ + return np.full(self.num_cables, self.length) + + @property + def sections_cables(self): + """ + Creates an array of cable names to work with `CableSystem`. + + Returns + ------- + np.ndarray + Array of `cable.name` with shape (`num_cables`, ). + """ + + return np.full(self.num_cables, self.cable.name) + + + + #################### SUBSTATION #################### def calc_num_substation(self): """Computes number of substations""" - self.num_substations = self._plant_capacity / 800 # store this somewhere else? + _design = self.config.get("substation_design",{}) + self.num_substations = _design.get( + "num_substations", int(np.ceil(self._plant_capacity / 800)) + ) @property @@ -130,9 +288,9 @@ def substation_cost(self): return ( self.mpt_cost + self.shunt_reactor_cost - + self.switchgear_costs + + self.switchgear_cost + self.topside_cost - + self.ancillary_system_costs + + self.ancillary_system_cost + self.land_assembly_cost ) @@ -140,15 +298,27 @@ def calc_mpt_cost(self): """Computes transformer cost""" num_mpt = self.num_cables self.mpt_cost = num_mpt * 1750000 + self.mpt_rating = ( + round( + ( + self._plant_capacity / (num_mpt * self.num_substation) + ) + /10.0 + ) + * 10.0 + ) def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" # get distance to shore - compensation = self.export_system_design.touchdown_distance * self.cables.compensation_factor # MW + compensation = ( + self.export_system_design.touchdown_distance + * self.cables.compensation_factor + ) # MW self.shunt_reactor_cost = compensation * 120000 - def calc_switchgear_costs(self): + def calc_switchgear_cost(self): """Computes switchgear cost""" num_switchgear = self.num_cables @@ -156,35 +326,119 @@ def calc_switchgear_costs(self): def calc_topside_cost(self): """Computes topside cost""" + self.topside_cost = 1 def calc_ancillary_system_cost(self): - """Copmutes ancillary system cost""" + """ + Calculates cost of ancillary systems. + + Parameters + ---------- + backup_gen_cost : int | float + workspace_cost : int | float + other_ancillary_cost : int | float + """ + + _design = self.config.get("substation_design", {}) + backup_gen_cost = _design.get("backup_gen_cost", 1e6) + workspace_cost = _design.get("workspace_cost", 2e6) + other_ancillary_cost = _design.get("other_ancillary_cost", 3e6) + + self.ancillary_system_costs = ( + backup_gen_cost + workspace_cost + other_ancillary_cost + ) + def calc_assembly_cost(self): + """ + Calculates the cost of assembly on land. + + Parameters + ---------- + topside_assembly_factor : int | float + """ + + _design = self.config.get("substation_design", {}) + topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) + self.land_assembly_cost = ( + self.switchgear_costs + + self.shunt_reactor_cost + + self.ancillary_system_costs + ) * topside_assembly_factor - # def calc_land_assembly_cost(self): include? - # """Computes land assembly cost""" - - - + def calc_substructure_mass_and_cost(self): + """ + Calculates the mass and associated cost of the substation substructure. + + Parameters + ---------- + oss_substructure_cost_rate : int | float + oss_pile_cost_rate : int | float + """ + + _design = self.config.get("substation_design", {}) + oss_substructure_cost_rate = _design.get( + "oss_substructure_cost_rate", 3000 + ) + oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + + substructure_mass = 0.4 * self.topside_mass + substructure_pile_mass = 8 * substructure_mass ** 0.5574 + self.substructure_cost = ( + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate + ) + + self.substructure_mass = substructure_mass + substructure_pile_mass + def calc_substructure_length(self): + """ + Calculates substructure length as the site depth + 10m + """ + + self.substructure_length = self.config["site"]["depth"] + 10 + + def calc_substructure_deck_space(self): + """ + Calculates required deck space for the substation substructure. + + Coming soon! + """ + + self.substructure_deck_space = 1 + + def calc_topside_deck_space(self): + """ + Calculates required deck space for the substation topside. + + Coming soon! + """ + + self.topside_deck_space = 1 + def calc_topside_mass_and_cost(self): + """ + Calculates the mass and cost of the substation topsides. - @property - def detailed_output(self): - """Returns detailed output dictionary.""" + Parameters + ---------- + topside_fab_cost_rate : int | float + topside_design_cost: int | float + """ + + _design = self.config.get("substation_design", {}) + topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) + topside_design_cost = _design.get("topside_design_cost", 4.5e6) - return {"example_detailed_output": self.result} + self.topside_mass = 3.85 * self.mpt_rating * self.num_mpt + 285 + self.topside_cost = ( + self.topside_mass * topside_fab_cost_rate + topside_design_cost + ) @property - def total_cost(self): + def total_oss_cost(self): """Returns total cost of subcomponent(s).""" num_turbines = 100 # Where applicable return self.result * num_turbines - @property - def design_result(self): - """Must match `self.output_config` structure.""" - - return {"example_output": self.result} diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index 19256e9c..4d22f6ab 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -4,7 +4,6 @@ conductor_size: 1000 # mm^2 cost_per_km: 850000 # $ current_capacity: 825 # A inductance: 0.38 # mH/km -linear_density: 90 # t/km -compensation_factor: 3.17 # MVAr/km +linear_density: 115 # t/km name: XLPE_1000m_220kV rated_voltage: 220 diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index ae206faf..a7ae0326 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -5,6 +5,5 @@ cost_per_km: 850000 # $ current_capacity: 655 # A inductance: 0.43 # mH/km linear_density: 90 # t/km -compensation_factor: 2.35 # MVAr/km name: XLPE_500mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index be52391a..6b2852b6 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -4,7 +4,6 @@ conductor_size: 630 # mm^2 cost_per_km: 850000 # $ current_capacity: 715 # A inductance: 0.41 # mH/km -linear_density: 90 # t/km -compensation_factor: 2.68 # MVAr/km +linear_density: 96 # t/km name: XLPE_630mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index bff89d12..80aaf58c 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -4,7 +4,6 @@ conductor_size: 800 # mm^2 cost_per_km: 850000 # $ current_capacity: 775 # A inductance: 0.40 # mH/km -linear_density: 90 # t/km -compensation_factor: 2.83 # MVAr/km +linear_density: 105 # t/km name: XLPE_800mm_220kV rated_voltage: 220 \ No newline at end of file From db54da9e5aa88eaa6e40ceb7d1ddda3e1fadd018 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Fri, 30 Jul 2021 17:24:42 -0600 Subject: [PATCH 009/240] test --- ORBIT/phases/design/electrical_export.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index c124da10..867d020c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -128,7 +128,6 @@ def run(self): # "system_cost": self.total_cost, # } - # SUBSTATION self.calc_substructure_length() self.calc_substructure_deck_space() From 2d75942c05033e34e91e07568b63ccb980a4bf42 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Tue, 3 Aug 2021 12:04:14 -0600 Subject: [PATCH 010/240] Added preliminary ElectricalDesign module to ProjectManager. Small bugfixes and config accounting. --- ORBIT/manager.py | 2 + ORBIT/phases/design/electrical_export.py | 119 ++++++----- ORBIT/phases/install/cable_install/export.py | 1 + dev.ipynb | 195 +++++++++++++++++++ 4 files changed, 254 insertions(+), 63 deletions(-) create mode 100644 dev.ipynb diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 5881191a..a0ef7d0c 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -27,6 +27,7 @@ from ORBIT.phases.design import ( SparDesign, MonopileDesign, + ElectricalDesign, ArraySystemDesign, ExportSystemDesign, MooringSystemDesign, @@ -70,6 +71,7 @@ class ProjectManager: MooringSystemDesign, SemiSubmersibleDesign, SparDesign, + ElectricalDesign, ] _install_phases = [ diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 867d020c..a5f8e79a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -6,14 +6,13 @@ import numpy as np # from ORBIT.core.library import extract_library_specs -from ORBIT.phases.design import DesignPhase from ORBIT.phases.design._cables import CableSystem -class ElectricalDesign(DesignPhase, CableSystem): +class ElectricalDesign(CableSystem): """ Design phase for export cabling and offshore substation systems. - + Attributes ---------- num_cables : int @@ -33,7 +32,7 @@ class ElectricalDesign(DesignPhase, CableSystem): An array of `cable`. sections_lengths : np.ndarray, shape: (`num_cables, ) An array of `length`. - + """ expected_config = { @@ -51,7 +50,7 @@ class ElectricalDesign(DesignPhase, CableSystem): "topside_fab_cost_rate": "USD/t (optional)", "topside_design_cost": "USD (optional)", "shunt_cost_rate": "USD/MW (optional)", - "switchgear_cost": "USD (optional)", + "switchgear_costs": "USD (optional)", "backup_gen_cost": "USD (optional)", "workspace_cost": "USD (optional)", "other_ancillary_cost": "USD (optional)", @@ -63,12 +62,11 @@ class ElectricalDesign(DesignPhase, CableSystem): } output_config = { - "num_substations": "int", "offshore_substation_topside": "dict", "offshore_substation_substructure": "dict", - "export_system": { + "system_cost": "USD", "cable": { "linear_density": "t/km", "sections": [("length, km", "speed, km/h (optional)")], @@ -86,7 +84,7 @@ def __init__(self, config, **kwargs): # CABLES super().__init__(config, "export", **kwargs) - + for name in self.expected_config["site"]: setattr(self, "".join(("_", name)), config["site"][name]) self._depth = config["site"]["depth"] @@ -100,13 +98,18 @@ def __init__(self, config, **kwargs): ] except KeyError: self._distance_to_interconnection = 3 - + # SUBSTATION self._outputs = {} def run(self): """Main run function.""" - + + self.export_system_design = self.config["export_system_design"] + self.offshore_substation_design = self.config.get( + "offshore_substation_design", {} + ) + # CABLES self._initialize_cables() self.cable = self.cables[[*self.cables][0]] @@ -114,30 +117,32 @@ def run(self): self.compute_cable_length() self.compute_cable_mass() self.compute_total_cable() - + + self._outputs["export_system"] = {"system_cost": self.total_cable_cost} for name, cable in self.cables.items(): self._outputs["export_system"]["cable"] = { - "linear_density": cable.linear_density, - "sections": [self.length], - "number": self.num_cables, - "cable_power": cable.cable_power, - } + "linear_density": cable.linear_density, + "sections": [self.length], + "number": self.num_cables, + "cable_power": cable.cable_power, + } + # self._outputs["export_system"] = { # "power_factor": self.cables.power_factor, # "interconnection_distance": self._distance_to_interconnection, # "system_cost": self.total_cost, # } - + # SUBSTATION + self.calc_num_substations() self.calc_substructure_length() self.calc_substructure_deck_space() self.calc_topside_deck_space() - self.calc_num_mpt_and_rating() self.calc_mpt_cost() self.calc_topside_mass_and_cost() self.calc_shunt_reactor_cost() - self.calc_switchgear_cost() + self.calc_switchgear_costs() self.calc_ancillary_system_cost() self.calc_assembly_cost() self.calc_substructure_mass_and_cost() @@ -157,7 +162,6 @@ def run(self): } self._outputs["num_substations"] = self.num_substations - @property def detailed_output(self): @@ -177,8 +181,8 @@ def detailed_output(self): "substation_substructure_cost": self.substructure_cost, } - return _output - + return _output + @property def design_result(self): """ @@ -190,14 +194,13 @@ def design_result(self): return self._outputs #################### CABLES ######################## - + @property def total_cable_cost(self): """Returns total array system cable cost.""" return sum(self.cost_by_type.values()) - def compute_number_cables(self): """ Calculate the total number of required and redundant cables to @@ -266,20 +269,15 @@ def sections_cables(self): return np.full(self.num_cables, self.cable.name) - - - #################### SUBSTATION #################### - - - def calc_num_substation(self): + + def calc_num_substations(self): """Computes number of substations""" - _design = self.config.get("substation_design",{}) + _design = self.config.get("substation_design", {}) self.num_substations = _design.get( "num_substations", int(np.ceil(self._plant_capacity / 800)) ) - - + @property def substation_cost(self): """Returns total procuremet cost of the topside.""" @@ -287,47 +285,43 @@ def substation_cost(self): return ( self.mpt_cost + self.shunt_reactor_cost - + self.switchgear_cost + + self.switchgear_costs + self.topside_cost + self.ancillary_system_cost + self.land_assembly_cost ) - + def calc_mpt_cost(self): """Computes transformer cost""" - num_mpt = self.num_cables - self.mpt_cost = num_mpt * 1750000 + self.num_mpt = self.num_cables + self.mpt_cost = self.num_mpt * 1750000 self.mpt_rating = ( round( - ( - self._plant_capacity / (num_mpt * self.num_substation) - ) - /10.0 - ) + (self._plant_capacity / (self.num_mpt * self.num_substations)) + / 10.0 + ) * 10.0 ) - - + def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" # get distance to shore - compensation = ( - self.export_system_design.touchdown_distance - * self.cables.compensation_factor - ) # MW + + for name, cable in self.cables.items(): + compensation = self.touchdown * cable.compensation_factor # MW + self.shunt_reactor_cost = compensation * 120000 - - def calc_switchgear_cost(self): + + def calc_switchgear_costs(self): """Computes switchgear cost""" - + num_switchgear = self.num_cables - self.swtichgear_costs = num_switchgear * 134000 - + self.switchgear_costs = num_switchgear * 134000 + def calc_topside_cost(self): """Computes topside cost""" self.topside_cost = 1 - - + def calc_ancillary_system_cost(self): """ Calculates cost of ancillary systems. @@ -344,10 +338,10 @@ def calc_ancillary_system_cost(self): workspace_cost = _design.get("workspace_cost", 2e6) other_ancillary_cost = _design.get("other_ancillary_cost", 3e6) - self.ancillary_system_costs = ( + self.ancillary_system_cost = ( backup_gen_cost + workspace_cost + other_ancillary_cost ) - + def calc_assembly_cost(self): """ Calculates the cost of assembly on land. @@ -362,9 +356,9 @@ def calc_assembly_cost(self): self.land_assembly_cost = ( self.switchgear_costs + self.shunt_reactor_cost - + self.ancillary_system_costs + + self.ancillary_system_cost ) * topside_assembly_factor - + def calc_substructure_mass_and_cost(self): """ Calculates the mass and associated cost of the substation substructure. @@ -388,8 +382,8 @@ def calc_substructure_mass_and_cost(self): + substructure_pile_mass * oss_pile_cost_rate ) - self.substructure_mass = substructure_mass + substructure_pile_mass - + self.substructure_mass = substructure_mass + substructure_pile_mass + def calc_substructure_length(self): """ Calculates substructure length as the site depth + 10m @@ -414,7 +408,7 @@ def calc_topside_deck_space(self): """ self.topside_deck_space = 1 - + def calc_topside_mass_and_cost(self): """ Calculates the mass and cost of the substation topsides. @@ -440,4 +434,3 @@ def total_oss_cost(self): num_turbines = 100 # Where applicable return self.result * num_turbines - diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index 897ac62e..30cfb55b 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -46,6 +46,7 @@ class ExportCableInstallation(InstallPhase): "plant": {"num_turbines": "int"}, "turbine": {"turbine_rating": "MW"}, "export_system": { + "system_cost": "USD", "cable": { "linear_density": "t/km", "sections": [("length, km", "speed, km/h (optional)")], diff --git a/dev.ipynb b/dev.ipynb new file mode 100644 index 00000000..433430a9 --- /dev/null +++ b/dev.ipynb @@ -0,0 +1,195 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# ProjectManager.compile_input_dict([\n", + "# \"ElectricalDesign\",\n", + "# \"ExportCableInstallation\",\n", + "# \"OffshoreSubstationInstallation\"\n", + "# ])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': 60, 'capacity': 600},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + "# 'num_redundant': 'int (optional)',\n", + "# 'touchdown_distance': 'm (optional, default: 0)',\n", + "# 'percent_added_length': 'float (optional)'\n", + " },\n", + "# 'substation_design': {\n", + "# 'mpt_cost_rate': 'USD/MW (optional)',\n", + "# 'topside_fab_cost_rate': 'USD/t (optional)',\n", + "# 'topside_design_cost': 'USD (optional)',\n", + "# 'shunt_cost_rate': 'USD/MW (optional)',\n", + "# 'switchgear_costs': 'USD (optional)',\n", + "# 'backup_gen_cost': 'USD (optional)',\n", + "# 'workspace_cost': 'USD (optional)',\n", + "# 'other_ancillary_cost': 'USD (optional)',\n", + "# 'topside_assembly_factor': 'float (optional)',\n", + "# 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + "# 'oss_pile_cost_rate': 'USD/t (optional)',\n", + "# 'num_substations': 'int (optional)'\n", + "# },\n", + "\n", + " 'design_phases': ['ElectricalDesign'],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" + ] + } + ], + "source": [ + "project = ProjectManager(config)\n", + "project.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Export System': 135201000.0,\n", + " 'Offshore Substation': 57373650.0,\n", + " 'Export System Installation': 114479148.81358309,\n", + " 'Offshore Substation Installation': 3098929.2998477924,\n", + " 'Turbine': 780000000,\n", + " 'Soft': 387000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.capex_breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-208387.36363249592" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "design.cables[\"XLPE_500mm_220kV\"].compensation_factor" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('XLPE_500mm_220kV',\n", + " )])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "design.cables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From fb30d27308e082656870b8f7f1e3f36a7f027a40 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Tue, 3 Aug 2021 16:45:14 -0600 Subject: [PATCH 011/240] add some prints to dev test file. fixes on shunt reactor cost and compensation factor calc --- ORBIT/phases/design/_cables.py | 4 +- ORBIT/phases/design/electrical_export.py | 18 ++----- dev.ipynb | 66 ++++++++++++++++++------ examples/1. Example Fixed Project.ipynb | 2 +- 4 files changed, 58 insertions(+), 32 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index f3900ef6..c3e574ab 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -134,10 +134,10 @@ def calc_compensation_factor(self): """ Calculate compensation factor for shunt reactor cost """ - capacitive_reactance = 1 / (2 * np.pi * self.line_frequency * (self.capacitance / 10e6)) + capacitive_reactance = 1 / (2 * np.pi * self.line_frequency * (self.capacitance / 10e8)) capacitive_losses = self.rated_voltage ** 2 / capacitive_reactance inductive_reactance = 2 * np.pi * self.line_frequency * (self.inductance / 1000) - inductive_losses = 3 * inductive_reactance * self.current_capacity ** 2 + inductive_losses = 3 * inductive_reactance * (self.current_capacity / 1000) ** 2 self.compensation_factor = capacitive_losses - inductive_losses class Plant: diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index a5f8e79a..e8457243 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -297,7 +297,7 @@ def calc_mpt_cost(self): self.mpt_cost = self.num_mpt * 1750000 self.mpt_rating = ( round( - (self._plant_capacity / (self.num_mpt * self.num_substations)) + (self._plant_capacity / self.num_mpt) / 10.0 ) * 10.0 @@ -306,10 +306,10 @@ def calc_mpt_cost(self): def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" # get distance to shore - + touchdown = self.config["site"]["distance_to_landfall"] for name, cable in self.cables.items(): - compensation = self.touchdown * cable.compensation_factor # MW - + compensation = touchdown * cable.compensation_factor # MW + print(touchdown) self.shunt_reactor_cost = compensation * 120000 def calc_switchgear_costs(self): @@ -318,10 +318,6 @@ def calc_switchgear_costs(self): num_switchgear = self.num_cables self.switchgear_costs = num_switchgear * 134000 - def calc_topside_cost(self): - """Computes topside cost""" - self.topside_cost = 1 - def calc_ancillary_system_cost(self): """ Calculates cost of ancillary systems. @@ -428,9 +424,3 @@ def calc_topside_mass_and_cost(self): self.topside_mass * topside_fab_cost_rate + topside_design_cost ) - @property - def total_oss_cost(self): - """Returns total cost of subcomponent(s).""" - - num_turbines = 100 # Where applicable - return self.result * num_turbines diff --git a/dev.ipynb b/dev.ipynb index 433430a9..e7cfc999 100644 --- a/dev.ipynb +++ b/dev.ipynb @@ -3,15 +3,18 @@ { "cell_type": "code", "execution_count": 1, - "metadata": {}, + "metadata": { + "tags": [] + }, "outputs": [], "source": [ - "from ORBIT import ProjectManager" + "from ORBIT import ProjectManager\n", + "from ORBIT.phases.design import ElectricalDesign" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -24,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -66,25 +69,29 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" + "ORBIT library intialized at 'C:\\Users\\SBREDENK\\ORBIT\\library'\n", + "0\n", + "0\n" ] } ], "source": [ + "design = ElectricalDesign(config)\n", + "design.run()\n", "project = ProjectManager(config)\n", "project.run()" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -99,7 +106,7 @@ " 'Project': 151250000.0}" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -110,16 +117,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-208387.36363249592" + "2.345849005672588" ] }, - "execution_count": 6, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -130,17 +137,17 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "OrderedDict([('XLPE_500mm_220kV',\n", - " )])" + " )])" ] }, - "execution_count": 7, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -149,6 +156,35 @@ "design.cables" ] }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mpt costs = 5250000\n", + "shunt reactor costs = 0.0\n", + "switchgear costs = 402000\n", + "topside costs = 42127500.0\n", + "ancillary system costs = 6000000.0\n", + "land assembly costs = 480150.0\n" + ] + } + ], + "source": [ + "print(\"mpt costs = \", design.mpt_cost)\n", + "print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "print(\"switchgear costs = \", design.switchgear_costs)\n", + "print(\"topside costs = \", design.topside_cost)\n", + "print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "print(\"land assembly costs = \", design.land_assembly_cost)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -187,7 +223,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.10" } }, "nbformat": 4, diff --git a/examples/1. Example Fixed Project.ipynb b/examples/1. Example Fixed Project.ipynb index 320fe41c..cd58a33c 100644 --- a/examples/1. Example Fixed Project.ipynb +++ b/examples/1. Example Fixed Project.ipynb @@ -554,7 +554,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.7.10" } }, "nbformat": 4, From 5af08528f1c4be97356473aa82fb5d229f15aed4 Mon Sep 17 00:00:00 2001 From: Sophie Bredenkamp Date: Wed, 4 Aug 2021 11:04:24 -0600 Subject: [PATCH 012/240] updated costs in cable lib --- dev.ipynb | 36 ++++++++++++++++++---------- library/cables/XLPE_500mm_220kV.yaml | 2 +- library/cables/XLPE_630mm_220kV.yaml | 2 +- library/cables/XLPE_800mm_220kV.yaml | 2 +- 4 files changed, 27 insertions(+), 15 deletions(-) diff --git a/dev.ipynb b/dev.ipynb index e7cfc999..9e5d1e89 100644 --- a/dev.ipynb +++ b/dev.ipynb @@ -77,8 +77,8 @@ "output_type": "stream", "text": [ "ORBIT library intialized at 'C:\\Users\\SBREDENK\\ORBIT\\library'\n", - "0\n", - "0\n" + "50\n", + "50\n" ] } ], @@ -98,7 +98,7 @@ "data": { "text/plain": [ "{'Export System': 135201000.0,\n", - " 'Offshore Substation': 57373650.0,\n", + " 'Offshore Substation': 72504376.0865882,\n", " 'Export System Installation': 114479148.81358309,\n", " 'Offshore Substation Installation': 3098929.2998477924,\n", " 'Turbine': 780000000,\n", @@ -117,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -126,7 +126,7 @@ "2.345849005672588" ] }, - "execution_count": 14, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -137,17 +137,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "OrderedDict([('XLPE_500mm_220kV',\n", - " )])" + " )])" ] }, - "execution_count": 15, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -158,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 8, "metadata": { "tags": [] }, @@ -168,11 +168,22 @@ "output_type": "stream", "text": [ "mpt costs = 5250000\n", - "shunt reactor costs = 0.0\n", + "shunt reactor costs = 14075094.034035528\n", "switchgear costs = 402000\n", "topside costs = 42127500.0\n", "ancillary system costs = 6000000.0\n", - "land assembly costs = 480150.0\n" + "land assembly costs = 1535782.0525526644\n" + ] + }, + { + "ename": "AttributeError", + "evalue": "'ElectricalDesign' object has no attribute 'export_system'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"ancillary system costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mancillary_system_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"land assembly costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mland_assembly_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"cable costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexport_system\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msystem_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m: 'ElectricalDesign' object has no attribute 'export_system'" ] } ], @@ -182,7 +193,8 @@ "print(\"switchgear costs = \", design.switchgear_costs)\n", "print(\"topside costs = \", design.topside_cost)\n", "print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "print(\"land assembly costs = \", design.land_assembly_cost)" + "print(\"land assembly costs = \", design.land_assembly_cost)\n", + "print(\"cable costs = \", design.export_system.system_cost)" ] }, { diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index a7ae0326..0271a400 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.03 # ohm/km capacitance: 140 # nF/km conductor_size: 500 # mm^2 -cost_per_km: 850000 # $ +cost_per_km: 665000 # $ current_capacity: 655 # A inductance: 0.43 # mH/km linear_density: 90 # t/km diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index 6b2852b6..638d5ab7 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.25 # ohm/km capacitance: 160 # nF/km conductor_size: 630 # mm^2 -cost_per_km: 850000 # $ +cost_per_km: 710000 # $ current_capacity: 715 # A inductance: 0.41 # mH/km linear_density: 96 # t/km diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index 80aaf58c..2b6c95b1 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.20 # ohm/km capacitance: 170 # nF/km conductor_size: 800 # mm^2 -cost_per_km: 850000 # $ +cost_per_km: 776000 # $ current_capacity: 775 # A inductance: 0.40 # mH/km linear_density: 105 # t/km From 97196a975fe4869b76af41f6c29c8453ceca1170 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 10 Aug 2021 10:22:59 -0400 Subject: [PATCH 013/240] added export_runs for prelim cost curves --- export_runs.ipynb | 306 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 306 insertions(+) create mode 100644 export_runs.ipynb diff --git a/export_runs.ipynb b/export_runs.ipynb new file mode 100644 index 00000000..9a83ae65 --- /dev/null +++ b/export_runs.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 86, + "id": "34256382-d968-446b-b4f5-2900571b6202", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager\n", + "from ORBIT.phases.design import ElectricalDesign\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "09623e08-fe09-46c6-8697-d80dfb455428", + "metadata": {}, + "source": [ + "## Cost Curves \n", + "#### Vary Plant Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "ab071a0f-25e7-401e-952d-7d420fde68b4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" + ] + } + ], + "source": [ + "cap = [400, 600, 800, 1000, 1200, 1400]\n", + "i = 0\n", + "mpt_cost = [0] * len(cap)\n", + "capex_list = [None] * len(cap)\n", + "for x in cap:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': ['ElectricalDesign'],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = ElectricalDesign(config)\n", + " design.run()\n", + " mpt_cost[i] = design.mpt_cost\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + "# print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + "\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list[i] = project.capex_breakdown\n", + " i = i + 1\n" + ] + }, + { + "cell_type": "markdown", + "id": "79968dab-bc0a-4746-8205-306942cd0348", + "metadata": {}, + "source": [ + "#### Vary Distance to Shore" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "2a9b6a5b-fa16-499d-b4fb-705ac25d44f5", + "metadata": {}, + "outputs": [], + "source": [ + "dist = [40, 80, 100, 140, 180, 200]\n", + "i = 0\n", + "mpt_cost = [0] * len(dist)\n", + "capex_list_dist = [None] * len(dist)\n", + "for x in dist:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': x},\n", + " 'plant': {'num_turbines': 60, 'capacity': 600},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': ['ElectricalDesign'],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = ElectricalDesign(config)\n", + " design.run()\n", + " mpt_cost[i] = design.mpt_cost\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + "# print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + "\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list_dist[i] = project.capex_breakdown\n", + " i = i + 1\n" + ] + }, + { + "cell_type": "markdown", + "id": "2336fbf6-9c9b-4ec6-b55f-f63b4bb01cda", + "metadata": { + "tags": [] + }, + "source": [ + "### Extract and Plot Cable + Substation Costs \n", + "#### By Plant Cap\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "3558606a-2e7c-4aef-8652-db48274450fd", + "metadata": {}, + "outputs": [], + "source": [ + "i = 0\n", + "cable_cost = [0] * len(cap)\n", + "oss_cost = [0] * len(cap)\n", + "for x in capex_list:\n", + " cable_cost[i] = x.get('Export System')\n", + " oss_cost[i] = x.get('Offshore Substation')\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "362f145f-603a-4c5b-8b32-ea96d4e81f95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, cable_cost)\n", + "plt.plot(cap, oss_cost)\n", + "plt.title(\"Cable, OSS Cost by Plant Capacity\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "225fc353-d75d-43a4-a1f3-6305c6f10745", + "metadata": {}, + "source": [ + "#### By Distance" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "73432368-74ab-4ba5-8546-67d21ee00be7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "i = 0\n", + "cable_cost_dist = [0] * len(cap)\n", + "oss_cost_dist = [0] * len(cap)\n", + "for x in capex_list_dist:\n", + " cable_cost_dist[i] = x.get('Export System')\n", + " oss_cost_dist[i] = x.get('Offshore Substation')\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "f5e2a52e-eb9c-4405-974a-bd699b44fc75", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, cable_cost_dist)\n", + "plt.plot(cap, oss_cost_dist)\n", + "plt.title(\"Cable, OSS Cost by Distance to Shore\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From fb2a5713b9e399a208778a3fc50162db8c7130be Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 11 Aug 2021 16:55:12 -0400 Subject: [PATCH 014/240] try smaller increment runs. update electrical_export to include optional user inputs --- ORBIT/phases/design/electrical_export.py | 42 ++-- export_runs.ipynb | 300 +++++++++++++++++++++-- 2 files changed, 295 insertions(+), 47 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index e8457243..64143166 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -13,26 +13,6 @@ class ElectricalDesign(CableSystem): """ Design phase for export cabling and offshore substation systems. - Attributes - ---------- - num_cables : int - Total number of cables required for transmitting power. - length : float - Length of a single cable connecting the OSS to the interconnection in km. - mass : float - Mass of `length` in tonnes. - cable : `Cable` - Instance of `ORBIT.phases.design.Cable`. An export system will - only require a single type of cable. - total_length : float - Total length of cable required to trasmit power. - total_mass : float - Total mass of cable required to transmit power. - sections_cables : np.ndarray, shape: (`num_cables, ) - An array of `cable`. - sections_lengths : np.ndarray, shape: (`num_cables, ) - An array of `length`. - """ expected_config = { @@ -211,6 +191,7 @@ def compute_number_cables(self): num_redundant = self._design.get("num_redundant", 0) self.num_cables = int(num_required + num_redundant) + #print(self.num_cables) def compute_cable_length(self): """ @@ -273,8 +254,8 @@ def sections_cables(self): def calc_num_substations(self): """Computes number of substations""" - _design = self.config.get("substation_design", {}) - self.num_substations = _design.get( + self._design = self.config.get("substation_design", {}) + self.num_substations = self._design.get( "num_substations", int(np.ceil(self._plant_capacity / 800)) ) @@ -294,7 +275,9 @@ def substation_cost(self): def calc_mpt_cost(self): """Computes transformer cost""" self.num_mpt = self.num_cables - self.mpt_cost = self.num_mpt * 1750000 + self.mpt_cost = ( + self.num_mpt * self._design.get("mpt_cost_rate", 1750000) + ) self.mpt_rating = ( round( (self._plant_capacity / self.num_mpt) @@ -309,15 +292,18 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] for name, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW - print(touchdown) - self.shunt_reactor_cost = compensation * 120000 - + self.shunt_reactor_cost = ( + compensation * self._design.get("shunt_cost_rate", 120000) + ) + def calc_switchgear_costs(self): """Computes switchgear cost""" num_switchgear = self.num_cables - self.switchgear_costs = num_switchgear * 134000 - + self.switchgear_costs = ( + num_switchgear * self._design.get("switchgear_costs", 134000) + ) + def calc_ancillary_system_cost(self): """ Calculates cost of ancillary systems. diff --git a/export_runs.ipynb b/export_runs.ipynb index 9a83ae65..2dc0a298 100644 --- a/export_runs.ipynb +++ b/export_runs.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 86, + "execution_count": 1, "id": "34256382-d968-446b-b4f5-2900571b6202", "metadata": {}, "outputs": [], @@ -24,7 +24,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 2, "id": "ab071a0f-25e7-401e-952d-7d420fde68b4", "metadata": { "tags": [] @@ -34,6 +34,245 @@ "name": "stdout", "output_type": "stream", "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", "OffshoreSubstationInstallation:\n", "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", "OffshoreSubstationInstallation:\n", @@ -46,7 +285,7 @@ } ], "source": [ - "cap = [400, 600, 800, 1000, 1200, 1400]\n", + "cap = np.arange(100,2010,10)\n", "i = 0\n", "mpt_cost = [0] * len(cap)\n", "capex_list = [None] * len(cap)\n", @@ -88,6 +327,7 @@ " design = ElectricalDesign(config)\n", " design.run()\n", " mpt_cost[i] = design.mpt_cost\n", + " #print(x, \":\", design.num_cables)\n", "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", "# print(\"switchgear costs = \", design.switchgear_costs)\n", "# print(\"topside costs = \", design.topside_cost)\n", @@ -110,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 3, "id": "2a9b6a5b-fa16-499d-b4fb-705ac25d44f5", "metadata": {}, "outputs": [], @@ -162,7 +402,6 @@ "# print(\"topside costs = \", design.topside_cost)\n", "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - "\n", " project = ProjectManager(config)\n", " project.run()\n", " capex_list_dist[i] = project.capex_breakdown\n", @@ -182,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 4, "id": "3558606a-2e7c-4aef-8652-db48274450fd", "metadata": {}, "outputs": [], @@ -198,13 +437,13 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 5, "id": "362f145f-603a-4c5b-8b32-ea96d4e81f95", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpUElEQVR4nO3dd1hT1/8H8HcChD1EtiKggqKCxVlcOKho3Xa46q511lWttf6sYlu1WlfV2n47tI7W1tbRqnWhONGqFfcWNw5UliAr5/dHSjSyIXBvyPv1PDwk957cfG4C5M25556rEEIIEBEREcmQUuoCiIiIiPLCoEJERESyxaBCREREssWgQkRERLLFoEJERESyxaBCREREssWgQkRERLLFoEJERESyxaBCREREssWgQgbP29sbHTt2LLBdZGQkFAoFIiMjS78oKpHp06dDoVAgLi5O6lIAAAMGDIC3t7fUZZRb/N2k/DCoUJm7evUqhg4diqpVq8LCwgJ2dnZo2rQpFi1ahNTUVKnL0wshBFatWoUWLVrAwcEBVlZWCAgIwIwZM/D06dMc7dVqNVauXInGjRvD0dERtra28PPzQ79+/XD48GGdttevX8fAgQNRrVo1WFhYwM3NDS1atMC0adMKXV90dDTeeecdeHp6wtzcHI6OjggNDcXy5cuRlZVV4v1/2d27dzF9+nRER0frfdsl0bJlSygUCu2Xo6MjGjZsiB9//BFqtbpMazl06BCmT5+O+Pj4Ij0uMjIS3bt3h5ubG1QqFVxcXNCpUyesX7++dAotIz///DMWLlwodRkkA6ZSF0DGZcuWLXjrrbdgbm6Ofv36oU6dOkhPT8eBAwcwceJEnD17Fv/73/+kLrNEsrKy0Lt3b/z2229o3rw5pk+fDisrK+zfvx/h4eFYt24ddu3aBVdXV+1jRo8ejaVLl6JLly7o06cPTE1NcfHiRfz999+oWrUqXn31VQDAlStX0LBhQ1haWmLQoEHw9vZGbGws/v33X3zxxRcIDw8vsL7vv/8ew4YNg6urK/r27QtfX18kJSUhIiICgwcPRmxsLD7++GO9viZ3795FeHg4vL298corr+h12yVVuXJlzJo1CwDw8OFDrFy5EoMHD8alS5cwe/bsMqvj0KFDCA8Px4ABA+Dg4FCox0ybNg0zZsyAr68vhg4dCi8vLzx69Ahbt27FG2+8gTVr1qB3796lW7getGjRAqmpqVCpVNplP//8M86cOYOxY8dKVxjJgyAqI9euXRM2NjaiZs2a4u7duznWX758WSxcuLDI2/Xy8hIdOnQosN2ePXsEALFnz54iP0dRzJw5UwAQEyZMyLHuzz//FEqlUrRr10677N69e0KhUIghQ4bkaK9Wq8X9+/e190eMGCFMTU3F9evXc7R9sV1eoqKihImJiWjWrJlITEzMsf7o0aNi+fLlBW6nqI4ePSoAFHrb06ZNEwDEw4cP9V7Li0JCQkTt2rV1lj19+lRUrlxZWFtbi/T0dCGEEP379xdeXl6lWsvcuXMFABETE1Oo9uvWrRMAxJtvvqmt80Xbtm0Tf/31l56rLDsdOnQo9decDAODCpWZYcOGCQDi4MGDhWr/448/ilatWglnZ2ehUqmEv7+/+Prrr3O0yw4q27dvF3Xr1hXm5ubC399f/PHHHzrt8goqhw8fFmFhYcLOzk5YWlqKFi1aiAMHDhRrH1NSUkSFChWEn5+fyMjIyLXNwIEDBQARFRUlhNCEBwBixYoVBW4/LCxMeHt7F6s2IYRo166dMDU1FTdu3ChU++TkZDF+/HhRuXJloVKphJ+fn5g7d65Qq9U67Xbs2CGaNm0q7O3thbW1tfDz8xOTJ08WQjx/3V/+yi+0ZAeV8+fPi7feekvY2toKR0dHMXr0aJGamqpt16JFCxEYGJjrNvz8/ETbtm3z3b/cgooQQrz55psCgLhz544QIvegMnfuXBEcHCwcHR2FhYWFqFevnli3bl2ObQEQI0eOFBs2bBC1a9cWKpVK1KpVS/z999859vflr/xCS82aNYWjo2OugfNlaWlpYurUqaJevXrCzs5OWFlZiWbNmondu3frtIuJiREAxNy5c8X8+fNFlSpVhIWFhWjRooU4ffq0TtuTJ0+K/v37Cx8fH2Fubi5cXV3FwIEDRVxcXI7nv337thg0aJBwd3cXKpVKeHt7i2HDhom0tDQhRM7fzZCQkByvhZeXl0hKShJWVlZi9OjROZ7j1q1bQqlUipkzZxb4epBhYVChMlOpUiVRtWrVQrdv2LChGDBggFiwYIFYvHixaNu2rQAglixZotPOy8tL+Pn5CQcHB/HRRx+J+fPni4CAAKFUKsWOHTu07XILKhEREUKlUong4GAxb948sWDBAhEYGChUKpU4cuRIkfdxx44dAoCYPn16nm2y65gyZYoQQoi7d+8KAKJDhw7i6dOn+W7/vffeEyYmJiIiIqLItT19+lSYmZmJ1q1bF6q9Wq0WrVu3FgqFQrz77rtiyZIlolOnTgKAGDt2rLbdmTNnhEqlEg0aNBCLFi0S33zzjZgwYYJo0aKFEELTYzRjxgwBQLz33nti1apVYtWqVeLq1at5Pnf2B3dAQIDo1KmTWLJkiXjnnXcEANG3b19tu++++04AyPEh+s8//wgAYuXKlfnuY15BpV69esLExET7fuQWVCpXrixGjBghlixZIubPny8aNWokAIjNmzfrtAMg6tatK9zd3cWnn34qFi5cKKpWrSqsrKy0H+onT54UvXr1EgDEggULtK9RcnJyrnVfunRJABCDBg3Kd/+yPXz4ULi7u4vx48eLZcuWiTlz5ogaNWoIMzMzceLECW277KASEBAgvL29xRdffCHCw8OFo6OjcHZ2Fvfu3dO2/fLLL0Xz5s3FjBkzxP/+9z8xZswYYWlpKRo1aqQTZO/cuSM8PDyElZWVGDt2rPjmm2/E1KlThb+/v3jy5IkQIufv5o4dO8Qrr7winJyctK/Fhg0bhBBC9OnTR7i6uorMzEydfZwzZ45QKBSFDuFkOBhUqEwkJCQIAKJLly6FfkxKSkqOZWFhYTnCjpeXlwCg04OSkJAg3N3dRVBQkHbZy38M1Wq18PX1FWFhYTp/WFNSUoSPj4947bXXCl1rtoULFwoA2j+quXn8+LEAILp3765d1q9fPwFAVKhQQXTr1k18+eWX4vz58zkee+bMGWFpaSkAiFdeeUWMGTNGbNy4scCAI4TmwxCAGDNmTKH2ZePGjQKA+Oyzz3SWv/nmm0KhUIgrV64IIYRYsGBBgYdpinvop3PnzjrLR4wYIQCIkydPCiGEiI+PFxYWFmLSpEk67UaPHi2sra3z/KDPFhISImrWrCkePnwoHj58KM6fPy9Gjx4tAIhOnTpp2+UWVF7++UxPTxd16tTJEQQBCJVKpX29hHj+XixevFi7rCiHfjZt2qQNNYWRmZmp7b3I9uTJE+Hq6qoTdrKDiqWlpbh9+7Z2+ZEjRwQAMW7cOO2y3H4/f/nlFwFA7Nu3T7usX79+QqlUiqNHj+Zon/17l9s/EXkd+tm+fbsAoNMjJYQQgYGBIiQkJPcXgAwaz/qhMpGYmAgAsLW1LfRjLC0ttbcTEhIQFxeHkJAQXLt2DQkJCTptPTw80K1bN+19Ozs79OvXDydOnMC9e/dy3X50dDQuX76M3r1749GjR4iLi0NcXByePn2KNm3aYN++fUU+8yMpKQlA/vuZvS77NQGA5cuXY8mSJfDx8cGGDRswYcIE+Pv7o02bNrhz5462Xe3atbVn7Fy/fh2LFi1C165d4erqiu+++y7f2or6HmzduhUmJiYYPXq0zvIPPvgAQgj8/fffAKAd+Llp0ya9nykzcuRInfvvv/++tjYAsLe3R5cuXfDLL79ACAFAM5j5119/RdeuXWFtbV3gc1y4cAHOzs5wdnaGv78/Fi9ejA4dOuDHH3/M93Ev/nw+efIECQkJaN68Of79998cbUNDQ1GtWjXt/cDAQNjZ2eHatWsF1pebor6XJiYm2oGqarUajx8/RmZmJho0aJBrvV27dkWlSpW09xs1aoTGjRtrX3dAd/+fPXuGuLg47aDv7G2q1Wps3LgRnTp1QoMGDXI8j0KhKFT9LwoNDYWHhwfWrFmjXXbmzBmcOnUK77zzTpG3R/JXboLKvn370KlTJ3h4eEChUGDjxo1F3sb27dvx6quvwtbWFs7OznjjjTdw/fp1vddqjOzs7AA8/yAvjIMHDyI0NBTW1tZwcHCAs7Oz9myUl4NK9erVc/zR8/PzA4A838PLly8DAPr376/9oMr++v7775GWlpbjeQqS/cGR337mFmaUSiVGjhyJ48ePIy4uDps2bUL79u2xe/du9OzZM8d+rVq1CnFxcTh16hRmzpwJU1NTvPfee9i1a1eez1vU9+DGjRvw8PDI8WHo7++vXQ8APXr0QNOmTfHuu+/C1dUVPXv2xG+//aaX0OLr66tzv1q1alAqlTrvab9+/XDz5k3s378fALBr1y7cv38fffv2LdRzeHt7Y+fOndi1axcOHDiAe/fuYfPmzXBycsr3cZs3b8arr74KCwsLODo6wtnZGcuWLcv1Z6ZKlSo5llWoUAFPnjwpVI0vK87v008//YTAwEBYWFigYsWKcHZ2xpYtW3Kt9+XXHdD83L34uj9+/BhjxoyBq6srLC0t4ezsDB8fHwDPfz8fPnyIxMRE1KlTpyi7ly+lUok+ffpg48aNSElJAQCsWbMGFhYWeOutt/T2PCQf5SaoPH36FHXr1sXSpUuL9fiYmBh06dIFrVu3RnR0NLZv3464uDh0795dz5UaJzs7O3h4eODMmTOFan/16lW0adMGcXFxmD9/PrZs2YKdO3di3LhxAKCXD8HsbcydOxc7d+7M9cvGxqZI28z+ED916lSebbLX1apVK9f1FStWROfOnbF161aEhITgwIED2lDwIhMTEwQEBGDy5MnYsGEDAOj8l/my6tWrw9TUFKdPny70/hSGpaUl9u3bh127dqFv3744deoUevTogddee03vc7Lk9h94WFgYXF1dsXr1agDA6tWr4ebmhtDQ0EJt09raGqGhoWjTpg2aNm0KFxeXAh+zf/9+dO7cGRYWFvj666+xdetW7Ny5E71799b27LzIxMQk1+3k1rYwatasCQCFfi9Xr16NAQMGoFq1avjhhx+wbds27Ny5E61bty7279Lbb7+N7777DsOGDcP69euxY8cObNu2DYB+fj/z069fPyQnJ2Pjxo0QQuDnn39Gx44dYW9vX6rPS9IoN/OotG/fHu3bt89zfVpaGqZMmYJffvkF8fHxqFOnDr744gu0bNkSAHD8+HFkZWXhs88+g1KpyW8TJkxAly5dkJGRATMzs7LYjXKtY8eO+N///oeoqCgEBwfn2/avv/5CWloa/vzzT53/Rvfs2ZNr+ytXrkAIofNBdunSJQDIc0bR7K54Ozu7Qn+oFaRZs2ZwcHDAzz//jClTpuT6AbVy5UoAKNRsug0aNMDevXsRGxsLLy+vfNsBQGxsbJ5trKys0Lp1a+zevRu3bt2Cp6dnvs/t5eWFXbt2ISkpSadX5cKFC9r12ZRKJdq0aYM2bdpg/vz5mDlzJqZMmYI9e/YgNDS0WF38gKbXK/u/dEDzPqvVap331MTEBL1798aKFSvwxRdfYOPGjRgyZEie4UAf/vjjD1hYWGD79u0wNzfXLl++fHmxt1mU18jPzw81atTApk2bsGjRogID9e+//46qVati/fr1Os+T1ySB2b2NL7p06ZL2dX/y5AkiIiIQHh6OTz75JM/HOTs7w87OrtD/oLwov9ejTp06CAoKwpo1a1C5cmXcvHkTixcvLvJzkGEoNz0qBRk1ahSioqKwdu1anDp1Cm+99RbatWun/cWqX78+lEqldmbOhIQErFq1CqGhoQwpevLhhx/C2toa7777Lu7fv59j/dWrV7Fo0SIAz/8DffE/zoSEhDw/CO7evavtVQA0x/BXrlyJV155BW5ubrk+pn79+qhWrRq+/PJLJCcn51j/8OHDwu/cf6ysrDBhwgRcvHgRU6ZMybF+y5YtWLFiBcLCwrTH8+/du4dz587laJueno6IiAgolUpUr14dgOY/+YyMjBxts8cO1KhRI9/6pk2bBiEE+vbtm+s+Hz9+HD/99BMA4PXXX0dWVhaWLFmi02bBggVQKBTafwweP36cYzvZk7qlpaUBgHasSFFnXX25hzT7w+jlf0r69u2LJ0+eYOjQoUhOTi71sQomJiZQKBQ6PUbXr18v1iHnbEV9jcLDw/Ho0SO8++67yMzMzLF+x44d2Lx5s7ZeQPf36ciRI4iKisp12xs3btQZG/XPP//gyJEj2tc9t+0ByDGTrFKpRNeuXfHXX3/h2LFjOZ4nvx4la2vrfA+99u3bFzt27MDChQtRsWLFfP9RJcNWbnpU8nPz5k0sX74cN2/ehIeHBwBNb8m2bduwfPlyzJw5Ez4+PtixYwfefvttDB06FFlZWQgODtYZPEYlU61aNfz888/o0aMH/P39dWamPXToENatW4cBAwYAANq2bQuVSoVOnTppP3y+++47uLi45Npr4Ofnh8GDB+Po0aNwdXXFjz/+iPv37+f7H65SqcT333+P9u3bo3bt2hg4cCAqVaqEO3fuYM+ePbCzs8Nff/2lba9QKBASElLg9Ug++ugjnDhxAl988QWioqLwxhtvwNLSEgcOHMDq1avh7++vDQMAcPv2bTRq1AitW7dGmzZt4ObmhgcPHuCXX37ByZMnMXbsWO14iS+++ALHjx9H9+7dERgYCEAzcHHlypVwdHQscBbPJk2aYOnSpRgxYgRq1qypMzNtZGQk/vzzT3z22WcAgE6dOqFVq1aYMmUKrl+/jrp162LHjh3YtGkTxo4dq+2RmjFjBvbt24cOHTrAy8sLDx48wNdff43KlSujWbNm2vfewcEB33zzDWxtbWFtbY3GjRvr9JbkJiYmBp07d0a7du0QFRWF1atXo3fv3qhbt65Ou6CgINSpUwfr1q2Dv78/6tWrl+92S6pDhw6YP38+2rVrh969e+PBgwdYunQpqlevnu9hv/zUr18fADBlyhT07NkTZmZm6NSpU54Dgnv06IHTp0/j888/x4kTJ9CrVy/tzLTbtm1DREQEfv75ZwCa3rv169ejW7du6NChA2JiYvDNN9+gVq1auQbW6tWro1mzZhg+fDjS0tK0YeDDDz8EoOmFbNGiBebMmYOMjAxUqlQJO3bsQExMTI5tzZw5Ezt27EBISAjee+89+Pv7IzY2FuvWrcOBAwfynIW3fv36+PXXXzF+/Hg0bNgQNjY26NSpk3Z979698eGHH2LDhg0YPnw4/6EszyQ626hU4aXTQzdv3iwACGtra50vU1NT8fbbbwshhIiNjRW+vr5i4sSJ4t9//xV79+4VISEhok2bNjkmt6KSuXTpkhgyZIjw9vYWKpVK2NraiqZNm4rFixeLZ8+eadv9+eefIjAwUFhYWGjndPjxxx9znML54oRvgYGBwtzcXNSsWTPH5Ft5Tfh24sQJ0b17d1GxYkVhbm4uvLy8xNtvv60zV0lSUpIAIHr27FmofczKyhLLly8XTZs2FXZ2dsLCwkLUrl1bhIeH5zhlNjExUSxatEiEhYWJypUrCzMzM2FrayuCg4PFd999p/Pzd/DgQTFy5EhRp04dYW9vL8zMzESVKlXEgAED8p2X5GXHjx8XvXv3Fh4eHsLMzExUqFBBtGnTRvz0008iKytLZ7/HjRunbefr65tjwreIiAjRpUsX4eHhIVQqlfDw8BC9evUSly5d0nnOTZs2iVq1aglTU9NCT/h27tw58eabbwpbW1tRoUIFMWrUKJ0J3140Z84cAaBIE37lNY/Ky3I7PfmHH34Qvr6+2p+35cuXa+t+Ef6b8O1lXl5eon///jrLPv30U1GpUiWhVCoLfapy9uvv4uIiTE1NhbOzs+jUqZPYtGmTto1arRYzZ84UXl5ewtzcXAQFBYnNmzfn2K8XJ3ybN2+e8PT0FObm5qJ58+baU8Kz3b59W3Tr1k04ODgIe3t78dZbb2nnBJo2bZpO2xs3boh+/foJZ2dnYW5uLqpWrSpGjhyZ54RvQmgmG+zdu7dwcHDQTvj2stdff10AEIcOHSrwdSLDpRCimKO5ZEyhUGDDhg3o2rUrAODXX39Fnz59cPbs2RzHrW1sbODm5oapU6di27ZtOHr0qHbd7du34enpiaioKG03PRmnrVu3omPHjjh58iQCAgKkLodysWjRIowbNw7Xr1/P9SwbKtj169fh4+ODuXPnYsKECVKXU6Bu3brh9OnTuHLlitSlUCkyikM/QUFByMrKwoMHD9C8efNc26SkpGgH0WbLDjVlfRVVkp89e/agZ8+eDCkyJYTADz/8gJCQEIYUIxEbG4stW7bkOhaMypdyE1SSk5N1UnVMTAyio6Ph6OgIPz8/9OnTB/369cO8efMQFBSEhw8fIiIiAoGBgejQoQM6dOiABQsWYMaMGejVqxeSkpLw8ccfw8vLC0FBQRLuGcnB3LlzpS6BcvH06VP8+eef2LNnD06fPo1NmzZJXRKVspiYGBw8eBDff/89zMzMMHToUKlLotIm8aEnvcnrwmfZx4DT09PFJ598Iry9vYWZmZlwd3cX3bp1E6dOndJu45dffhFBQUHC2tpaODs7i86dO+c6jTkRyUP2mAoHBwfx8ccfS12OwXtxjIpcLV++XAAQVapUyfUikFT+lMsxKkRERFQ+GM08KkRERGR4GFSIiIhItgx6MK1arcbdu3dha2tb7Cm6iYiIqGwJIZCUlAQPD48cZ9y+zKCDyt27dwu8XgkRERHJ061bt1C5cuV82xh0UMm+UNqtW7e0lz0nIiIieUtMTISnp6fOBU/zYtBBJftwj52dHYMKERGRgSnMsA0OpiUiIiLZYlAhIiIi2WJQISIiItliUCEiIiLZYlAhIiIi2WJQISIiItliUCEiIiLZYlAhIiIi2WJQISIiItliUCEiIiLZYlAhIiIi2ZI0qEyfPh0KhULnq2bNmlKWRERERDIi+UUJa9eujV27dmnvm5pKXhIREREBwI1DgGsdwEK6C/9KngpMTU3h5uYmdRlERESU7ekjYOcnQPRqoNFQ4PU5kpUieVC5fPkyPDw8YGFhgeDgYMyaNQtVqlTJtW1aWhrS0tK09xMTE8uqTCIiovLnyQ1g/zwgI/WFhQK4EgGkPv7vbhYgBKBQSFKipEGlcePGWLFiBWrUqIHY2FiEh4ejefPmOHPmDGxtbXO0nzVrFsLDwyWolIiIqBw6MB/496fc17nUBjotBDwblWlJL1MIIYSkFbwgPj4eXl5emD9/PgYPHpxjfW49Kp6enkhISICdnXTHz4iIiAzS0sbAwwtAg0GAY7Xny21cgNrdABOzUnnaxMRE2NvbF+rzW/JDPy9ycHCAn58frly5kut6c3NzmJubl3FVRERE5VDqE01IAYBWUwBrJ2nryYOs5lFJTk7G1atX4e7uLnUpRERE5dvtY5rvjtVkG1IAiYPKhAkTsHfvXly/fh2HDh1Ct27dYGJigl69eklZFhERUfl387Dmu2djaesogKSHfm7fvo1evXrh0aNHcHZ2RrNmzXD48GE4OztLWRYREVH5d+uI5nsVBpU8rV27VsqnJyIiMk5ZmcCd45rbMu9RkdUYFSIiIioD988AGSmAuT3gVEPqavLFoEJERGRsbv2j+e7ZEFDKOwrI6vRkIiIiykNGKhB3ST/buhqh+S7zwz4AgwoREZFhWNHh+bgSfWFQISIiohJLuv88pNh66GebLjWBKq/qZ1uliEGFiIhI7m7/N6bEpTYw4pC0tZQxeY+gISIioudznkh8gUApMKgQERHJnfYsHfmPKdE3BhUiIiI5y0wD7p7Q3Jb5LLKlgUGFiIhIzmJPAlnpgLUzUMFH6mrKHIMKERGRnL148UCFQtpaJMCgQkREJGdGPJAWYFAhIiKSLyGMeiAtwHlUiIiISt/Di8COqZoLARaFOhN4+gAwUQHur5RKaXLHoEJERFTaopYCl7cX//FeTQAzC/3VY0AYVIiIiEpb9uGb5h8ArnWK9liFEvBurv+aDASDChERUWlKjQcentfcbjwcsHGWtBxDw8G0REREpen2Mc13x6oMKcXAoEJERFSatKcXG+dZOyXFoEJERFSajHwelJJiUCEiIiotWZnPD/14viptLQaKQYWIiKi0PDgLZDwFzO0A55pSV2OQGFSIiIhKS/ZpyZUbAkp+5BYHT08mIiIqrGcJmosECnXh2l/YrPnOgbTFxqBCRERUWL/2BWL2Fv1xng31X4uRYFAhIiIqjLsnNCFFaQq41y3845z8jHpm2ZJiUCEiIiqMw8s032t3B974TtpajAhH9hARERUkMRY484fm9qvDpa3FyDCoEBERFeTo94A6E6gSDFSqJ3U1RoWHfoiIiF60KxyI/hmAeL4s5bHmO3tTyhyDChERUbb0p8ChxYA6I+c655pAzY5lX5ORY1AhIiLKdvOwJqTYVQJ6/6a7zrEqoDSRpi4jxqBCRESULXuOlKotAbc6kpZCGhxMS0RElC1mn+a7T4i0dZAWgwoREREApD4B7kZrbvtwgja5YFAhIiICgOsHAQigoi9g5yF1NfQfBhUiIiLg+WGfqjzsIycMKkRERMDzgbQ+LaStg3TwrB8iIio/4i4D2z7SzIdSFEIADy8AUPACgjLDoEJEROVH1FLgyq7iP77Kq4CVo/7qoRJjUCEiovIje5xJyCTAtXbRHqtQaq7lQ7LCoEJEROVDwm3g8VVN4Hh1BGDpIHVFpAccTEtEROVDdm+KRxBDSjnCoEJEROWDdlZZnrVTnjCoEBGR4RMCuJZ9ejHnQSlPGFSIiMjwPboKJN0FTFSAZ2OpqyE9YlAhIiLDlz1Zm2djQGUlbS2kVzzrh4iIDMOZ9XnPkXLrH813HvYpdxhUiIhI/oQANo4AMlPzb1etddnUQ2WGQYWIiORPnfU8pIR8BJhZ5GxTwQeoXL9s66JSx6BCRETyl5X+/HbT0YDKWrpaqExxMC0REcnfi0HFRCVdHVTmGFSIiEj+sjKe31byYIAxYVAhIiL5y+5RMVEBCoW0tVCZYlAhIiL5ezGokFFhUCEiIvnLPvRjYiZtHVTmGFSIiEj+2KNitBhUiIhI/hhUjBaDChERyR8P/RgtBhUiIpI/9qgYLQYVIiKSP21QYY+KsZFNUJk9ezYUCgXGjh0rdSlERCQ32kM/7FExNrIIKkePHsW3336LwMBAqUshIiI5yu5RUbJHxdhIHlSSk5PRp08ffPfdd6hQoYLU5RARkRzx0I/RkjyojBw5Eh06dEBoaGiBbdPS0pCYmKjzRURERoCHfoyWpFd2Wrt2Lf79918cPXq0UO1nzZqF8PDwUq6KiIhkh2f9GC3JelRu3bqFMWPGYM2aNbCwsCjUYyZPnoyEhATt161bt0q5SiIikgUe+jFakvWoHD9+HA8ePEC9evW0y7KysrBv3z4sWbIEaWlpMDEx0XmMubk5zM3Ny7pUIiKSGg/9GC3JgkqbNm1w+vRpnWUDBw5EzZo1MWnSpBwhhYiIjBgP/RgtyYKKra0t6tSpo7PM2toaFStWzLGciIiMHKfQN1qSn/VDRERUIPaoGC1Jz/p5WWRkpNQlEBGRHDGoGC32qBARkfzx0I/RYlAhIiL5Y4+K0WJQISIi+WNQMVoMKkREJH889GO0GFSIiEj+2KNitBhUiIhI/jiFvtFiUCEiIvnjFPpGi0GFiIjkj4d+jBaDChERyR8P/RgtBhUiIpI/HvoxWgwqREQkfzz0Y7QYVIiISP44j4rRYlAhIiL5Y4+K0WJQISIi+VNzjIqxYlAhIiL546Efo8WgQkRE8sdDP0aLQYWIiOSPQcVoMagQEZH88dCP0WJQISIi+WOPitFiUCEiInkTgkHFiDGoEBGRvKkzn9/moR+jw6BCRETylt2bArBHxQgxqBARkbwxqBg1BhUiIpK37DN+oACUJpKWQmWPQYWIiOTtxYG0CoW0tVCZY1AhIiJ54xk/Ro1BhYiI5I2TvRk1BhUiIpI39qgYNQYVIiKSNwYVo8agQkRE8sZDP0aNQYWIiOSNPSpGjUGFiIjkTRtU2KNijBhUiIhI3rSHftijYowYVIiISN546MeoMagQEZG8cTCtUWNQISIieWOPilFjUCEiInljUDFqDCpERCRvPPRj1BhUiIhI3tijYtQYVIiISN4YVIwagwoREckbD/0YNQYVIiKSN/aoGDUGFSIikjdOoW/UGFSIiEjeOIW+UWNQISIieeOhH6PGoEJERPLGQz9GjUGFiIjkjYd+jBqDChERyRsP/Rg1BhUiIpI3HvoxagwqREQkbzz0Y9QYVIiISN546MeoMagQEZG8aXtUTKWtw8jcjU/FoStxuPkoRdI6ivWux8TEYP/+/bhx4wZSUlLg7OyMoKAgBAcHw8LCQt81EhGRMWOPiiQiLjzA1I1nEFbbFd/2bSBZHUUKKmvWrMGiRYtw7NgxuLq6wsPDA5aWlnj8+DGuXr0KCwsL9OnTB5MmTYKXl1dp1UxERMaEQUUSD5PSAADOtuaS1lHooBIUFASVSoUBAwbgjz/+gKenp876tLQ0REVFYe3atWjQoAG+/vprvPXWW3ovmIiIjAyvniwJbVCxkfZISaGDyuzZsxEWFpbnenNzc7Rs2RItW7bE559/juvXr+ujPiIiMnbsUZGEwfWo5BdSXlaxYkVUrFixWAURERHpYFCRxMNkAwsqL0pISMDOnTtx/fp1KBQK+Pj4IDQ0FHZ2dvquj4iIjB0P/UgiztB6VLKtXr0ao0aNQmJios5ye3t7fPPNN+jRo4feiiMiImKPStkTQsjm0E+R5lH5999/MXDgQHTt2hUnTpxAamoqUlJScOzYMXTq1Al9+/bFyZMnS6tWIiIyRgwqZS4xNRPpWWoAQEVraV/3IvWoLF68GF27dsWKFSt0lterVw8rV65ESkoKFi1ahB9//FGfNRIRkTHjoZ8y9zD5GQDAzsIUFmYmktZSpB6VgwcPYujQoXmuHzZsGA4cOFDo7S1btgyBgYGws7ODnZ0dgoOD8ffffxelJCIiKu/Yo1LmHsjksA9QxKBy9+5d+Pn55bnez88Pd+7cKfT2KleujNmzZ+P48eM4duwYWrdujS5duuDs2bNFKYuIiMortRpQZ2puM6iUGbmMTwGKeOgnJSUl3ynyzc3N8ezZs0Jvr1OnTjr3P//8cyxbtgyHDx9G7dq1i1IaERGVR+qM57d56KfMPA8q0l8Wp8hn/Wzfvh329va5rouPjy92IVlZWVi3bh2ePn2K4ODgXNukpaUhLS1Ne//lM4+IiKicyT7sA7BHpQxp51CxMbAeFQDo379/vusVCkWRtnf69GkEBwfj2bNnsLGxwYYNG1CrVq1c286aNQvh4eFF2j4RERmwrBd7VBhUyoqcDv0UaYyKWq0u8CsrK6tIBdSoUQPR0dE4cuQIhg8fjv79++PcuXO5tp08eTISEhK0X7du3SrScxERkYHJ7lFRKAGltGefGBM5BZVizUyrTyqVCtWrVwcA1K9fH0ePHsWiRYvw7bff5mhrbm4Oc3PpXzQiIiojPONHEnIKKkXqUbl06RL++ecfnWURERFo1aoVGjVqhJkzZ5a4ILVarTMOhYiIjJh2DhUGlbIUl6wJiHIYo1KkoDJp0iRs3rxZez8mJgadOnWCSqVCcHAwZs2ahYULFxZ6e5MnT8a+fftw/fp1nD59GpMnT0ZkZCT69OlTlLKIiKi80vao8IyfspKlFnj8VD49KkU69HPs2DF8+OGH2vtr1qyBn58ftm/fDgAIDAzE4sWLMXbs2EJt78GDB+jXrx9iY2Nhb2+PwMBAbN++Ha+99lpRyiIiovKKh37K3KOnaVALQKkAHCWePh8oYlCJi4tD5cqVtff37NmjMxdKy5Yt8cEHHxR6ez/88ENRnp6IiIwNp88vc9njUyramMNEWbQzeUtDkQ79ODo6IjY2FoBmLMmxY8fw6quvatenp6dDCKHfComIyHixR6XMaQfSymB8ClDEoNKyZUt8+umnuHXrFhYuXAi1Wo2WLVtq1587dw7e3t56LpGIiIwWB9OWOTmd8QMU8dDP559/jtdeew1eXl4wMTHBV199BWtra+36VatWoXXr1novkoiIjBQP/ZQ57ay0hhhUvL29cf78eZw9exbOzs7w8PDQWR8eHq4zhoWIiKhEeOinzBl0jwoAmJqaom7durmuy2s5ERFRsTColDm5jVEpUlDp3r17rsvt7e3h5+eHd999F87OznopjIiIjExGKvBjGHDv9PNlQq35LpNDP38cv42vI69AXY7PG7mX8AyAgfao5HfV5O+++w5z587Fvn37UKdOHb0UR0RERuTcJiD2ZO7rqgSXbS15WH4oBlcfPpW6jFKnUAD+7nZSlwGgiEFl+fLlea5Tq9UYMmQIJk+ejL/++qvEhRERkZH5d6Xme/MPgEZDny9XmgLWFaWp6SXZh0XmvBEIH2frAlobLjc7C3g6WkldBgA9XpRQqVRi9OjRaN++vb42SURExiLuCnDjoOYqyQ0GA7auUleUg1ottNfAaeHnDDd7C4krMg5FmkelINbW1khJSdHnJomIyBicWKX5Xj0UsK8kbS15eJKSjqz/BqdUtOHg3rKi16Cyc+dO+Pn56XOTRERU3mVlACd/0dyu10/aWvKRPb+Io7UKZiZ6/fikfBTp0M+ff/6Z6/KEhAQcP34c33//Pb7//nu9FEZERAbm2HJg35eAyCra49SZwNOHgLUz4NeudGrTA7mdtmssihRUunbtmutyW1tb1KhRA99//z169uypj7qIiMiQZKYDuz8FUh4VfxsN35XNaci5yQ4qTrY87FOWihRU1Gp1adVBRESG7OJWTUixcQP6/AagiFfdNTUHnOQ9dCAumT0qUtDbWT9ERGTEsk8tDuoDuJfPWcrlNrW8sSj0aKC1a9cWeqO3bt3CwYMHi1UQEREZmPhbwNXdmttB70hbSyliUJFGoYPKsmXL4O/vjzlz5uD8+fM51ickJGDr1q3o3bs36tWrh0ePSnCckoiIDEf0GgAC8G4OOFaVuppSI7erChuLQh/62bt3L/78808sXrwYkydPhrW1NVxdXWFhYYEnT57g3r17cHJywoABA3DmzBm4uspvsh4iIiqhc5uAU78BQmiuw5PxFLgbrVlXr7+kpZW252f9cKK3slSkMSqdO3dG586dERcXhwMHDuDGjRtITU2Fk5MTgoKCEBQUBKWS55YTEZVLqfHAxhFAenLOddYugH/HMi+pLPHQjzSKNZjWyckpz1OViYionDq+XBNSKvoCwSM1V64zswZU1oDHK4CZpdQVlpr0TDWepGQAYFApazzrh4iICpaZDhz+RnO7+Xjgld7S1lPGHj3V9KaYKhVwsJTvXC/lEY/TEBFRwU6vA5LvAbbuQJ03pa6mzGkne7Mxh1JZxDliqETYo0JEZCwyUoETq4H0p0V/bPY8KY2HAabGNzMrx6dIh0GFiMhY7JsL7J9X/MerbID6A/RWjiGJ46nJkilWUJkxYwYmTJgAKysrneWpqamYO3cuPvnkE70UR0REepKWDBz976KxNToAlg5F3IACqNWlGI8rH3hBQukUK6iEh4dj2LBhOYJKSkoKwsPDGVSIiOTmxGrgWQLgWA3osRrgVBJFwkM/0inWT6oQAgpFzsFEJ0+ehKOjY4mLIiIiPcrKBA4v1dxuMoohpRg4K610itSjUqFCBSgUCigUCvj5+emElaysLCQnJ2PYsGF6L5KIiPLw8KLmqsX5uX0UiL8JWFUE6vYqm7rKmRfP+qGyVaSgsnDhQgghMGjQIISHh8Pe3l67TqVSwdvbG8HBwXovkoiIcnF1D7Cqa+HbN3qvXE/KVpp46Ec6RQoq/ftrruPg4+ODpk2bwtSUJw0REUkm+wweG1fA3C7/tnYeQOOhpV9TOcWgIp1iJQ1bW1ucP38eAQEBAIBNmzZh+fLlqFWrFqZPnw6VyvjOsSciKlN3TwDX9wNKU2DIbsC+smSlHLwSh9N3EiR7/tKWpRZ4mp4FgEFFCsUKKkOHDsVHH32EgIAAXLt2DT169ED37t2xbt06pKSkYOHChXouk4iIdBxaovleu7ukISU+JR39f/wHmWohWQ1lxdbCFNYqE6nLMDrFCiqXLl3CK6+8AgBYt24dQkJC8PPPP+PgwYPo2bMngwoRUWFlZRb9MQm3gLMbNLebvK/feoroTnwqMtUCVioTvB7gLmktpS3U3zXXM16pdBUrqAghoFarAQC7du1Cx46aS3t7enoiLi5Of9UREZVXQgC/9AQubSv+Nqq2BNwD9VZScWSP3fCqaI0v36oraS1UPhXrZPoGDRrgs88+w6pVq7B371506NABABATEwNXV1e9FkhEVC5d31+ykGKiAkI+0l89xcRBplTaitWjsnDhQvTp0wcbN27ElClTUL16dQDA77//jiZNmui1QCKicunQYs33+gOA0OlFf7ypJWBmoc+KikU7ERrnF6FSUqygEhgYiNOnT+dYPnfuXJiYcKAREVG+HpwHLu8AoACajAYsK0hdUbGxR4VKW4kmQjl+/DjOnz8PAKhVqxbq1aunl6KIiMq1qP/O2PHvBFSsJm0tJRSXnA6AQYVKT7GCyoMHD9CjRw/s3bsXDg4OAID4+Hi0atUKa9euhbOzsz5rJCIyLHFXgM1jgfTk3NffO6P53mR0mZVUWh4mPQPAoEKlp1iDad9//30kJyfj7NmzePz4MR4/fowzZ84gMTERo0cb/i8eEVGxZWUC64doBsvePZH7lzoD8G4OeDaUutoS0x764RgVKiXF6lHZtm0bdu3aBX9/f+2yWrVqYenSpWjbtq3eiiMiMjhRS4C7/wLm9kDXrzVn57xMoSwXIQXgGBUqfcUKKmq1GmZmZjmWm5mZaedXISIyGkn3gaRYzVWM98zULGs3E/DvKG1dpexZRhYSn2kmrGNQodJSrKDSunVrjBkzBr/88gs8PDwAAHfu3MG4cePQpk0bvRZIRCRrcVeAb5sDGSnPl1VrA7zSR7qaykjcf6cmq0yVsLPgRWqpdBRrjMqSJUuQmJgIb29vVKtWDdWqVYOPjw8SExOxePFifddIRCRfEdM1IcXcDrD1ANxfATp/BRjBVOsvjk/h1PJUWooVgT09PfHvv/9i165duHDhAgDA398foaGhei2OiEjWbv0DnP9LM+Zk8A7Axb/gx5QjHJ9CZaHYfXUKhQKvvfYaXnvtNX3WQ0RkGIQAdkzV3H6lj9GFFOCFWWkZVKgUFSmo7N69G6NGjcLhw4dhZ2ensy4hIQFNmjTBN998g+bNm+u1SCKiMqNWA3++D9z+p4B2mcDja5qp7Ft9XDa1yQx7VKgsFCmoLFy4EEOGDMkRUgDA3t4eQ4cOxfz58xlUiMhwnV0PRK8ufPumYwA7j9KrR8ayg4oT51ChUlSkoHLy5El88cUXea5v27YtvvzyyxIXRUQkicw0ICJcc/vVEUDNAk4vNrMA3INKvy6ZYo8KlYUiBZX79+/nOn+KdmOmpnj48GGJiyIiksTRH4D4m4CtO9B6KqCykroiWeOVk6ksFCmoVKpUCWfOnEH16tVzXX/q1Cm4u7vrpTAiIr25fQy4urvgdoe/1nxvOZkhpRDYo0JloUhB5fXXX8fUqVPRrl07WFhY6KxLTU3FtGnT0LFj+Z6JkYgMzNM4YFU3IC2xcO2dahjFZG0lJYTQBhUXBhUqRUUKKv/3f/+H9evXw8/PD6NGjUKNGjUAABcuXMDSpUuRlZWFKVOmlEqhRETFsm+uJqRU8AGqtsy/rdIUaDAQMOEsqwVJTstEWqbmkikcTEulqUi/ja6urjh06BCGDx+OyZMnQwgBQDOnSlhYGJYuXQpXV9dSKZSIqMgeX9OMOwGATgsLDipUaNm9KbbmprBUmUhcDZVnRf63wcvLC1u3bsWTJ09w5coVCCHg6+uLChUqlEZ9REQ5qdVAwk1AFHAR1J3TAHUGUD2UIUXPOD6Fykqx+zcrVKiAhg3Lx2XKicjA/DEIOLuhkI0VQGh4qZaTm2cZWXiWkVXmz1tWbjzSXITRiUGFShkPxBKRYbl+8HlIUdkU0FgBNHoXcKtT6mW96PiNx+j93RHtGI7yjD0qVNoYVIjIcAgB7Pzv+joNBgEdF0hbTx6irj4yipCiMlHiNX+OS6TSxaBCRIbj3EbgznHAzBoI+UjqavKUPX5jeMtqmNC2hsTVlB4FAKVSIXUZVM4xqBCR9K7uBiK/0Ax8zc+jq5rvTUcDtvL9Tz57xlZXW3OY8IOcqEQYVIhIWhmpwKb3gcTbhWtv6w4Ejyrdmkro+RkxFgW0JKKCSBpUZs2ahfXr1+PChQuwtLREkyZN8MUXX2gnkiMiI3DkW01IsasMvD4XUBTQA+FeFzAvaBCttHjqLpH+SBpU9u7di5EjR6Jhw4bIzMzExx9/jLZt2+LcuXOwtraWsjQiKgspj4H98zW3W08Bar4ubT16wqBCpD+SBpVt27bp3F+xYgVcXFxw/PhxtGjRQqKqiKhUJN0Dzv8FqF+YW+T6fiAtAXCtAwT2kK42PXqalomn6Zp9ZFAhKjlZjVFJSEgAADg6Oua6Pi0tDWlpadr7iYmFvMgYEUkr4Q7wfRsgKTb39aHhgLJ8TMMe999AWkszE1hzanmiEpNNUFGr1Rg7diyaNm2KOnVyn5xp1qxZCA8v+xkmiagEniUCP7+tCSkOXkDlBrrr3V8BqreRpLTS8OJhH0VB422IqECyCSojR47EmTNncODAgTzbTJ48GePHj9feT0xMhKenZ1mUR0TFoc4C1g0A7p8BbFyBAZsBhypSV1WqOD6FSL9kEVRGjRqFzZs3Y9++fahcuXKe7czNzWFuzl9+IoMRtQS4GgGYWQG9fy33IQV4PoeKsw3/VhHpg6RBRQiB999/Hxs2bEBkZCR8fHykLIeI9On+OWD3Z5rbr88FPIKkraeMZPeoONmqJK6EqHyQNKiMHDkSP//8MzZt2gRbW1vcu3cPAGBvbw9LS0spSyOivDx9BDy+VkAjAWz5AMhKB/zaAa/0KZPS5EB76MeGk70R6YOkQWXZsmUAgJYtW+osX758OQYMGFD2BRFR/pIfAt80BZLvF669ZQWg06KCJ3ErRzhGhUi/JD/0Q0QGQghgyzhNSDG3A6xyn0ZAy0QFtP0MsHUrm/pkQjtGhUGFSC9kMZiWiAzAqd80E7YpzYABWwD3QKkrkqU49qgQ6RWDChHpysoEtn8MPDyvu/zOCc33lpMYUvIghGCPCpGeMagQka5Di4B/vs19XaX6QNNxZVuPAUlIzUBGluaQtpMNz/oh0gcGFSJ67t4ZYM8sze0WEwHnms/XKU0AnxDAhH828pI9kNbe0gzmppw+n0gf+BeHyBgk3QceXii43fYpgDoDqPE60GqKUZ2tow8844dI/xhUiMq75AeaU4qfPixce6uKRndKsb5wVloi/WNQISrPhAD+GqMJKZYVAJsCThU2MQNCpwE2LmVTXznDHhUi/WNQISrPTv4CXNyqOaW4/2bALfcrk5N+MKgQ6R+DClF5kJUJbP1Ac32dF90/q/neajJDShlgUCHSPwYVovLg4ALg+Irc11VuCDQZU6bl5ObwtUdYGXUdWeryOyP1vzfjAXCMCpE+MagQGbrYU0DkF5rbraYArrWfr1OYAF7BsjileN6Oizh6/YnUZZQJH2drqUsgKjek/+tFREX3LAG4eQSAACJmaE4prtlRM/eJTM/WuZf4DAAwvGU1VK5Qfq+O7m5vgSBPB6nLICo3GFSIDNGvfYGYvc/vWzkBHRfKNqQIIbTjN3o3qgJPRyuJKyIiQ8GgQmSIHsdovjvVACwdgJaTARtnSUvKT3JaJp5lqAEAThy/QURFwKBCZIgyUjTf31oBuNaStJTCyO5NsTU3haWKU8sTUeEppS6AiIohI1Xz3cwwxnrwtF0iKi4GFSJDI8TzHhUzwxjrkT21PA/7EFFRMagQGZqsdAD/zUXCHhUiKucYVIgMTXZvCsCgQkTlHoMKkaHJHp+iNNVcRNAAMKgQUXExqBAZGu1AWsMYnwIAcf+NUeHU8kRUVAwqRIbGwM74AZ4PpmWPChEVFYMKkaHJDiqmFtLWUQQ89ENExcWgQmRoDOzUZLVaIC45HQCDChEVHYMKkaExsEM/T1LSkaUWUCgAR2uV1OUQkYFhUCEyNJmGNZg2e3yKo5UKZib8k0NERcO/GkSGRtujYhhjVDg+hYhKgkGFyNBox6gYxqEfBhUiKgkGFSJDY2DzqGiDCudQIaJiYFAhMjQZzzTf2aNCREaAQYXI0GQf+jE1kKDCKycTUQkwqBAZGgM7PZk9KkRUEgwqRIbGwCZ8Y1AhopJgUCEyNJkGNkaF1/khohIwlboAImN2+0kKLt9PLtJjaj9+AhcAFx9l4O6FB6VTmJ6ohUB8SgYAnvVDRMXDoEIkkZT0TLRfuB9JaZlFetwKs/twMQH+F3UPfxw8WkrV6ZfKRAl7SzOpyyAiA8SgQiSRO09SkZSWCVOlArU87Ar9OKf4LCATcKnogEBz+1KsUH9eD3CHUqmQugwiMkAMKkQSyR5k6lXRCn+Oalb4B/7PDLgLTOpUD/ArwuOIiAwQB9MSSaTYg0yzJ3wzNYxr/RARlQSDCpFEnp+2W8TAYWCnJxMRlQSDCpFEtD0qRT0bxsAmfCMiKgkGFSKJFHsiNAYVIjIiDCpEEil2UMk0rKsnExGVBIMKkUSKFVSyMgD1f/OumHEwLRGVfwwqRBKJK84YleyBtAB7VIjIKDCoEEkgM0uNR0/TARSxRyV7fIpCCZioSqEyIiJ5YVAhksDjp+kQAlAqAEfrIgSOjBfGpyg40ysRlX8MKkQSePDf+JSKNuYwKcrU8tlBhZO9EZGRYFAhkkDJ51Dh+BQiMg4MKkQSKP4cKtmz0nIOFSIyDgwqRBLIDipORe1RyfzvOj8MKkRkJBhUiCTAHhUiosJhUCGSQPGvnMzp84nIuDCoEEmg5D0qHExLRMaBQYVIAsWalRYAMjhGhYiMC4MKkQRK3KPCeVSIyEgwqBCVsWcZWUh6prmwYPHHqPDQDxEZBwYVojKW3ZuiMlXCzsK0aA/mYFoiMjIMKkRl7MVZaRVFvV5PJntUiMi4MKgQlbFij08BXuhR4RgVIjIORex3Jipd1x4mY/jqf/EkJV3qUkpNakYWgOIGFZ6eTETGRdKgsm/fPsydOxfHjx9HbGwsNmzYgK5du0pZEkls1/n7uHg/SeoyysQrng5FfxDHqBCRkZE0qDx9+hR169bFoEGD0L17dylLIZnIPizyZv3KGNTUR+JqSo+5mRJVnayL/kAGFSIyMpIGlfbt26N9+/ZSlkAykx1UarjaopaHncTVyFB2UDFlUCEi42BQY1TS0tKQlpamvZ+YmChhNVQain0NHGPBHhUiMjIGddbPrFmzYG9vr/3y9PSUuiTSsxKdEWMMOJiWiIyMQQWVyZMnIyEhQft169YtqUsiPWNQKQB7VIjIyBjUoR9zc3OYm/MDrLxKz1TjSUoGgGJcrM9YcMI3IjIyBtWjQuXbo6ea3hQzEwXsLc0krkamOOEbERkZSXtUkpOTceXKFe39mJgYREdHw9HREVWqVJGwMpJC9mEfJxtzKJVFnFreGGRlAln/TYTHHhUiMhKSBpVjx46hVatW2vvjx48HAPTv3x8rVqyQqCqSyotBhXKRfdgH4BgVIjIakgaVli1bQgghZQkkIxxIW4CMZ89vm/LQDxEZB45RIdnQBhX2qOQu+9RkU0ugqFddJiIyUAZ11g+Vb5zsLRfqrOe305M133nYh4iMCIMKyUYcg8pzcZeBDcOAO8dyruNAWiIyIgwqJBtGOUYl/hbw6LLusrgrwK5pzw/1vMynRenXRVSG1Go10tPTpS6D9MjMzAwmJiZ62RaDCsmGUQUVIYAj3wA7pgLqjNzb+LQAOi4ELCvoLrdyLPXyiMpKeno6YmJioFarpS6F9MzBwQFubm5QlHBMHYMKyYbRDKZ9GgdsHgec/1Nzv2J13ashK5VA7e5Ak/cBpX7+IyGSIyEEYmNjYWJiAk9PTyiVPL+jPBBCICUlBQ8ePAAAuLu7l2h7DCokC0/TMvE0XTNwtFz0qAgBPL4GZL3YWyKAC1uAAwuB9CRAaQaEzQQaDeFZPGSUMjMzkZKSAg8PD1hZcexVeWJpqfnn68GDB3BxcSnRYSAGFZKF7IG0VioTWJsb+I/ljShgx//lPhA2m3tdoOMCoFL9squLSGaysjT/nKhUKokrodKQHT4zMjIYVMjwGdz4lNQnwP55wMW/dU8hFllA/E3NbRMVYG6r+zhrF6D5eKDOm5pDPERU4jEMJE/6el8ZVEgWZDk+RQjg8g4gZp/u8sw04PQ64Fl87o9TKIF6/YGWkwFb11Ivk4gMy/Tp07Fx40ZER0fn2WbAgAGIj4/Hxo0by6wuuWJQIVmQdLK3p3HAwwu6y9KSgUNfATcO5v04Z3+g5STA1kN3uX0lwL6y/uskIpKJsgxSDCokC5Ic+nmWCBxcBEQt1b3g34tMLYC6PQELB93lrrWBOm/wrBwiolLGg+QkC6V66OdKBPBda2CWp+7X3GrA/i81IcW+CuBUQ/crqC/w/nGg0yLgtXDdr8C3GVKIjJRarcacOXNQvXp1mJubo0qVKvj888+16ydNmgQ/Pz9YWVmhatWqmDp1KjIycs6X9O2338LT0xNWVlZ4++23kZCQkO9zzpo1Cz4+PrC0tETdunXx+++/51tnWloaJk2aBE9PT5ibm6N69er44YcftOv37t2LRo0awdzcHO7u7vjoo4+QmZmpXf/7778jICAAlpaWqFixIkJDQ/H06VNMnz4dP/30EzZt2gSFQgGFQoHIyMgivIJFwx4VAxAT9xR/Rt9FVjmeEOno9ccAAKfi9qgkPwAOLwMS7+guj78F3DyU9+MqVgdCw4GaHXiKMJHEhBBIzcgquGEpsDQzKfTgz8mTJ+O7777DggUL0KxZM8TGxuLCheeHj21tbbFixQp4eHjg9OnTGDJkCGxtbfHhhx9q21y5cgW//fYb/vrrLyQmJmLw4MEYMWIE1qxZk+tzzpo1C6tXr8Y333wDX19f7Nu3D++88w6cnZ0REhKS62P69euHqKgofPXVV6hbty5iYmIQFxcHALhz5w5ef/11DBgwACtXrsSFCxcwZMgQWFhYYPr06YiNjUWvXr0wZ84cdOvWDUlJSdi/fz+EEJgwYQLOnz+PxMRELF++HADg6Fh6E1EyqBiA6X+exd5LD6Uuo0xUcsjngntqtWbMSMoj3eUPLwCHFj+/aN/LlGZAo/eA+v0B5Qs/8gol4FCFPSNEMpGakYVan2yX5LnPzQiDlargj8SkpCQsWrQIS5YsQf/+/QEA1apVQ7NmzbRt/u///k9729vbGxMmTMDatWt1gsqzZ8+wcuVKVKpUCQCwePFidOjQAfPmzYObm5vOc6alpWHmzJnYtWsXgoODAQBVq1bFgQMH8O233+YaVC5duoTffvsNO3fuRGhoqPYx2b7++mt4enpiyZIlUCgUqFmzJu7evYtJkybhk08+QWxsLDIzM9G9e3d4eXkBAAICArSPt7S0RFpaWo5aSwODigG49URzzZf2ddzgYiin7xaDm70lmlZ30pzuq37pv6rb/2imm7/7b94b8AgCanfTBJBsSjPALwxw9CmdoonIqJw/fx5paWlo06ZNnm1+/fVXfPXVV7h69SqSk5ORmZkJOzs7nTZVqlTRhhQACA4OhlqtxsWLF3N8+F+5cgUpKSl47bXXdJanp6cjKCgo1xqio6NhYmKSZ2/L+fPnERwcrNOL1LRpUyQnJ+P27duoW7cu2rRpg4CAAISFhaFt27Z48803UaFChVy3V5oYVAxA9viND9rWQHUXG4mrKWXnNwObRuZ96q/KBnAL1D1MY2oOvNJHM+085yYhMliWZiY4NyNMsucuVDvLfHp9AURFRaFPnz4IDw9HWFgY7O3tsXbtWsybN6/YtSUna3qLt2zZohNuAMDcPPd/XguqsyAmJibYuXMnDh06hB07dmDx4sWYMmUKjhw5Ah+fsv3Hj0FF5p5lZCHpmWZwk8FMhlZcN6KA3wcBWWk51ylN/5ub5CPAxqXsayOiUqdQKAp1+EVKvr6+sLS0REREBN59990c6w8dOgQvLy9MmTJFu+zGjRs52t28eRN3796Fh4dmeoPDhw9DqVSiRo0aOdrWqlUL5ubmuHnzZp49JC8LCAiAWq3G3r17tYd+XuTv748//vgDQghtr8rBgwdha2uLypU10ysoFAo0bdoUTZs2xSeffAIvLy9s2LAB48ePh0ql0s4sXNrk/RNB2t4UlYkSdhbl5O16+gi4vk/3OjiZaZpp57PSgBodgK5LdQ/hmJgDZhZlXysR0QssLCwwadIkfPjhh1CpVGjatCkePnyIs2fPYvDgwfD19cXNmzexdu1aNGzYEFu2bMGGDRty3U7//v3x5ZdfIjExEaNHj8bbb7+d65gPW1tbTJgwAePGjYNarUazZs2QkJCAgwcPws7OTjtW5kXe3t7o378/Bg0apB1Me+PGDTx48ABvv/02RowYgYULF+L999/HqFGjcPHiRUybNg3jx4+HUqnEkSNHEBERgbZt28LFxQVHjhzBw4cP4e/vr93+9u3bcfHiRVSsWBH29vYwMzPT/wsOBhXZe3EiNIOeZjozDbi0HTi5Fri8HVBn5t6uckPgje8BFS9QRkTyNHXqVJiamuKTTz7B3bt34e7ujmHDhgEAOnfujHHjxmHUqFFIS0tDhw4dMHXqVEyfPl1nG9WrV0f37t3x+uuv4/Hjx+jYsSO+/vrrPJ/z008/hbOzM2bNmoVr167BwcEB9erVw8cff5znY5YtW4aPP/4YI0aMwKNHj1ClShVt+0qVKmHr1q2YOHEi6tatC0dHRwwePFg7ENjOzg779u3DwoULkZiYCC8vL8ybNw/t27cHAAwZMgSRkZFo0KABkpOTsWfPHrRs2bIEr2reFEIIUSpbLgOJiYmwt7dHQkJCjoFK5cX2s/cwdNVx1PV0wKaRTaUuJ3+PY4DTvwPx13WXZzwDruzSHXfiUhuwcdZt51AFaDMdsK5YyoUSkRw8e/YMMTEx8PHxgYUFe0zLm/ze36J8frNHReZkeQ2cF6XGA+c2anpKbkbl39bWQzNRWt2egIt/WVRHREQGjkFF5iS/qrAQQGy0Johc2QVkpeuuT7r/fPCrQglUbQl4NdUdX6JQAO6vAD4tOGcJEREVCYOKzJXJxfrSU4CnD3SXZaYBF7dqAsrLF+x7mbM/8EovIOAtwM4j/7ZERERFwKAic3Gl1aOizgKuRWqCyPm/8r4oH6C5MF/NDkCdNwEbV911FnaaaegNeaAvERHJFoOKzGl7VIozRiXpPnBtj6Z35EWPLgOn1gHJ954vM7XM5XBNXc14klpdAAv7YlRPRERUMgwqMlfkMSrpKc8P2VyNAEQ+FzK0rKDpJanbE6hUn70iREQkOwwqMiaE0AYVnWv8PLwEnP5NczrwizKfAdf2AulJz5d5BAE2L00gZGEH+HcGfNsCpqpSqp6IiKjkGFRkLCktE2mZmh4RJ2UycGQ1cPKX/C/MB2jmIwnsqekpqVitDColIiIqHQwqMvYwKQ3OiMdH5r/D8qv+gPq/KecVJoDva4B385dO91UAbgFAlWBenI+IiMoFBhW5EQJIuA3cPwOL03ux23wFbBWpgBr/DW7t9d/ZN84FboqIiMjQMahIKSMVeHAeuH8GuHdG8/3+GeBZAgCgEgAogCtmfqjedwlQpbGk5RIRUfmxYsUKjB07FvHx8VKXki8GlbIgBJB0779Acvp5MHl0OfezcpSmgHNNXFF44aubPlD7dsOSKg3Kvm4iIiKJcSCDvmWmA7GngOifgW0fAz91BuZWA+bXBNa8CUSEA2f+AOIuakKKVUXAJwQIHgV0/QYYdgD4OBYYfhB/eH+CP9VN4GRrKfVeERHRf9LS0jB69Gi4uLjAwsICzZo1w9GjR7Xrnzx5gj59+sDZ2RmWlpbw9fXF8uXLAQDp6ekYNWoU3N3dYWFhAS8vL8yaNSvf5/vxxx9Ru3ZtmJubw93dHaNGjdKuu3nzJrp06QIbGxvY2dnh7bffxv3797XrT548iVatWsHW1hZ2dnaoX78+jh07hsjISAwcOBAJCQlQKBRQKBQ5rvAsF+xRKYnkh8D9088P29w7owkg6sycbRVKoKIv4FYHcK2jGfTqWgewdctz/hLJr/NDRFSWhAAyUqR5bjOrQs8l9eGHH+KPP/7ATz/9BC8vL8yZMwdhYWG4cuUKHB0dMXXqVJw7dw5///03nJyccOXKFaSmamb//uqrr/Dnn3/it99+Q5UqVXDr1i3cunUrz+datmwZxo8fj9mzZ6N9+/ZISEjAwYMHAQBqtVobUvbu3YvMzEyMHDkSPXr0QGRkJACgT58+CAoKwrJly2BiYoLo6GiYmZmhSZMmWLhwIT755BNcvHgRAGBjY1OCF7D0MKgURlYG8OjKf4HkhWCSfD/39ub2LwSS/767+ANmResZkf2Vk4mI9CkjBZgp0fXCPr4LqKwLbPb06VMsW7YMK1asQPv27QEA3333HXbu3IkffvgBEydOxM2bNxEUFIQGDTSH7L29vbWPv3nzJnx9fdGsWTMoFAp4eXnl+3yfffYZPvjgA4wZM0a7rGHDhgCAiIgInD59GjExMfD09AQArFy5ErVr18bRo0fRsGFD3Lx5ExMnTkTNmjUBAL6+vtrt2NvbQ6FQwM3tpbm2ZIZBJTdxV4DLO56PKXl48fkVgnUoAMeq/4WRAMC1tua2vadeZnlljwoRkbxcvXoVGRkZaNq0qXaZmZkZGjVqhPPnzwMAhg8fjjfeeAP//vsv2rZti65du6JJkyYAgAEDBuC1115DjRo10K5dO3Ts2BFt27bN9bkePHiAu3fvok2bNrmuP3/+PDw9PbUhBQBq1aoFBwcHnD9/Hg0bNsT48ePx7rvvYtWqVQgNDcVbb72FatUMa34tBpXc3IwCtk/WXaay0QQRbS9JgKaXxLz0usrK5MrJRERyYWal6dmQ6rn1pH379rhx4wa2bt2KnTt3ok2bNhg5ciS+/PJL1KtXDzExMfj777+xa9cuvP322wgNDcXvv/+eYzuWliUfnzh9+nT07t0bW7Zswd9//41p06Zh7dq16NatW4m3XVYYVHKR6vIKUDUMGU61ke5cCxlOtZFlX0X3on0AkAIgpXSOpwoBPH6aDoBBhYiMhEJRqMMvUqpWrRpUKhUOHjyoPWyTkZGBo0ePYuzYsdp2zs7O6N+/P/r374/mzZtj4sSJ+PLLLwEAdnZ26NGjB3r06IE333wT7dq1w+PHj+Ho6KjzXLa2tvD29kZERARatWqVoxZ/f3/tGJfsXpVz584hPj4etWrV0rbz8/ODn58fxo0bh169emH58uXo1q0bVCoVsrKy9P0S6R2DSi52PqqI0ef6v7Ak5r+vsqdQAI7WvB4PEZEcWFtbY/jw4Zg4cSIcHR1RpUoVzJkzBykpKRg8eDAA4JNPPkH9+vVRu3ZtpKWlYfPmzfD39wcAzJ8/H+7u7ggKCoJSqcS6devg5uYGBweHXJ9v+vTpGDZsGFxcXNC+fXskJSXh4MGDeP/99xEaGoqAgAD06dMHCxcuRGZmJkaMGIGQkBA0aNAAqampmDhxIt588034+Pjg9u3bOHr0KN544w0AmrEzycnJiIiIQN26dWFlZQUrK/31LOkLg0ouTBQKmJvK48ztDoHuMDORRy1ERATMnj0barUaffv2RVJSEho0aIDt27ejQoUKAACVSoXJkyfj+vXrsLS0RPPmzbF27VoAml6SOXPm4PLlyzAxMUHDhg2xdetWKPO47En//v3x7NkzLFiwABMmTICTkxPefPNNAIBCocCmTZvw/vvvo0WLFlAqlWjXrh0WL14MADAxMcGjR4/Qr18/3L9/H05OTujevTvCw8MBAE2aNMGwYcPQo0cPPHr0CNOmTZPlKcoKIYSQuojiSkxMhL29PRISEmBnZyd1OUREVATPnj1DTEwMfHx8YGFhIXU5pGf5vb9F+fzmv+pEREQkWwwqREREJFsMKkRERCRbDCpEREQkWwwqREREJFsMKkREJCkDPvmU8qGv95VBhYiIJGFiYgIASE9Pl7gSKg0p/83cbmZmVqLtcMI3IiKShKmpKaysrPDw4UOYmZnlOekZGRYhBFJSUvDgwQM4ODhoA2lxMagQEZEkFAoF3N3dERMTgxs3bkhdDumZg4MD3NzcSrwdBhUiIpKMSqWCr68vD/+UM2ZmZiXuScnGoEJERJJSKpWcQp/yxAOCREREJFsMKkRERCRbDCpEREQkWwY9RiV7MpnExESJKyEiIqLCyv7cLsykcAYdVJKSkgAAnp6eEldCRERERZWUlAR7e/t82yiEAc9drFarcffuXdja2kKhUEhdTqlJTEyEp6cnbt26BTs7O6nLKXXGtL/c1/LLmPaX+1p+ldb+CiGQlJQEDw+PAif6M+geFaVSicqVK0tdRpmxs7Mzil+MbMa0v9zX8suY9pf7Wn6Vxv4W1JOSjYNpiYiISLYYVIiIiEi2GFQMgLm5OaZNmwZzc3OpSykTxrS/3Nfyy5j2l/tafslhfw16MC0RERGVb+xRISIiItliUCEiIiLZYlAhIiIi2WJQISIiItliUJHIrFmz0LBhQ9ja2sLFxQVdu3bFxYsXddq0bNkSCoVC52vYsGE6bW7evIkOHTrAysoKLi4umDhxIjIzM8tyVwpl+vTpOfalZs2a2vXPnj3DyJEjUbFiRdjY2OCNN97A/fv3dbZhKPvq7e2dY18VCgVGjhwJwLDf13379qFTp07w8PCAQqHAxo0bddYLIfDJJ5/A3d0dlpaWCA0NxeXLl3XaPH78GH369IGdnR0cHBwwePBgJCcn67Q5deoUmjdvDgsLC3h6emLOnDmlvWu5ym9/MzIyMGnSJAQEBMDa2hoeHh7o168f7t69q7ON3H4eZs+erdNGDvtb0Hs7YMCAHPvRrl07nTaG8t4WtK+5/f4qFArMnTtX28ZQ3tfCfNbo6+9vZGQk6tWrB3Nzc1SvXh0rVqzQz04IkkRYWJhYvny5OHPmjIiOjhavv/66qFKlikhOTta2CQkJEUOGDBGxsbHar4SEBO36zMxMUadOHREaGipOnDghtm7dKpycnMTkyZOl2KV8TZs2TdSuXVtnXx4+fKhdP2zYMOHp6SkiIiLEsWPHxKuvviqaNGmiXW9I+/rgwQOd/dy5c6cAIPbs2SOEMOz3devWrWLKlCli/fr1AoDYsGGDzvrZs2cLe3t7sXHjRnHy5EnRuXNn4ePjI1JTU7Vt2rVrJ+rWrSsOHz4s9u/fL6pXry569eqlXZ+QkCBcXV1Fnz59xJkzZ8Qvv/wiLC0txbfffltWu6mV3/7Gx8eL0NBQ8euvv4oLFy6IqKgo0ahRI1G/fn2dbXh5eYkZM2bovN8v/p7LZX8Lem/79+8v2rVrp7Mfjx8/1mljKO9tQfv64j7GxsaKH3/8USgUCnH16lVtG0N5XwvzWaOPv7/Xrl0TVlZWYvz48eLcuXNi8eLFwsTERGzbtq3E+8CgIhMPHjwQAMTevXu1y0JCQsSYMWPyfMzWrVuFUqkU9+7d0y5btmyZsLOzE2lpaaVZbpFNmzZN1K1bN9d18fHxwszMTKxbt0677Pz58wKAiIqKEkIY1r6+bMyYMaJatWpCrVYLIcrP+/ryH3i1Wi3c3NzE3Llztcvi4+OFubm5+OWXX4QQQpw7d04AEEePHtW2+fvvv4VCoRB37twRQgjx9ddfiwoVKujs66RJk0SNGjVKeY/yl9sH2sv++ecfAUDcuHFDu8zLy0ssWLAgz8fIcX/zCipdunTJ8zGG+t4W5n3t0qWLaN26tc4yQ3xfhcj5WaOvv78ffvihqF27ts5z9ejRQ4SFhZW4Zh76kYmEhAQAgKOjo87yNWvWwMnJCXXq1MHkyZORkpKiXRcVFYWAgAC4urpql4WFhSExMRFnz54tm8KL4PLly/Dw8EDVqlXRp08f3Lx5EwBw/PhxZGRkIDQ0VNu2Zs2aqFKlCqKiogAY3r5mS09Px+rVqzFo0CCdC2eWp/c1W0xMDO7du6fzPtrb26Nx48Y676ODgwMaNGigbRMaGgqlUokjR45o27Ro0QIqlUrbJiwsDBcvXsSTJ0/KaG+KJyEhAQqFAg4ODjrLZ8+ejYoVKyIoKAhz587V6TI3pP2NjIyEi4sLatSogeHDh+PRo0fadeX1vb1//z62bNmCwYMH51hniO/ry581+vr7GxUVpbON7DbZ2ygJg74oYXmhVqsxduxYNG3aFHXq1NEu7927N7y8vODh4YFTp05h0qRJuHjxItavXw8AuHfvns4PDgDt/Xv37pXdDhRC48aNsWLFCtSoUQOxsbEIDw9H8+bNcebMGdy7dw8qlSrHH3dXV1ftfhjSvr5o48aNiI+Px4ABA7TLytP7+qLs2nKr/cX30cXFRWe9qakpHB0dddr4+Pjk2Eb2ugoVKpRK/SX17NkzTJo0Cb169dK5eNvo0aNRr149ODo64tChQ5g8eTJiY2Mxf/58AIazv+3atUP37t3h4+ODq1ev4uOPP0b79u0RFRUFExOTcvve/vTTT7C1tUX37t11lhvi+5rbZ42+/v7m1SYxMRGpqamwtLQsdt0MKjIwcuRInDlzBgcOHNBZ/t5772lvBwQEwN3dHW3atMHVq1dRrVq1si6zRNq3b6+9HRgYiMaNG8PLywu//fZbiX6A5e6HH35A+/bt4eHhoV1Wnt5X0sjIyMDbb78NIQSWLVums278+PHa24GBgVCpVBg6dChmzZplUNOw9+zZU3s7ICAAgYGBqFatGiIjI9GmTRsJKytdP/74I/r06QMLCwud5Yb4vub1WSN3PPQjsVGjRmHz5s3Ys2cPKleunG/bxo0bAwCuXLkCAHBzc8sxMjv7vpubWylUqz8ODg7w8/PDlStX4ObmhvT0dMTHx+u0uX//vnY/DHFfb9y4gV27duHdd9/Nt115eV+za8ut9hffxwcPHuisz8zMxOPHjw32vc4OKTdu3MDOnTt1elNy07hxY2RmZuL69esADG9/s1WtWhVOTk46P7fl7b3dv38/Ll68WODvMCD/9zWvzxp9/f3Nq42dnV2J/xllUJGIEAKjRo3Chg0bsHv37hxdhLmJjo4GALi7uwMAgoODcfr0aZ0/Dtl/KGvVqlUqdetLcnIyrl69Cnd3d9SvXx9mZmaIiIjQrr948SJu3ryJ4OBgAIa5r8uXL4eLiws6dOiQb7vy8r76+PjAzc1N531MTEzEkSNHdN7H+Ph4HD9+XNtm9+7dUKvV2sAWHByMffv2ISMjQ9tm586dqFGjhuwODWSHlMuXL2PXrl2oWLFigY+Jjo6GUqnUHiYxpP190e3bt/Ho0SOdn9vy9N4Cmh7R+vXro27dugW2lev7WtBnjb7+/gYHB+tsI7tN9jZKuhMkgeHDhwt7e3sRGRmpc3pbSkqKEEKIK1euiBkzZohjx46JmJgYsWnTJlG1alXRokUL7TayTxlr27atiI6OFtu2bRPOzs6yOI31ZR988IGIjIwUMTEx4uDBgyI0NFQ4OTmJBw8eCCE0p8dVqVJF7N69Wxw7dkwEBweL4OBg7eMNaV+FECIrK0tUqVJFTJo0SWe5ob+vSUlJ4sSJE+LEiRMCgJg/f744ceKE9iyX2bNnCwcHB7Fp0yZx6tQp0aVLl1xPTw4KChJHjhwRBw4cEL6+vjqnsMbHxwtXV1fRt29fcebMGbF27VphZWUlyenJ+e1venq66Ny5s6hcubKIjo7W+T3OPhPi0KFDYsGCBSI6OlpcvXpVrF69Wjg7O4t+/frJbn/z29ekpCQxYcIEERUVJWJiYsSuXbtEvXr1hK+vr3j27Jl2G4by3hb0cyyE5vRiKysrsWzZshyPN6T3taDPGiH08/c3+/TkiRMnivPnz4ulS5fy9GRDByDXr+XLlwshhLh586Zo0aKFcHR0FObm5qJ69epi4sSJOvNtCCHE9evXRfv27YWlpaVwcnISH3zwgcjIyJBgj/LXo0cP4e7uLlQqlahUqZLo0aOHuHLlinZ9amqqGDFihKhQoYKwsrIS3bp1E7GxsTrbMJR9FUKI7du3CwDi4sWLOssN/X3ds2dPrj+3/fv3F0JoTlGeOnWqcHV1Febm5qJNmzY5XoNHjx6JXr16CRsbG2FnZycGDhwokpKSdNqcPHlSNGvWTJibm4tKlSqJ2bNnl9Uu6shvf2NiYvL8Pc6eM+f48eOicePGwt7eXlhYWAh/f38xc+ZMnQ93IeSxv/nta0pKimjbtq1wdnYWZmZmwsvLSwwZMkTndFUhDOe9LejnWAghvv32W2FpaSni4+NzPN6Q3teCPmuE0N/f3z179ohXXnlFqFQqUbVqVZ3nKAnFfztCREREJDsco0JERESyxaBCREREssWgQkRERLLFoEJERESyxaBCREREssWgQkRERLLFoEJERESyxaBCZABWrFiR4+qmlLuWLVti7NixpbLtR48ewcXFRXs9l7LyzTffoFOnTmX6nERywaBCJAMDBgyAQqGAQqGASqVC9erVMWPGDGRmZpbac16/fh0KhUJ7raGC/PHHH2jZsiXs7e1hY2ODwMBAzJgxA48fPy61Gotj/fr1+PTTT7X3vb29sXDhQr1s+/PPP0eXLl3g7e0N4PlraGJigjt37ui0jY2NhampKRQKhTbYuLu7Y/bs2TrtPvroIygUCkRGRuosb9myJfr27QsAGDRoEP7991/s379fL/tBZEgYVIhkol27doiNjcXly5fxwQcfYPr06Zg7d67UZQEApkyZgh49eqBhw4b4+++/cebMGcybNw8nT57EqlWrpC5Ph6OjI2xtbfW+3ZSUFPzwww8YPHhwjnWVKlXCypUrdZb99NNPqFSpks6yli1b5ggke/bsgaenp87yZ8+e4fDhw2jdujUAQKVSoXfv3vjqq6/0szNEhkQvE/ETUYn0799fdOnSRWfZa6+9Jl599VUhhBDLly8X9vb22nVXrlwRnTt3Fi4uLsLa2lo0aNBA7Ny5U+fxXl5e4vPPPxcDBw4UNjY2wtPTU+eCaHjp2h8hISG51nbkyBEBQCxcuDDX9U+ePClSTTNmzBA9e/YUVlZWwsPDQyxZskSnzbx580SdOnWElZWVqFy5shg+fHiO68UcOHBAhISECEtLS+Hg4CDatm0rHj9+LIQQIiQkRIwZM0Z7++X9TE5OFra2tmLdunU629ywYYOwsrISiYmJue7nunXrhLOzs86y7Ov9/N///Z/w9fXVWefn5yemTp0qAIiYmBghhOb6MTY2NtprpCQmJgozMzOxZMkSndd/9+7dOo8TQoi9e/cKlUqlczE5ImPAHhUimbK0tER6enqu65KTk/H6668jIiICJ06cQLt27dCpUyfcvHlTp928efPQoEEDnDhxAiNGjMDw4cNx8eJFAMA///wDANi1axdiY2Oxfv36XJ9rzZo1sLGxwYgRI3Jdnz12prA1zZ07F3Xr1sWJEyfw0UcfYcyYMdi5c6d2vVKpxFdffYWzZ8/ip59+wu7du/Hhhx9q10dHR6NNmzaoVasWoqKicODAAXTq1AlZWVk5alu/fj0qV66MGTNmIDY2FrGxsbC2tkbPnj2xfPlynbbLly/Hm2++mWdvzP79+1G/fv1c13Xu3BlPnjzBgQMHAAAHDhzAkydPcowradWqFZKTk3H06FHtNv38/PDGG2/gyJEjePbsGQBNL4u3t7f2EBMANGjQAJmZmThy5EiuNRCVW1InJSLS7VFRq9Vi586dwtzcXEyYMEEIkbNHJTe1a9cWixcv1t738vIS77zzjva+Wq0WLi4u2svWZ/cGnDhxIt/ttm/fXgQGBhZ9p/KoqV27djptevToIdq3b5/nNtatWycqVqyovd+rVy/RtGnTPNu/2KOS/ZwLFizQaXPkyBFhYmIi7t69K4QQ4v79+8LU1FRERkbmud0uXbqIQYMG6Sx78TUcO3asGDhwoBBCiIEDB4px48aJEydO5OgZqVSpkpg5c6YQQoiJEyeKESNGCCE0PTC7d+8WQgjRvHlz7bZeVKFCBbFixYo8ayQqj9ijQiQTmzdvho2NDSwsLNC+fXv06NED06dPz7VtcnIyJkyYAH9/fzg4OMDGxgbnz5/P0XsRGBiova1QKODm5oYHDx4UqS5RyAusF7am4ODgHPfPnz+vvb9r1y60adMGlSpVgq2tLfr27YtHjx4hJSUFwPMelZJo1KgRateujZ9++gkAsHr1anh5eaFFixZ5PiY1NRUWFhZ5rh80aBDWrVuHe/fuYd26dRg0aFCu7V4cpxIZGYmWLVsCAEJCQhAZGYnU1FQcOXIErVq1yvFYS0tL7etAZCwYVIhkolWrVoiOjsbly5eRmpqKn376CdbW1rm2nTBhAjZs2ICZM2di//79iI6ORkBAQI5DRWZmZjr3FQoF1Gp1kery8/PDtWvXkJGRkW+7wtaUn+vXr6Njx44IDAzEH3/8gePHj2Pp0qUAoN2OpaVlkerPy7vvvosVK1YA0Bz2GThwIBQKRZ7tnZyc8OTJkzzXBwQEoGbNmujVqxf8/f1Rp06dXNu1atUKBw8exKNHj3DixAmEhIQA0ASVPXv24NChQ0hPT9cOpH3R48eP4ezsXIS9JDJ8DCpEMmFtbY3q1aujSpUqMDU1zbftwYMHMWDAAHTr1g0BAQFwc3Mr8tweKpUKAHId2/Gi3r17Izk5GV9//XWu6+Pj44tU0+HDh3Pc9/f3BwAcP34carUa8+bNw6uvvgo/Pz/cvXtXp31gYCAiIiIKs4sANPuZ2z6+8847uHHjBr766iucO3cO/fv3z3c7QUFBOHfuXL5tBg0ahMjIyDx7UwBNUHn69Cnmz58PX19fuLi4AABatGiBf/75B3///Td8fX1znDF09epVPHv2DEFBQfnWQFTeMKgQGSBfX1+sX78e0dHROHnyJHr37l3knhIXFxdYWlpi27ZtuH//PhISEnJt17hxY3z44Yf44IMP8OGHHyIqKgo3btxAREQE3nrrLe3hk8LWdPDgQcyZMweXLl3C0qVLsW7dOowZMwYAUL16dWRkZGDx4sW4du0aVq1ahW+++Ubn8ZMnT8bRo0cxYsQInDp1ChcuXMCyZcsQFxeXa/3e3t7Yt28f7ty5o9OmQoUK6N69OyZOnIi2bduicuXK+b5eYWFhOHv2bL69KkOGDMHDhw/x7rvv5tmmatWqqFKlChYvXqztTQEAT09PeHh44H//+1+uh33279+PqlWrolq1avnWSVTeMKgQGaD58+ejQoUKaNKkCTp16oSwsDDUq1evSNswNTXFV199hW+//RYeHh7o0qVLnm2/+OIL/Pzzzzhy5AjCwsJQu3ZtjB8/HoGBgdqeiMLW9MEHH+DYsWMICgrCZ599hvnz5yMsLAwAULduXcyfPx9ffPEF6tSpgzVr1mDWrFk6j/fz88OOHTtw8uRJNGrUCMHBwdi0aVOevVAzZszA9evXUa1atRyHTQYPHoz09PR8e0CyBQQEoF69evjtt9/ybGNqagonJ6cCe8RatWqFpKQk7fiUbCEhIUhKSso1qPzyyy8YMmRIgXUSlTcKUdiRckREJeTt7Y2xY8eW2hT3RbVq1SqMGzcOd+/e1R4Ky8+WLVswceJEnDlzBkpl2f2fd/bsWbRu3RqXLl2Cvb19mT0vkRzkH/uJiMqhlJQUxMbGYvbs2Rg6dGihQgoAdOjQAZcvX8adO3fg6elZylU+Fxsbi5UrVzKkkFHioR8iMjpz5sxBzZo14ebmhsmTJxfpsWPHji3TkAIAoaGh2sNjRMaGh36IiIhIttijQkRERLLFoEJERESyxaBCREREssWgQkRERLLFoEJERESyxaBCREREssWgQkRERLLFoEJERESyxaBCREREsvX/ObMxFYroY34AAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -233,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 6, "id": "73432368-74ab-4ba5-8546-67d21ee00be7", "metadata": { "tags": [] @@ -241,8 +480,8 @@ "outputs": [], "source": [ "i = 0\n", - "cable_cost_dist = [0] * len(cap)\n", - "oss_cost_dist = [0] * len(cap)\n", + "cable_cost_dist = [0] * len(dist)\n", + "oss_cost_dist = [0] * len(dist)\n", "for x in capex_list_dist:\n", " cable_cost_dist[i] = x.get('Export System')\n", " oss_cost_dist[i] = x.get('Offshore Substation')\n", @@ -251,18 +490,15 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 7, "id": "f5e2a52e-eb9c-4405-974a-bd699b44fc75", "metadata": { - "jupyter": { - "source_hidden": true - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -272,14 +508,40 @@ } ], "source": [ - "plt.plot(cap, cable_cost_dist)\n", - "plt.plot(cap, oss_cost_dist)\n", + "plt.plot(dist, cable_cost_dist)\n", + "plt.plot(dist, oss_cost_dist)\n", "plt.title(\"Cable, OSS Cost by Distance to Shore\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.xlabel(\"DIstance to Shore (mi)\")\n", "plt.ylabel(\"Cost (USD)\")\n", "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4f606331-1524-42e2-a6c7-44e06c68607d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[85824900.0, 165624900.0, 205524900.0, 285324900.00000006, 365124900.00000006, 405024900.00000006]\n" + ] + } + ], + "source": [ + "print(cable_cost_dist)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d6dc085-dc82-403c-bf16-989cb39e1c4b", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 4760945af8a5be147e0bf94a57353a4173526c96 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 25 Aug 2021 11:23:56 -0600 Subject: [PATCH 015/240] new analysis notebooks, parametric run --- ORBIT/phases/design/electrical_export.py | 19 +- aubryn.ipynb | 188 ++++++++ bycap_bydist.ipynb | 464 ++++++++++++++++++ cable_comparison.ipynb | 521 +++++++++++++++++++++ dev.ipynb | 243 ---------- export_runs.ipynb | 568 ----------------------- gut_check_runs.ipynb | 212 +++++++++ oss_component_breakdown.ipynb | 450 ++++++++++++++++++ 8 files changed, 1845 insertions(+), 820 deletions(-) create mode 100644 aubryn.ipynb create mode 100644 bycap_bydist.ipynb create mode 100644 cable_comparison.ipynb delete mode 100644 dev.ipynb delete mode 100644 export_runs.ipynb create mode 100644 gut_check_runs.ipynb create mode 100644 oss_component_breakdown.ipynb diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 64143166..fc349884 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -168,9 +168,6 @@ def design_result(self): """ Returns the results of self.run(). """ - if not self._outputs: - raise Exception("Has OffshoreSubstationDesign been ran yet?") - return self._outputs #################### CABLES ######################## @@ -264,9 +261,10 @@ def substation_cost(self): """Returns total procuremet cost of the topside.""" return ( - self.mpt_cost + (self.mpt_cost + self.shunt_reactor_cost + self.switchgear_costs + ) / self.num_substations + self.topside_cost + self.ancillary_system_cost + self.land_assembly_cost @@ -280,7 +278,8 @@ def calc_mpt_cost(self): ) self.mpt_rating = ( round( - (self._plant_capacity / self.num_mpt) + (self._plant_capacity * 1.15 + / self.num_mpt) / 10.0 ) * 10.0 @@ -293,7 +292,8 @@ def calc_shunt_reactor_cost(self): for name, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - compensation * self._design.get("shunt_cost_rate", 120000) + compensation * self._design.get("shunt_cost_rate", 99000) + * self.num_cables ) def calc_switchgear_costs(self): @@ -336,8 +336,8 @@ def calc_assembly_cost(self): _design = self.config.get("substation_design", {}) topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) self.land_assembly_cost = ( - self.switchgear_costs - + self.shunt_reactor_cost + self.switchgear_costs / self.num_substations + + self.shunt_reactor_cost / self.num_substations + self.ancillary_system_cost ) * topside_assembly_factor @@ -405,8 +405,9 @@ def calc_topside_mass_and_cost(self): topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) topside_design_cost = _design.get("topside_design_cost", 4.5e6) - self.topside_mass = 3.85 * self.mpt_rating * self.num_mpt + 285 + self.topside_mass = 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 self.topside_cost = ( self.topside_mass * topside_fab_cost_rate + topside_design_cost ) + diff --git a/aubryn.ipynb b/aubryn.ipynb new file mode 100644 index 00000000..ddf43e84 --- /dev/null +++ b/aubryn.ipynb @@ -0,0 +1,188 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "425e445d-d671-410e-bdbf-3d7498fc0f8f", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "992084e9-831b-4283-82a6-7243b81de8b5", + "metadata": {}, + "outputs": [], + "source": [ + "config1 = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 45},\n", + " 'plant': {'num_turbines': 4, 'capacity': 48},\n", + " 'turbine': {'turbine_rating': 12},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "386c636d-f3dd-47ec-97eb-1a652a68bea4", + "metadata": {}, + "outputs": [], + "source": [ + "config2 = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 45},\n", + " 'plant': {'num_turbines': 2, 'capacity': 24},\n", + " 'turbine': {'turbine_rating': 12},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_185mm_66kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1626e009-4c93-41dc-9fa7-6e9ffd299861", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" + ] + } + ], + "source": [ + "design1 = ElectricalDesign(config1)\n", + "design1.run()\n", + "design2 = ElectricalDesign(config2)\n", + "design2.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9c63662e-c794-4dc1-8852-92afa2a93f07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "for 24 MW:\n", + "compensation = 10450757.32027138\n", + "transformer = 1750000\n", + "switchgear = 134000\n", + "\n", + "for 48 MW:\n", + "compensation = 750487.1946612032\n", + "transformer = 1750000\n", + "switchgear = 134000\n" + ] + } + ], + "source": [ + "print(\"for 24 MW:\")\n", + "print(\"compensation = \", design1.shunt_reactor_cost)\n", + "print(\"transformer = \", design1.mpt_cost)\n", + "print(\"switchgear = \", design1.switchgear_costs)\n", + "print(\"\")\n", + "print(\"for 48 MW:\")\n", + "print(\"compensation = \", design2.shunt_reactor_cost)\n", + "print(\"transformer = \", design2.mpt_cost)\n", + "print(\"switchgear = \", design2.switchgear_costs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00e698be-82d9-48d5-a8e5-7c706255c65d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/bycap_bydist.ipynb b/bycap_bydist.ipynb new file mode 100644 index 00000000..f8f54f95 --- /dev/null +++ b/bycap_bydist.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "34256382-d968-446b-b4f5-2900571b6202", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager\n", + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT.phases.design import OffshoreSubstationDesign\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "09623e08-fe09-46c6-8697-d80dfb455428", + "metadata": {}, + "source": [ + "## Cost Curves \n", + "#### Vary Plant Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ab071a0f-25e7-401e-952d-7d420fde68b4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" + ] + } + ], + "source": [ + "cap = np.arange(100,2010,10)\n", + "i = 0\n", + "capex_list = [None] * len(cap)\n", + "for x in cap:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + "# 'ExportSystemDesign',\n", + "# 'OffshoreSubstationDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = ElectricalDesign(config)\n", + " design.run()\n", + "# mpt_cost[i] = design.mpt_cost\n", + "# print(x, \":\", design.num_cables)\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + "# print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + " \n", + " \n", + "\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list[i] = project.capex_breakdown\n", + " i = i + 1\n" + ] + }, + { + "cell_type": "markdown", + "id": "79968dab-bc0a-4746-8205-306942cd0348", + "metadata": {}, + "source": [ + "#### Vary Distance to Shore" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2a9b6a5b-fa16-499d-b4fb-705ac25d44f5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "topside costs = 47151750.0\n", + "topside costs = 47151750.0\n", + "topside costs = 47151750.0\n", + "topside costs = 47151750.0\n", + "topside costs = 47151750.0\n", + "topside costs = 47151750.0\n" + ] + } + ], + "source": [ + "dist = [40, 80, 100, 140, 180, 200]\n", + "i = 0\n", + "mpt_cost = [0] * len(dist)\n", + "capex_list_dist = [None] * len(dist)\n", + "for x in dist:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': x},\n", + " 'plant': {'num_turbines': 60, 'capacity': 600},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + "# 'ExportSystemDesign',\n", + "# 'OffshoreSubstationDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = ElectricalDesign(config)\n", + " design.run()\n", + " mpt_cost[i] = design.mpt_cost\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + " print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list_dist[i] = project.capex_breakdown\n", + " i = i + 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2f8eda8b-9b2c-4b39-9912-f11507634a56", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Export System': 165624900.0,\n", + " 'Offshore Substation': 135441185.21562335,\n", + " 'Export System Installation': 116801066.62180227,\n", + " 'Offshore Substation Installation': 3098929.2998477924,\n", + " 'Turbine': 780000000,\n", + " 'Soft': 387000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "capex_list_dist[1]" + ] + }, + { + "cell_type": "markdown", + "id": "2336fbf6-9c9b-4ec6-b55f-f63b4bb01cda", + "metadata": { + "tags": [] + }, + "source": [ + "### Extract and Plot Cable + Substation Costs \n", + "#### By Plant Cap\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3558606a-2e7c-4aef-8652-db48274450fd", + "metadata": {}, + "outputs": [], + "source": [ + "i = 0\n", + "cable_cost = [0] * len(cap)\n", + "oss_cost = [0] * len(cap)\n", + "for x in capex_list:\n", + " cable_cost[i] = x.get('Export System')\n", + " oss_cost[i] = x.get('Offshore Substation')\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "362f145f-603a-4c5b-8b32-ea96d4e81f95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, cable_cost)\n", + "plt.plot(cap, oss_cost)\n", + "plt.title(\"Cable, OSS Cost by Plant Capacity\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "225fc353-d75d-43a4-a1f3-6305c6f10745", + "metadata": {}, + "source": [ + "#### By Distance" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "73432368-74ab-4ba5-8546-67d21ee00be7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "i = 0\n", + "cable_cost_dist = [0] * len(dist)\n", + "oss_cost_dist = [0] * len(dist)\n", + "for x in capex_list_dist:\n", + " cable_cost_dist[i] = x.get('Export System')\n", + " oss_cost_dist[i] = x.get('Offshore Substation')\n", + " i = i + 1" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f5e2a52e-eb9c-4405-974a-bd699b44fc75", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(dist, cable_cost_dist)\n", + "plt.plot(dist, oss_cost_dist)\n", + "plt.title(\"Cable, OSS Cost by Distance to Shore\")\n", + "plt.xlabel(\"DIstance to Shore (mi)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4f606331-1524-42e2-a6c7-44e06c68607d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[85824900.0, 165624900.0, 205524900.0, 285324900.00000006, 365124900.00000006, 405024900.00000006]\n" + ] + } + ], + "source": [ + "print(cable_cost_dist)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9d6dc085-dc82-403c-bf16-989cb39e1c4b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5045921-95dc-4967-b462-8ae593e1a363", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cable_comparison.ipynb b/cable_comparison.ipynb new file mode 100644 index 00000000..cdc90663 --- /dev/null +++ b/cable_comparison.ipynb @@ -0,0 +1,521 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 125, + "id": "6672f27a-8604-4f5c-b885-028ab3425360", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", + "metadata": {}, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + " 'distance_to_landfall': 50\n", + " },\n", + " 'plant': {\n", + " 'num_turbines': 60, \n", + "# 'capacity': 600\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + "# 'export_system_design': {\n", + "# 'cables': 'XLPE_500mm_220kV',\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "a1bb5c31-9881-46d8-bb20-b40ecb487ab9", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + " 'export_system_design.cables': ['XLPE_500mm_220kV', 'XLPE_630mm_220kV', 'XLPE_800mm_220kV', 'XLPE_1000m_220kV'],\n", + "# 'site.distance_to_landfall': np.arange(10,510,50),\n", + "# 'plant.num_turbines': np.arange(10,210,50), \n", + " 'plant.capacity': np.arange(100,2100,300)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "1627fd49-5e96-45c8-8d40-05f3b2bab6ba", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + " 'compensation': lambda run: run.cable.compensation_factor\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "514e6a20-be60-4048-9094-d49f49a69a5e", + "metadata": { + "tags": [] + }, + "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", + "
export_system_design.cablesplant.capacitycable_costoss_costcompensation
0XLPE_500mm_220kV10035258300.03.560015e+072.345849
1XLPE_500mm_220kV40070516600.06.951580e+072.345849
2XLPE_500mm_220kV700105774900.01.034314e+082.345849
3XLPE_500mm_220kV1000176291500.08.312412e+072.345849
4XLPE_500mm_220kV1300211549800.01.000819e+082.345849
5XLPE_500mm_220kV1600246808100.01.162024e+082.345849
6XLPE_500mm_220kV1900282066400.09.361490e+072.345849
7XLPE_630mm_220kV10037644200.03.739083e+072.682365
8XLPE_630mm_220kV40075288400.07.309717e+072.682365
9XLPE_630mm_220kV700112932600.01.088035e+082.682365
10XLPE_630mm_220kV1000150576800.07.979617e+072.682365
11XLPE_630mm_220kV1300188221000.09.737021e+072.682365
12XLPE_630mm_220kV1600225865200.01.155025e+082.682365
13XLPE_630mm_220kV1900263509400.09.318694e+072.682365
14XLPE_800mm_220kV10041143520.03.817732e+072.830167
15XLPE_800mm_220kV40082287040.07.467015e+072.830167
16XLPE_800mm_220kV700123430560.01.111630e+082.830167
17XLPE_800mm_220kV1000164574080.08.136915e+072.830167
18XLPE_800mm_220kV1300205717600.09.933643e+072.830167
19XLPE_800mm_220kV1600246861120.01.178620e+082.830167
20XLPE_800mm_220kV1900288004640.09.502209e+072.830167
21XLPE_1000m_220kV10045067000.04.000853e+073.174298
22XLPE_1000m_220kV40090134000.07.833257e+073.174298
23XLPE_1000m_220kV700135201000.01.166566e+083.174298
24XLPE_1000m_220kV1000180268000.08.503157e+073.174298
25XLPE_1000m_220kV1300225335000.01.039145e+083.174298
26XLPE_1000m_220kV1600270402000.01.233556e+083.174298
27XLPE_1000m_220kV1900315469000.09.929491e+073.174298
\n", + "
" + ], + "text/plain": [ + " export_system_design.cables plant.capacity cable_cost oss_cost \\\n", + "0 XLPE_500mm_220kV 100 35258300.0 3.560015e+07 \n", + "1 XLPE_500mm_220kV 400 70516600.0 6.951580e+07 \n", + "2 XLPE_500mm_220kV 700 105774900.0 1.034314e+08 \n", + "3 XLPE_500mm_220kV 1000 176291500.0 8.312412e+07 \n", + "4 XLPE_500mm_220kV 1300 211549800.0 1.000819e+08 \n", + "5 XLPE_500mm_220kV 1600 246808100.0 1.162024e+08 \n", + "6 XLPE_500mm_220kV 1900 282066400.0 9.361490e+07 \n", + "7 XLPE_630mm_220kV 100 37644200.0 3.739083e+07 \n", + "8 XLPE_630mm_220kV 400 75288400.0 7.309717e+07 \n", + "9 XLPE_630mm_220kV 700 112932600.0 1.088035e+08 \n", + "10 XLPE_630mm_220kV 1000 150576800.0 7.979617e+07 \n", + "11 XLPE_630mm_220kV 1300 188221000.0 9.737021e+07 \n", + "12 XLPE_630mm_220kV 1600 225865200.0 1.155025e+08 \n", + "13 XLPE_630mm_220kV 1900 263509400.0 9.318694e+07 \n", + "14 XLPE_800mm_220kV 100 41143520.0 3.817732e+07 \n", + "15 XLPE_800mm_220kV 400 82287040.0 7.467015e+07 \n", + "16 XLPE_800mm_220kV 700 123430560.0 1.111630e+08 \n", + "17 XLPE_800mm_220kV 1000 164574080.0 8.136915e+07 \n", + "18 XLPE_800mm_220kV 1300 205717600.0 9.933643e+07 \n", + "19 XLPE_800mm_220kV 1600 246861120.0 1.178620e+08 \n", + "20 XLPE_800mm_220kV 1900 288004640.0 9.502209e+07 \n", + "21 XLPE_1000m_220kV 100 45067000.0 4.000853e+07 \n", + "22 XLPE_1000m_220kV 400 90134000.0 7.833257e+07 \n", + "23 XLPE_1000m_220kV 700 135201000.0 1.166566e+08 \n", + "24 XLPE_1000m_220kV 1000 180268000.0 8.503157e+07 \n", + "25 XLPE_1000m_220kV 1300 225335000.0 1.039145e+08 \n", + "26 XLPE_1000m_220kV 1600 270402000.0 1.233556e+08 \n", + "27 XLPE_1000m_220kV 1900 315469000.0 9.929491e+07 \n", + "\n", + " compensation \n", + "0 2.345849 \n", + "1 2.345849 \n", + "2 2.345849 \n", + "3 2.345849 \n", + "4 2.345849 \n", + "5 2.345849 \n", + "6 2.345849 \n", + "7 2.682365 \n", + "8 2.682365 \n", + "9 2.682365 \n", + "10 2.682365 \n", + "11 2.682365 \n", + "12 2.682365 \n", + "13 2.682365 \n", + "14 2.830167 \n", + "15 2.830167 \n", + "16 2.830167 \n", + "17 2.830167 \n", + "18 2.830167 \n", + "19 2.830167 \n", + "20 2.830167 \n", + "21 3.174298 \n", + "22 3.174298 \n", + "23 3.174298 \n", + "24 3.174298 \n", + "25 3.174298 \n", + "26 3.174298 \n", + "27 3.174298 " + ] + }, + "execution_count": 129, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, module=ElectricalDesign, product=True)\n", + "parametric.run()\n", + "parametric.results\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "0f9311f2-9b72-4c71-b8e1-5ffc448bdaf8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plt.plot(parametric.results.cable_cost)\n", + "# plt.show()\n", + "# index = results.index" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# number per line = total / 4\n", + "# 0 - (num-1), num - (2num-1), etc \n", + "# \n", + "num = int(len(parametric.results) / 4)\n", + "print(num)\n", + "\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[0:num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[num:2*num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[2*num:3*num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[3*num:4*num])\n", + "plt.legend([\"500mm\",\"630mm\",\"800mm\",\"1000mm\"], loc = \"lower right\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0846621f-977c-4334-a263-4fda8b6ad271", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4acefb99-f145-44b3-85e0-ae270faf3bfd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2185809-c073-4e06-8616-27a5386df5e3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/dev.ipynb b/dev.ipynb deleted file mode 100644 index 9e5d1e89..00000000 --- a/dev.ipynb +++ /dev/null @@ -1,243 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import ElectricalDesign" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# ProjectManager.compile_input_dict([\n", - "# \"ElectricalDesign\",\n", - "# \"ExportCableInstallation\",\n", - "# \"OffshoreSubstationInstallation\"\n", - "# ])" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': 60, 'capacity': 600},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - "# 'num_redundant': 'int (optional)',\n", - "# 'touchdown_distance': 'm (optional, default: 0)',\n", - "# 'percent_added_length': 'float (optional)'\n", - " },\n", - "# 'substation_design': {\n", - "# 'mpt_cost_rate': 'USD/MW (optional)',\n", - "# 'topside_fab_cost_rate': 'USD/t (optional)',\n", - "# 'topside_design_cost': 'USD (optional)',\n", - "# 'shunt_cost_rate': 'USD/MW (optional)',\n", - "# 'switchgear_costs': 'USD (optional)',\n", - "# 'backup_gen_cost': 'USD (optional)',\n", - "# 'workspace_cost': 'USD (optional)',\n", - "# 'other_ancillary_cost': 'USD (optional)',\n", - "# 'topside_assembly_factor': 'float (optional)',\n", - "# 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - "# 'oss_pile_cost_rate': 'USD/t (optional)',\n", - "# 'num_substations': 'int (optional)'\n", - "# },\n", - "\n", - " 'design_phases': ['ElectricalDesign'],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\SBREDENK\\ORBIT\\library'\n", - "50\n", - "50\n" - ] - } - ], - "source": [ - "design = ElectricalDesign(config)\n", - "design.run()\n", - "project = ProjectManager(config)\n", - "project.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Export System': 135201000.0,\n", - " 'Offshore Substation': 72504376.0865882,\n", - " 'Export System Installation': 114479148.81358309,\n", - " 'Offshore Substation Installation': 3098929.2998477924,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2.345849005672588" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "design.cables[\"XLPE_500mm_220kV\"].compensation_factor" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "OrderedDict([('XLPE_500mm_220kV',\n", - " )])" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "design.cables" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mpt costs = 5250000\n", - "shunt reactor costs = 14075094.034035528\n", - "switchgear costs = 402000\n", - "topside costs = 42127500.0\n", - "ancillary system costs = 6000000.0\n", - "land assembly costs = 1535782.0525526644\n" - ] - }, - { - "ename": "AttributeError", - "evalue": "'ElectricalDesign' object has no attribute 'export_system'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"ancillary system costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mancillary_system_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"land assembly costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mland_assembly_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"cable costs = \"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdesign\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexport_system\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msystem_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mAttributeError\u001b[0m: 'ElectricalDesign' object has no attribute 'export_system'" - ] - } - ], - "source": [ - "print(\"mpt costs = \", design.mpt_cost)\n", - "print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "print(\"switchgear costs = \", design.switchgear_costs)\n", - "print(\"topside costs = \", design.topside_cost)\n", - "print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "print(\"land assembly costs = \", design.land_assembly_cost)\n", - "print(\"cable costs = \", design.export_system.system_cost)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/export_runs.ipynb b/export_runs.ipynb deleted file mode 100644 index 2dc0a298..00000000 --- a/export_runs.ipynb +++ /dev/null @@ -1,568 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "34256382-d968-446b-b4f5-2900571b6202", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import ElectricalDesign\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "id": "09623e08-fe09-46c6-8697-d80dfb455428", - "metadata": {}, - "source": [ - "## Cost Curves \n", - "#### Vary Plant Capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ab071a0f-25e7-401e-952d-7d420fde68b4", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" - ] - } - ], - "source": [ - "cap = np.arange(100,2010,10)\n", - "i = 0\n", - "mpt_cost = [0] * len(cap)\n", - "capex_list = [None] * len(cap)\n", - "for x in cap:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': ['ElectricalDesign'],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = ElectricalDesign(config)\n", - " design.run()\n", - " mpt_cost[i] = design.mpt_cost\n", - " #print(x, \":\", design.num_cables)\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - "# print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - "\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list[i] = project.capex_breakdown\n", - " i = i + 1\n" - ] - }, - { - "cell_type": "markdown", - "id": "79968dab-bc0a-4746-8205-306942cd0348", - "metadata": {}, - "source": [ - "#### Vary Distance to Shore" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2a9b6a5b-fa16-499d-b4fb-705ac25d44f5", - "metadata": {}, - "outputs": [], - "source": [ - "dist = [40, 80, 100, 140, 180, 200]\n", - "i = 0\n", - "mpt_cost = [0] * len(dist)\n", - "capex_list_dist = [None] * len(dist)\n", - "for x in dist:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': x},\n", - " 'plant': {'num_turbines': 60, 'capacity': 600},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': ['ElectricalDesign'],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = ElectricalDesign(config)\n", - " design.run()\n", - " mpt_cost[i] = design.mpt_cost\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - "# print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list_dist[i] = project.capex_breakdown\n", - " i = i + 1\n" - ] - }, - { - "cell_type": "markdown", - "id": "2336fbf6-9c9b-4ec6-b55f-f63b4bb01cda", - "metadata": { - "tags": [] - }, - "source": [ - "### Extract and Plot Cable + Substation Costs \n", - "#### By Plant Cap\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3558606a-2e7c-4aef-8652-db48274450fd", - "metadata": {}, - "outputs": [], - "source": [ - "i = 0\n", - "cable_cost = [0] * len(cap)\n", - "oss_cost = [0] * len(cap)\n", - "for x in capex_list:\n", - " cable_cost[i] = x.get('Export System')\n", - " oss_cost[i] = x.get('Offshore Substation')\n", - " i = i + 1" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "362f145f-603a-4c5b-8b32-ea96d4e81f95", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, cable_cost)\n", - "plt.plot(cap, oss_cost)\n", - "plt.title(\"Cable, OSS Cost by Plant Capacity\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "225fc353-d75d-43a4-a1f3-6305c6f10745", - "metadata": {}, - "source": [ - "#### By Distance" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "73432368-74ab-4ba5-8546-67d21ee00be7", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "i = 0\n", - "cable_cost_dist = [0] * len(dist)\n", - "oss_cost_dist = [0] * len(dist)\n", - "for x in capex_list_dist:\n", - " cable_cost_dist[i] = x.get('Export System')\n", - " oss_cost_dist[i] = x.get('Offshore Substation')\n", - " i = i + 1" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f5e2a52e-eb9c-4405-974a-bd699b44fc75", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(dist, cable_cost_dist)\n", - "plt.plot(dist, oss_cost_dist)\n", - "plt.title(\"Cable, OSS Cost by Distance to Shore\")\n", - "plt.xlabel(\"DIstance to Shore (mi)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "4f606331-1524-42e2-a6c7-44e06c68607d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[85824900.0, 165624900.0, 205524900.0, 285324900.00000006, 365124900.00000006, 405024900.00000006]\n" - ] - } - ], - "source": [ - "print(cable_cost_dist)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d6dc085-dc82-403c-bf16-989cb39e1c4b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/gut_check_runs.ipynb b/gut_check_runs.ipynb new file mode 100644 index 00000000..919f0217 --- /dev/null +++ b/gut_check_runs.ipynb @@ -0,0 +1,212 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "91b54f6c-aae3-40b8-861a-1bf35db84b75", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager\n", + "from ORBIT.phases.design import Cable\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ade5f020-f39a-457d-9210-cfd3d288412e", + "metadata": {}, + "outputs": [], + "source": [ + "config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 34, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': 98, 'capacity': 597.8},\n", + " 'turbine': {'turbine_rating': 6.1},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + "# 'num_redundant': 'int (optional)',\n", + "# 'touchdown_distance': 'm (optional, default: 0)',\n", + "# 'percent_added_length': 'float (optional)'\n", + " },\n", + "# 'substation_design': {\n", + "# 'mpt_cost_rate': 'USD/MW (optional)',\n", + "# 'topside_fab_cost_rate': 'USD/t (optional)',\n", + "# 'topside_design_cost': 'USD (optional)',\n", + "# 'shunt_cost_rate': 'USD/MW (optional)',\n", + "# 'switchgear_costs': 'USD (optional)',\n", + "# 'backup_gen_cost': 'USD (optional)',\n", + "# 'workspace_cost': 'USD (optional)',\n", + "# 'other_ancillary_cost': 'USD (optional)',\n", + "# 'topside_assembly_factor': 'float (optional)',\n", + "# 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + "# 'oss_pile_cost_rate': 'USD/t (optional)',\n", + "# 'num_substations': 'int (optional)'\n", + "# },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9072176e-a61b-4c00-997a-85bec06f786e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" + ] + }, + { + "data": { + "text/plain": [ + "{'Export System': 105802830.0,\n", + " 'Offshore Substation': 100262247.06430578,\n", + " 'Export System Installation': 114117083.59143695,\n", + " 'Offshore Substation Installation': 3126797.6636225265,\n", + " 'Turbine': 777140000.0,\n", + " 'Soft': 385580999.99999994,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project = ProjectManager(config)\n", + "project.run()\n", + "project.capex_breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3bc09aff-2233-43e7-8c5c-6dfdb37d221f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'export_system': {'system_cost': 105802830.0,\n", + " 'cable': {'linear_density': 90,\n", + " 'sections': [53.034],\n", + " 'number': 3,\n", + " 'cable_power': 249.5885151507681}},\n", + " 'offshore_substation_substructure': {'type': 'Monopile',\n", + " 'deck_space': 1,\n", + " 'mass': 1588.3736050922225,\n", + " 'length': 44,\n", + " 'unit_cost': 3529800.0000000005},\n", + " 'offshore_substation_topside': {'deck_space': 1,\n", + " 'mass': 2941.5,\n", + " 'unit_cost': 96732447.06430578},\n", + " 'num_substations': 1}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.phases[\"ElectricalDesign\"]._outputs\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "94ba321a-3a46-4cb6-a466-2c93397d6d3a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "electrical system: 40487857.73423793\n", + "structure: 50681550.0\n", + "facility: 6000000.0\n", + "land assembly: 3092839.3300678446\n" + ] + } + ], + "source": [ + "elec_cost = (\n", + " project.phases[\"ElectricalDesign\"].mpt_cost\n", + " + project.phases[\"ElectricalDesign\"].shunt_reactor_cost\n", + " + project.phases[\"ElectricalDesign\"].switchgear_costs\n", + ")\n", + "print(\"electrical system: \", elec_cost)\n", + "\n", + "struct_cost = (\n", + " project.phases[\"ElectricalDesign\"].topside_cost\n", + " + project.phases[\"ElectricalDesign\"].substructure_cost\n", + ")\n", + "print(\"structure: \",struct_cost)\n", + "\n", + "print(\"facility: \", project.phases[\"ElectricalDesign\"].ancillary_system_cost)\n", + "print(\"land assembly: \", project.phases[\"ElectricalDesign\"].land_assembly_cost)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ca180f7b-6a49-44b1-a082-316783101acd", + "metadata": {}, + "outputs": [], + "source": [ + "design = Cable(config)\n", + "design.run()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38e3babe-2b1d-4fec-afa6-e1b212ccb904", + "metadata": {}, + "outputs": [], + "source": [ + "design.cable.compensation" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/oss_component_breakdown.ipynb b/oss_component_breakdown.ipynb new file mode 100644 index 00000000..1c205c0f --- /dev/null +++ b/oss_component_breakdown.ipynb @@ -0,0 +1,450 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "9ca44daf-9e05-4ff7-bf05-a864acd2623e", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager\n", + "from ORBIT.phases.design import OffshoreSubstationDesign\n", + "from ORBIT.phases.design import ElectricalDesign\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "db5af5db-e245-4989-a8c8-f2f76f8f01a3", + "metadata": {}, + "source": [ + "## Cost Curves \n", + "#### Vary Plant Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f7857dd1-e6c7-4f31-bc77-a837d97c2462", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" + ] + } + ], + "source": [ + "cap = np.arange(100,2010,10)\n", + "i = 0\n", + "mpt_cost1 = [0] * len(cap)\n", + "shunt_list1 = [0] * len(cap)\n", + "switch_list1 = [0] * len(cap)\n", + "topside_list1 = [0] * len(cap)\n", + "capex_list1 = [None] * len(cap)\n", + "for x in cap:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ExportSystemDesign',\n", + " 'OffshoreSubstationDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = OffshoreSubstationDesign(config)\n", + " design.run()\n", + " mpt_cost1[i] = design.mpt_cost\n", + "# print(x, \":\", design.num_cables)\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + "# print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + " shunt_list1[i] = design.shunt_reactor_cost\n", + " switch_list1[i] = design.switchgear_costs\n", + " topside_list1[i] = design.topside_cost\n", + " \n", + "\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list1[i] = project.capex_breakdown\n", + " i = i + 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7347c506-7f27-4738-a133-b42f17fd4e67", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" + ] + } + ], + "source": [ + "cap = np.arange(100,2010,10)\n", + "i = 0\n", + "mpt_cost2 = [0] * len(cap)\n", + "shunt_list2 = [0] * len(cap)\n", + "switch_list2 = [0] * len(cap)\n", + "topside_list2 = [0] * len(cap)\n", + "capex_list2 = [None] * len(cap)\n", + "for x in cap:\n", + " config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", + " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_500mm_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }\n", + " design = ElectricalDesign(config)\n", + " design.run()\n", + " mpt_cost2[i] = design.mpt_cost\n", + "# print(x, \":\", design.num_cables)\n", + "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", + "# print(\"switchgear costs = \", design.switchgear_costs)\n", + "# print(\"topside costs = \", design.topside_cost)\n", + "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", + "# print(\"land assembly costs = \", design.land_assembly_cost)\n", + " shunt_list2[i] = design.shunt_reactor_cost\n", + " switch_list2[i] = design.switchgear_costs\n", + " topside_list2[i] = design.topside_cost\n", + " \n", + "\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " capex_list2[i] = project.capex_breakdown\n", + " i = i + 1" + ] + }, + { + "cell_type": "markdown", + "id": "093653d4-e392-46a3-aa34-ce522c2d7ae0", + "metadata": { + "tags": [] + }, + "source": [ + "### Plot Costs by Plant Capacity\n", + "#### Shunt Reactor\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1d6cf66a-ead9-4036-9612-380fcef1ab9e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, shunt_list1)\n", + "plt.plot(cap, shunt_list2)\n", + "plt.title(\"Shunt Reactor\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a0ea568e-2f52-4ed7-bc06-c4157c5e2453", + "metadata": { + "tags": [] + }, + "source": [ + "#### Switchgear" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "26ecc47f-420c-4315-9ce6-4b1ccca9608a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, switch_list1)\n", + "plt.plot(cap, switch_list2)\n", + "plt.title(\"Switchgear\")\n", + "plt.xlabel(\"DIstance to Shore (mi)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a6cf5e54-2238-4988-9c88-0708ae5353a8", + "metadata": { + "tags": [] + }, + "source": [ + "#### Topside" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d2cf82d5-58f3-4999-826a-116759a4d9f6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, topside_list1)\n", + "plt.plot(cap, topside_list2)\n", + "plt.title(\"Topside\")\n", + "plt.xlabel(\"Distance to Shore (mi)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ee87907e-7ddc-4159-8b7c-cba42890425f", + "metadata": { + "tags": [] + }, + "source": [ + "#### MPT" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0d3137c6-02f6-4220-bea8-208f56bd7a25", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(cap, mpt_cost1)\n", + "plt.plot(cap, mpt_cost2)\n", + "plt.title(\"MPT\")\n", + "plt.xlabel(\"DIstance to Shore (mi)\")\n", + "plt.ylabel(\"Cost (USD)\")\n", + "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 840138e8b5e9048ea0c572e357e08f62f623ab47 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Thu, 2 Sep 2021 13:19:28 -0600 Subject: [PATCH 016/240] added HVDC cable to lib, made HVDC changes to electrical_export and _cables, and wrote upa few scripts to test HVDC implementation --- ORBIT/phases/design/_cables.py | 32 +- ORBIT/phases/design/electrical_export.py | 34 +- cable_comparison.ipynb | 395 ++++++----------- hvdc_comparison.ipynb | 542 +++++++++++++++++++++++ library/cables/XLPE_1000m_220kV.yaml | 1 + library/cables/XLPE_1200m_300kV_DC.yaml | 10 + library/cables/XLPE_500mm_220kV.yaml | 1 + library/cables/XLPE_630mm_220kV.yaml | 1 + library/cables/XLPE_800mm_220kV.yaml | 1 + test_HVDC.ipynb | 235 ++++++++++ 10 files changed, 971 insertions(+), 281 deletions(-) create mode 100644 hvdc_comparison.ipynb create mode 100644 library/cables/XLPE_1200m_300kV_DC.yaml create mode 100644 test_HVDC.ipynb diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index c3e574ab..f70825f7 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -58,6 +58,7 @@ class Cable: "linear_density", "cost_per_km", "name", + "cable_type", ) def __init__(self, cable_specs, **kwargs): @@ -86,16 +87,19 @@ def __init__(self, cable_specs, **kwargs): self.line_frequency = cable_specs.get("line_frequency", 60) # Calc additional cable specs - self.calc_char_impedance(**kwargs) - self.calc_power_factor() + if self.cable_type == 'HVAC': + self.calc_char_impedance(**kwargs) + self.calc_power_factor() + self.calc_compensation_factor() self.calc_cable_power() - self.calc_compensation_factor() def calc_char_impedance(self): """ Calculate characteristic impedance of cable. """ - +# if self.cable_type == 'HVDC': +# self.char_impedance = 0 +# else: conductance = 1 / self.ac_resistance num = complex( @@ -122,13 +126,19 @@ def calc_cable_power(self): Calculate maximum power transfer through 3-phase cable in :math:`MW`. """ - self.cable_power = ( - np.sqrt(3) - * self.rated_voltage - * self.current_capacity - * self.power_factor - / 1000 - ) + if self.cable_type == 'HVDC': + self.cable_power = ( + self.current_capacity * self.rated_voltage * 2 / 1000 + ) + else: + self.cable_power = ( + np.sqrt(3) + * self.rated_voltage + * self.current_capacity + * self.power_factor + / 1000 + ) + def calc_compensation_factor(self): """ diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index fc349884..cabf5f99 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -34,6 +34,7 @@ class ElectricalDesign(CableSystem): "backup_gen_cost": "USD (optional)", "workspace_cost": "USD (optional)", "other_ancillary_cost": "USD (optional)", + "converter_cost": "USD (optional)", "topside_assembly_factor": "float (optional)", "oss_substructure_cost_rate": "USD/t (optional)", "oss_pile_cost_rate": "USD/t (optional)", @@ -126,6 +127,7 @@ def run(self): self.calc_ancillary_system_cost() self.calc_assembly_cost() self.calc_substructure_mass_and_cost() + self.calc_converter_cost() self._outputs["offshore_substation_substructure"] = { "type": "Monopile", # Substation install only supports monopiles @@ -183,7 +185,8 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ - + if self.cable.cable_type == 'HVDC': + print("Design uses HVDC cable") num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) @@ -264,6 +267,7 @@ def substation_cost(self): (self.mpt_cost + self.shunt_reactor_cost + self.switchgear_costs + + self.converter_cost ) / self.num_substations + self.topside_cost + self.ancillary_system_cost @@ -287,10 +291,14 @@ def calc_mpt_cost(self): def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" - # get distance to shore + # get distance to shore touchdown = self.config["site"]["distance_to_landfall"] - for name, cable in self.cables.items(): - compensation = touchdown * cable.compensation_factor # MW + + if self.cable.cable_type == "HVDC": + compensation = 0 + else: + for name, cable in self.cables.items(): + compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( compensation * self._design.get("shunt_cost_rate", 99000) * self.num_cables @@ -315,14 +323,24 @@ def calc_ancillary_system_cost(self): other_ancillary_cost : int | float """ - _design = self.config.get("substation_design", {}) - backup_gen_cost = _design.get("backup_gen_cost", 1e6) - workspace_cost = _design.get("workspace_cost", 2e6) - other_ancillary_cost = _design.get("other_ancillary_cost", 3e6) + backup_gen_cost = self._design.get("backup_gen_cost", 1e6) + workspace_cost = self._design.get("workspace_cost", 2e6) + other_ancillary_cost = self._design.get("other_ancillary_cost", 3e6) self.ancillary_system_cost = ( backup_gen_cost + workspace_cost + other_ancillary_cost ) + + def calc_converter_cost(self): + + if self.cable.cable_type == "HVDC": + self.converter_cost = ( + self.num_cables * self._design.get("converter_cost", 137e6) + ) + else: + self.converter_cost = 0 + + def calc_assembly_cost(self): """ diff --git a/cable_comparison.ipynb b/cable_comparison.ipynb index cdc90663..9df7fc58 100644 --- a/cable_comparison.ipynb +++ b/cable_comparison.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 125, + "execution_count": 1, "id": "6672f27a-8604-4f5c-b885-028ab3425360", "metadata": {}, "outputs": [], @@ -15,9 +15,14 @@ }, { "cell_type": "code", - "execution_count": 126, + "execution_count": 2, "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", - "metadata": {}, + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, "outputs": [], "source": [ "base_config = {\n", @@ -25,7 +30,7 @@ " 'site': {\n", " 'distance': 100, \n", " 'depth': 20, \n", - " 'distance_to_landfall': 50\n", + "# 'distance_to_landfall': 50\n", " },\n", " 'plant': {\n", " 'num_turbines': 60, \n", @@ -42,22 +47,22 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 3, "id": "a1bb5c31-9881-46d8-bb20-b40ecb487ab9", "metadata": {}, "outputs": [], "source": [ "parameters = {\n", " 'export_system_design.cables': ['XLPE_500mm_220kV', 'XLPE_630mm_220kV', 'XLPE_800mm_220kV', 'XLPE_1000m_220kV'],\n", - "# 'site.distance_to_landfall': np.arange(10,510,50),\n", - "# 'plant.num_turbines': np.arange(10,210,50), \n", - " 'plant.capacity': np.arange(100,2100,300)\n", + " 'site.distance_to_landfall': np.arange(50,550,50),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,2300,300)\n", "}" ] }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 4, "id": "1627fd49-5e96-45c8-8d40-05f3b2bab6ba", "metadata": {}, "outputs": [], @@ -71,12 +76,19 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 5, "id": "514e6a20-be60-4048-9094-d49f49a69a5e", "metadata": { "tags": [] }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" + ] + }, { "data": { "text/html": [ @@ -99,6 +111,7 @@ " \n", " \n", " export_system_design.cables\n", + " site.distance_to_landfall\n", " plant.capacity\n", " cable_cost\n", " oss_cost\n", @@ -109,294 +122,138 @@ " \n", " 0\n", " XLPE_500mm_220kV\n", + " 50\n", " 100\n", - " 35258300.0\n", + " 3.525830e+07\n", " 3.560015e+07\n", " 2.345849\n", " \n", " \n", " 1\n", " XLPE_500mm_220kV\n", + " 50\n", " 400\n", - " 70516600.0\n", + " 7.051660e+07\n", " 6.951580e+07\n", " 2.345849\n", " \n", " \n", " 2\n", " XLPE_500mm_220kV\n", + " 50\n", " 700\n", - " 105774900.0\n", + " 1.057749e+08\n", " 1.034314e+08\n", " 2.345849\n", " \n", " \n", " 3\n", " XLPE_500mm_220kV\n", + " 50\n", " 1000\n", - " 176291500.0\n", + " 1.762915e+08\n", " 8.312412e+07\n", " 2.345849\n", " \n", " \n", " 4\n", " XLPE_500mm_220kV\n", + " 50\n", " 1300\n", - " 211549800.0\n", + " 2.115498e+08\n", " 1.000819e+08\n", " 2.345849\n", " \n", " \n", - " 5\n", - " XLPE_500mm_220kV\n", - " 1600\n", - " 246808100.0\n", - " 1.162024e+08\n", - " 2.345849\n", - " \n", - " \n", - " 6\n", - " XLPE_500mm_220kV\n", - " 1900\n", - " 282066400.0\n", - " 9.361490e+07\n", - " 2.345849\n", - " \n", - " \n", - " 7\n", - " XLPE_630mm_220kV\n", - " 100\n", - " 37644200.0\n", - " 3.739083e+07\n", - " 2.682365\n", - " \n", - " \n", - " 8\n", - " XLPE_630mm_220kV\n", - " 400\n", - " 75288400.0\n", - " 7.309717e+07\n", - " 2.682365\n", - " \n", - " \n", - " 9\n", - " XLPE_630mm_220kV\n", - " 700\n", - " 112932600.0\n", - " 1.088035e+08\n", - " 2.682365\n", - " \n", - " \n", - " 10\n", - " XLPE_630mm_220kV\n", - " 1000\n", - " 150576800.0\n", - " 7.979617e+07\n", - " 2.682365\n", - " \n", - " \n", - " 11\n", - " XLPE_630mm_220kV\n", - " 1300\n", - " 188221000.0\n", - " 9.737021e+07\n", - " 2.682365\n", - " \n", - " \n", - " 12\n", - " XLPE_630mm_220kV\n", - " 1600\n", - " 225865200.0\n", - " 1.155025e+08\n", - " 2.682365\n", - " \n", - " \n", - " 13\n", - " XLPE_630mm_220kV\n", - " 1900\n", - " 263509400.0\n", - " 9.318694e+07\n", - " 2.682365\n", - " \n", - " \n", - " 14\n", - " XLPE_800mm_220kV\n", - " 100\n", - " 41143520.0\n", - " 3.817732e+07\n", - " 2.830167\n", - " \n", - " \n", - " 15\n", - " XLPE_800mm_220kV\n", - " 400\n", - " 82287040.0\n", - " 7.467015e+07\n", - " 2.830167\n", - " \n", - " \n", - " 16\n", - " XLPE_800mm_220kV\n", - " 700\n", - " 123430560.0\n", - " 1.111630e+08\n", - " 2.830167\n", - " \n", - " \n", - " 17\n", - " XLPE_800mm_220kV\n", - " 1000\n", - " 164574080.0\n", - " 8.136915e+07\n", - " 2.830167\n", - " \n", - " \n", - " 18\n", - " XLPE_800mm_220kV\n", - " 1300\n", - " 205717600.0\n", - " 9.933643e+07\n", - " 2.830167\n", - " \n", - " \n", - " 19\n", - " XLPE_800mm_220kV\n", - " 1600\n", - " 246861120.0\n", - " 1.178620e+08\n", - " 2.830167\n", - " \n", - " \n", - " 20\n", - " XLPE_800mm_220kV\n", - " 1900\n", - " 288004640.0\n", - " 9.502209e+07\n", - " 2.830167\n", - " \n", - " \n", - " 21\n", - " XLPE_1000m_220kV\n", - " 100\n", - " 45067000.0\n", - " 4.000853e+07\n", - " 3.174298\n", - " \n", - " \n", - " 22\n", - " XLPE_1000m_220kV\n", - " 400\n", - " 90134000.0\n", - " 7.833257e+07\n", - " 3.174298\n", - " \n", - " \n", - " 23\n", - " XLPE_1000m_220kV\n", - " 700\n", - " 135201000.0\n", - " 1.166566e+08\n", - " 3.174298\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", + " ...\n", " \n", " \n", - " 24\n", + " 315\n", " XLPE_1000m_220kV\n", + " 500\n", " 1000\n", - " 180268000.0\n", - " 8.503157e+07\n", + " 1.710268e+09\n", + " 3.890738e+08\n", " 3.174298\n", " \n", " \n", - " 25\n", + " 316\n", " XLPE_1000m_220kV\n", + " 500\n", " 1300\n", - " 225335000.0\n", - " 1.039145e+08\n", + " 2.137835e+09\n", + " 4.839672e+08\n", " 3.174298\n", " \n", " \n", - " 26\n", + " 317\n", " XLPE_1000m_220kV\n", + " 500\n", " 1600\n", - " 270402000.0\n", - " 1.233556e+08\n", + " 2.565402e+09\n", + " 5.794189e+08\n", " 3.174298\n", " \n", " \n", - " 27\n", + " 318\n", " XLPE_1000m_220kV\n", + " 500\n", " 1900\n", - " 315469000.0\n", - " 9.929491e+07\n", + " 2.992969e+09\n", + " 4.540108e+08\n", + " 3.174298\n", + " \n", + " \n", + " 319\n", + " XLPE_1000m_220kV\n", + " 500\n", + " 2200\n", + " 2.992969e+09\n", + " 4.605238e+08\n", " 3.174298\n", " \n", " \n", "\n", + "

320 rows × 6 columns

\n", "" ], "text/plain": [ - " export_system_design.cables plant.capacity cable_cost oss_cost \\\n", - "0 XLPE_500mm_220kV 100 35258300.0 3.560015e+07 \n", - "1 XLPE_500mm_220kV 400 70516600.0 6.951580e+07 \n", - "2 XLPE_500mm_220kV 700 105774900.0 1.034314e+08 \n", - "3 XLPE_500mm_220kV 1000 176291500.0 8.312412e+07 \n", - "4 XLPE_500mm_220kV 1300 211549800.0 1.000819e+08 \n", - "5 XLPE_500mm_220kV 1600 246808100.0 1.162024e+08 \n", - "6 XLPE_500mm_220kV 1900 282066400.0 9.361490e+07 \n", - "7 XLPE_630mm_220kV 100 37644200.0 3.739083e+07 \n", - "8 XLPE_630mm_220kV 400 75288400.0 7.309717e+07 \n", - "9 XLPE_630mm_220kV 700 112932600.0 1.088035e+08 \n", - "10 XLPE_630mm_220kV 1000 150576800.0 7.979617e+07 \n", - "11 XLPE_630mm_220kV 1300 188221000.0 9.737021e+07 \n", - "12 XLPE_630mm_220kV 1600 225865200.0 1.155025e+08 \n", - "13 XLPE_630mm_220kV 1900 263509400.0 9.318694e+07 \n", - "14 XLPE_800mm_220kV 100 41143520.0 3.817732e+07 \n", - "15 XLPE_800mm_220kV 400 82287040.0 7.467015e+07 \n", - "16 XLPE_800mm_220kV 700 123430560.0 1.111630e+08 \n", - "17 XLPE_800mm_220kV 1000 164574080.0 8.136915e+07 \n", - "18 XLPE_800mm_220kV 1300 205717600.0 9.933643e+07 \n", - "19 XLPE_800mm_220kV 1600 246861120.0 1.178620e+08 \n", - "20 XLPE_800mm_220kV 1900 288004640.0 9.502209e+07 \n", - "21 XLPE_1000m_220kV 100 45067000.0 4.000853e+07 \n", - "22 XLPE_1000m_220kV 400 90134000.0 7.833257e+07 \n", - "23 XLPE_1000m_220kV 700 135201000.0 1.166566e+08 \n", - "24 XLPE_1000m_220kV 1000 180268000.0 8.503157e+07 \n", - "25 XLPE_1000m_220kV 1300 225335000.0 1.039145e+08 \n", - "26 XLPE_1000m_220kV 1600 270402000.0 1.233556e+08 \n", - "27 XLPE_1000m_220kV 1900 315469000.0 9.929491e+07 \n", + " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", + "0 XLPE_500mm_220kV 50 100 \n", + "1 XLPE_500mm_220kV 50 400 \n", + "2 XLPE_500mm_220kV 50 700 \n", + "3 XLPE_500mm_220kV 50 1000 \n", + "4 XLPE_500mm_220kV 50 1300 \n", + ".. ... ... ... \n", + "315 XLPE_1000m_220kV 500 1000 \n", + "316 XLPE_1000m_220kV 500 1300 \n", + "317 XLPE_1000m_220kV 500 1600 \n", + "318 XLPE_1000m_220kV 500 1900 \n", + "319 XLPE_1000m_220kV 500 2200 \n", "\n", - " compensation \n", - "0 2.345849 \n", - "1 2.345849 \n", - "2 2.345849 \n", - "3 2.345849 \n", - "4 2.345849 \n", - "5 2.345849 \n", - "6 2.345849 \n", - "7 2.682365 \n", - "8 2.682365 \n", - "9 2.682365 \n", - "10 2.682365 \n", - "11 2.682365 \n", - "12 2.682365 \n", - "13 2.682365 \n", - "14 2.830167 \n", - "15 2.830167 \n", - "16 2.830167 \n", - "17 2.830167 \n", - "18 2.830167 \n", - "19 2.830167 \n", - "20 2.830167 \n", - "21 3.174298 \n", - "22 3.174298 \n", - "23 3.174298 \n", - "24 3.174298 \n", - "25 3.174298 \n", - "26 3.174298 \n", - "27 3.174298 " + " cable_cost oss_cost compensation \n", + "0 3.525830e+07 3.560015e+07 2.345849 \n", + "1 7.051660e+07 6.951580e+07 2.345849 \n", + "2 1.057749e+08 1.034314e+08 2.345849 \n", + "3 1.762915e+08 8.312412e+07 2.345849 \n", + "4 2.115498e+08 1.000819e+08 2.345849 \n", + ".. ... ... ... \n", + "315 1.710268e+09 3.890738e+08 3.174298 \n", + "316 2.137835e+09 4.839672e+08 3.174298 \n", + "317 2.565402e+09 5.794189e+08 3.174298 \n", + "318 2.992969e+09 4.540108e+08 3.174298 \n", + "319 2.992969e+09 4.605238e+08 3.174298 \n", + "\n", + "[320 rows x 6 columns]" ] }, - "execution_count": 129, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -410,21 +267,10 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 6, "id": "0f9311f2-9b72-4c71-b8e1-5ffc448bdaf8", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plt.plot(parametric.results.cable_cost)\n", "# plt.show()\n", @@ -433,20 +279,13 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 7, "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "7\n" - ] - }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -460,7 +299,10 @@ "# 0 - (num-1), num - (2num-1), etc \n", "# \n", "num = int(len(parametric.results) / 4)\n", - "print(num)\n", + "# print(num_per_cable)\n", + "\n", + "# num = num_per_cable / 10\n", + "# print(num)\n", "\n", "plt.plot(np.arange(num), parametric.results.cable_cost[0:num])\n", "plt.plot(np.arange(num), parametric.results.cable_cost[num:2*num])\n", @@ -474,11 +316,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "0846621f-977c-4334-a263-4fda8b6ad271", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Cable Cost ($)')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_per_cable = int(len(parametric.results) / 4)\n", + "print(num_per_cable)\n", + "\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[0:num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[num:2*num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[2*num:3*num])\n", + "plt.plot(np.arange(num), parametric.results.cable_cost[3*num:4*num])\n", + "plt.legend([\"500mm\",\"630mm\",\"800mm\",\"1000mm\"], loc = \"lower right\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "# plt.show()" + ] }, { "cell_type": "code", diff --git a/hvdc_comparison.ipynb b/hvdc_comparison.ipynb new file mode 100644 index 00000000..2a4fc896 --- /dev/null +++ b/hvdc_comparison.ipynb @@ -0,0 +1,542 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6672f27a-8604-4f5c-b885-028ab3425360", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", + "metadata": { + "jupyter": { + "source_hidden": true + }, + "tags": [] + }, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + "# 'distance_to_landfall': 50\n", + " },\n", + " 'plant': {\n", + " 'num_turbines': 60, \n", + "# 'capacity': 600\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + "# 'export_system_design': {\n", + "# 'cables': 'XLPE_500mm_220kV',\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a1bb5c31-9881-46d8-bb20-b40ecb487ab9", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + " 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + " 'site.distance_to_landfall': np.arange(30,330,30),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,2300,300)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1627fd49-5e96-45c8-8d40-05f3b2bab6ba", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + " 'compensation': lambda run: run.cable.compensation_factor\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "514e6a20-be60-4048-9094-d49f49a69a5e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n", + "Design uses HVDC cable\n" + ] + }, + { + "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", + "
export_system_design.cablessite.distance_to_landfallplant.capacitycable_costoss_costcompensation
0XLPE_1000m_220kV3010028067000.03.325204e+073.174298
1XLPE_1000m_220kV3040056134000.06.481958e+073.174298
2XLPE_1000m_220kV3070084201000.09.638712e+073.174298
3XLPE_1000m_220kV301000112268000.07.151858e+073.174298
4XLPE_1000m_220kV301300140335000.08.702323e+073.174298
.....................
155XLPE_1200m_300kV_DC3001000451499800.01.863550e+08NaN
156XLPE_1200m_300kV_DC3001300451499800.01.958453e+08NaN
157XLPE_1200m_300kV_DC3001600451499800.02.053356e+08NaN
158XLPE_1200m_300kV_DC3001900677249700.01.947288e+08NaN
159XLPE_1200m_300kV_DC3002200677249700.02.008696e+08NaN
\n", + "

160 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", + "0 XLPE_1000m_220kV 30 100 \n", + "1 XLPE_1000m_220kV 30 400 \n", + "2 XLPE_1000m_220kV 30 700 \n", + "3 XLPE_1000m_220kV 30 1000 \n", + "4 XLPE_1000m_220kV 30 1300 \n", + ".. ... ... ... \n", + "155 XLPE_1200m_300kV_DC 300 1000 \n", + "156 XLPE_1200m_300kV_DC 300 1300 \n", + "157 XLPE_1200m_300kV_DC 300 1600 \n", + "158 XLPE_1200m_300kV_DC 300 1900 \n", + "159 XLPE_1200m_300kV_DC 300 2200 \n", + "\n", + " cable_cost oss_cost compensation \n", + "0 28067000.0 3.325204e+07 3.174298 \n", + "1 56134000.0 6.481958e+07 3.174298 \n", + "2 84201000.0 9.638712e+07 3.174298 \n", + "3 112268000.0 7.151858e+07 3.174298 \n", + "4 140335000.0 8.702323e+07 3.174298 \n", + ".. ... ... ... \n", + "155 451499800.0 1.863550e+08 NaN \n", + "156 451499800.0 1.958453e+08 NaN \n", + "157 451499800.0 2.053356e+08 NaN \n", + "158 677249700.0 1.947288e+08 NaN \n", + "159 677249700.0 2.008696e+08 NaN \n", + "\n", + "[160 rows x 6 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, module=ElectricalDesign, product=True)\n", + "parametric.run()\n", + "parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0f9311f2-9b72-4c71-b8e1-5ffc448bdaf8", + "metadata": {}, + "outputs": [], + "source": [ + "# plt.plot(parametric.results.cable_cost)\n", + "# plt.show()\n", + "# index = results.index" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "80\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# number per line = total / 4\n", + "# 0 - (num-1), num - (2num-1), etc \n", + "# \n", + "num = int(len(parametric.results) / 2)\n", + "print(num)\n", + "\n", + "# Cable Cost\n", + "plt.plot(np.arange(100,2300,300), parametric.results.cable_cost[0:8])\n", + "plt.plot(np.arange(100,2300,300), parametric.results.cable_cost[num:num+8])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.show()\n", + "\n", + "# Substation Cost\n", + "plt.plot(np.arange(100,2300,300), parametric.results.oss_cost[0:8])\n", + "plt.plot(np.arange(100,2300,300), parametric.results.oss_cost[num:num+8])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.show()\n", + "\n", + "#Total Export System Cost\n", + "total_cost = parametric.results.oss_cost + parametric.results.cable_cost\n", + "plt.plot(np.arange(100,2300,300), total_cost[0:8])\n", + "plt.plot(np.arange(100,2300,300), total_cost[num:num+8])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0846621f-977c-4334-a263-4fda8b6ad271", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cable_vec = np.zeros((20,8))\n", + "oss_vec = np.zeros((20,8))\n", + "total_vec = np.zeros((20,8))\n", + "\n", + "for i in np.arange(8):\n", + " for j in np.arange(20):\n", + " index = 8 * j + i \n", + " cable_vec[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec[j,i] = parametric.results.oss_cost[index]\n", + " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", + "\n", + "num2 = int(len(cable_vec) / 2)\n", + "print(num2)\n", + "\n", + "# Cable Cost\n", + "plt.plot(np.arange(30,330,30), cable_vec[0:num2])\n", + "plt.plot(np.arange(30,330,30), cable_vec[num2:20])\n", + "\n", + "plt.legend([\"100 MW\",\"400 MW\",\"700 MW\"], loc = \"lower right\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.show()\n", + "\n", + "# Substation Cost\n", + "plt.plot(np.arange(30,330,30), oss_vec[0:num2])\n", + "plt.plot(np.arange(30,330,30), oss_vec[num2:20])\n", + "\n", + "plt.legend([\"100 MW\",\"400 MW\",\"700 MW\",\"1000 MW\",\"1300 MW\",\"1600 MW\",\"1900 MW\",\"2200 MW\"], loc = \"lower right\")\n", + "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.show()\n", + "\n", + "# # Total Export System Cost\n", + "# plt.plot(np.arange(30,330,30), total_vec[0:num2])\n", + "# plt.plot(np.arange(30,330,30), total_vec[num2:20])\n", + "\n", + "# plt.legend([\"100 MW\",\"400 MW\",\"700 MW\"], loc = \"lower right\")\n", + "# plt.ylabel(\"Export System Cost ($)\")\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fbdb3740-680a-4d92-a89d-caab35ee70b8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index 4d22f6ab..93fe52da 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -5,5 +5,6 @@ cost_per_km: 850000 # $ current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km +cable_type: HVAC # HVDC vs HVAC name: XLPE_1000m_220kV rated_voltage: 220 diff --git a/library/cables/XLPE_1200m_300kV_DC.yaml b/library/cables/XLPE_1200m_300kV_DC.yaml new file mode 100644 index 00000000..ecb5b1ef --- /dev/null +++ b/library/cables/XLPE_1200m_300kV_DC.yaml @@ -0,0 +1,10 @@ +ac_resistance: 0 # ohm/km +capacitance: 0 # nF/km +conductor_size: 1200 # mm^2 +cost_per_km: 745000 # $ +current_capacity: 1458 # A +inductance: 0 # mH/km +linear_density: 44 # t/km +cable_type: HVDC # HVDC vs HVAC +name: XLPE_1200m_300kV +rated_voltage: 300 \ No newline at end of file diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index 0271a400..c602bbf4 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -5,5 +5,6 @@ cost_per_km: 665000 # $ current_capacity: 655 # A inductance: 0.43 # mH/km linear_density: 90 # t/km +cable_type: HVAC # HVDC vs HVAC name: XLPE_500mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index 638d5ab7..ff5e4820 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -5,5 +5,6 @@ cost_per_km: 710000 # $ current_capacity: 715 # A inductance: 0.41 # mH/km linear_density: 96 # t/km +cable_type: HVAC # HVDC vs HVAC name: XLPE_630mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index 2b6c95b1..18ed6b96 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -5,5 +5,6 @@ cost_per_km: 776000 # $ current_capacity: 775 # A inductance: 0.40 # mH/km linear_density: 105 # t/km +cable_type: HVAC # HVDC vs HVAC name: XLPE_800mm_220kV rated_voltage: 220 \ No newline at end of file diff --git a/test_HVDC.ipynb b/test_HVDC.ipynb new file mode 100644 index 00000000..3bb39902 --- /dev/null +++ b/test_HVDC.ipynb @@ -0,0 +1,235 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f11c08fd-1397-46cb-bfc0-fe8bec7ccba1", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "76adf9c4-7e6e-41de-bc85-0a765074fd94", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 200},\n", + " 'plant': {'num_turbines': 4, 'capacity': 48},\n", + " 'turbine': {'turbine_rating': 12},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_1200m_300kV_DC\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ebb79d9f-e076-4649-ba7d-5a99c975fd97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", + "Design uses HVDC cable\n" + ] + } + ], + "source": [ + "design = ProjectManager(config)\n", + "design.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00691bac-4378-4e14-9eee-ef24081c25f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "151249900.0" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "design.capex_breakdown['Export System']" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ba713603-8158-45d7-af4d-2a425515144a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "134000\n", + "1750000\n", + "874.8\n" + ] + } + ], + "source": [ + "print(design.phases[\"ElectricalDesign\"].shunt_reactor_cost)\n", + "print(design.phases[\"ElectricalDesign\"].switchgear_costs)\n", + "print(design.phases[\"ElectricalDesign\"].mpt_cost)\n", + "print(design.phases[\"ElectricalDesign\"].cable.cable_power)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1dcd7372-003a-42a0-a882-7c287db7123c", + "metadata": {}, + "outputs": [], + "source": [ + "config_ac = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 200},\n", + " 'plant': {'num_turbines': 4, 'capacity': 48},\n", + " 'turbine': {'turbine_rating': 12},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': \"XLPE_1000m_220kV\",\n", + " # 'num_redundant': 'int (optional)',\n", + " # 'touchdown_distance': 'm (optional, default: 0)',\n", + " # 'percent_added_length': 'float (optional)'\n", + " },\n", + " # 'substation_design': {\n", + " # 'mpt_cost_rate': 'USD/MW (optional)',\n", + " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " # 'topside_design_cost': 'USD (optional)',\n", + " # 'shunt_cost_rate': 'USD/MW (optional)',\n", + " # 'switchgear_costs': 'USD (optional)',\n", + " # 'backup_gen_cost': 'USD (optional)',\n", + " # 'workspace_cost': 'USD (optional)',\n", + " # 'other_ancillary_cost': 'USD (optional)',\n", + " # 'topside_assembly_factor': 'float (optional)',\n", + " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " # 'num_substations': 'int (optional)'\n", + " # },\n", + "\n", + " 'design_phases': [\n", + " 'ElectricalDesign'\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "91b3c9e0-8b9b-4ef4-9626-f3cbd775d9bf", + "metadata": {}, + "outputs": [], + "source": [ + "design_ac = ProjectManager(config_ac)\n", + "design_ac.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "96f90240-f258-465d-b099-80fc370b97de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "62851104.43741779\n", + "134000\n", + "1750000\n", + "0\n" + ] + } + ], + "source": [ + "print(design_ac.phases[\"ElectricalDesign\"].shunt_reactor_cost)\n", + "print(design_ac.phases[\"ElectricalDesign\"].switchgear_costs)\n", + "print(design_ac.phases[\"ElectricalDesign\"].mpt_cost)\n", + "print(design_ac.phases[\"ElectricalDesign\"].converter_cost)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27551ffe-c367-4b3b-bbd7-1a4ba713c3b3", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 06261433b3024efa9ceb3f73692bbe44c9ea6be3 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 6 Oct 2021 14:22:21 -0600 Subject: [PATCH 017/240] hvdc capabilities + testing/analysis files --- ORBIT/phases/design/electrical_export.py | 5 +- ORBIT/phases/design/old_v_new.ipynb | 711 +++++++++++++++++++++++ ORBIT/phases/design/oss_design.py | 2 +- bycap_bydist.ipynb | 6 +- hvdc_comparison.ipynb | 613 ++++++++++++------- library/cables/XLPE_1200m_300kV_DC.yaml | 2 +- library/cables/XLPE_500mm_132kV.yaml | 1 + library/cables/XLPE_630mm_66kV.yaml | 1 + 8 files changed, 1117 insertions(+), 224 deletions(-) create mode 100644 ORBIT/phases/design/old_v_new.ipynb diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index cabf5f99..6850234b 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -185,13 +185,12 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ - if self.cable.cable_type == 'HVDC': - print("Design uses HVDC cable") +# if self.cable.cable_type == 'HVDC': +# print("Design uses HVDC cable") num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) self.num_cables = int(num_required + num_redundant) - #print(self.num_cables) def compute_cable_length(self): """ diff --git a/ORBIT/phases/design/old_v_new.ipynb b/ORBIT/phases/design/old_v_new.ipynb new file mode 100644 index 00000000..feb48418 --- /dev/null +++ b/ORBIT/phases/design/old_v_new.ipynb @@ -0,0 +1,711 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a52a565e-aae4-473a-86e1-b49bd4e85cdb", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "460416b8-ef30-4109-861a-b8c9208f8d27", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + "# 'distance_to_landfall': 50\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + "# 'export_system_design': {\n", + "# 'cables': 'XLPE_500mm_220kV',\n", + " 'design_phases': ['ExportSystemDesign', 'OffshoreSubstationDesign']\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "03d0cb25-dc29-4fe9-8326-0b6b4747cabb", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + " 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + " 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "11c2d8d2-ab29-4c16-8b7d-0b713209b090", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda project: project.phases['ExportSystemDesign'].total_cable_cost,\n", + " 'oss_cost': lambda project: project.phases['OffshoreSubstationDesign'].substation_cost,\n", + " 'num_substations': lambda project: project.phases['OffshoreSubstationDesign'].num_substations,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "46b78ce1-160d-4b06-ab70-8889c6caf31a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'c:\\users\\sbredenk\\orbit\\library'\n" + ] + }, + { + "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", + "
export_system_design.cablessite.distance_to_landfallplant.capacitycable_costoss_costnum_substations
0XLPE_1000m_220kV1510015317000.026226375.01
1XLPE_1000m_220kV1520015317000.036682875.01
2XLPE_1000m_220kV1530015317000.047826750.01
3XLPE_1000m_220kV1540030634000.058283250.01
4XLPE_1000m_220kV1550030634000.068739750.01
.....................
795XLPE_1200m_300kV_DC3001600506043400.0101484000.02
796XLPE_1200m_300kV_DC3001700506043400.077269500.03
797XLPE_1200m_300kV_DC3001800759065100.079883625.03
798XLPE_1200m_300kV_DC3001900759065100.082497750.03
799XLPE_1200m_300kV_DC3002000759065100.087726000.03
\n", + "

800 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", + "0 XLPE_1000m_220kV 15 100 \n", + "1 XLPE_1000m_220kV 15 200 \n", + "2 XLPE_1000m_220kV 15 300 \n", + "3 XLPE_1000m_220kV 15 400 \n", + "4 XLPE_1000m_220kV 15 500 \n", + ".. ... ... ... \n", + "795 XLPE_1200m_300kV_DC 300 1600 \n", + "796 XLPE_1200m_300kV_DC 300 1700 \n", + "797 XLPE_1200m_300kV_DC 300 1800 \n", + "798 XLPE_1200m_300kV_DC 300 1900 \n", + "799 XLPE_1200m_300kV_DC 300 2000 \n", + "\n", + " cable_cost oss_cost num_substations \n", + "0 15317000.0 26226375.0 1 \n", + "1 15317000.0 36682875.0 1 \n", + "2 15317000.0 47826750.0 1 \n", + "3 30634000.0 58283250.0 1 \n", + "4 30634000.0 68739750.0 1 \n", + ".. ... ... ... \n", + "795 506043400.0 101484000.0 2 \n", + "796 506043400.0 77269500.0 3 \n", + "797 759065100.0 79883625.0 3 \n", + "798 759065100.0 82497750.0 3 \n", + "799 759065100.0 87726000.0 3 \n", + "\n", + "[800 rows x 6 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, product=True)\n", + "parametric.run()\n", + "parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "markdown", + "id": "d4b6054d-cd43-4718-8fcc-7af9bb10f457", + "metadata": { + "tags": [] + }, + "source": [ + "# Varying plant capacity for given distance to shore" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "866139bd-732a-435a-8a09-919e9c3e5509", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "400\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# number per line = total / 4\n", + "# 0 - (num-1), num - (2num-1), etc \n", + "# \n", + "num = int(len(parametric.results) / 2)\n", + "print(num)\n", + "\n", + "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", + "\n", + "index = 3\n", + "# Cable Cost\n", + "plt.step(np.arange(100,2100,100), parametric.results.cable_cost[0+20*index:20*(index+1)])\n", + "# plt.plot(np.arange(100,2100,100), parametric.results.cable_cost[num+20*index:num+20*(index+1)])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,7.5e8])\n", + "plt.show()\n", + "\n", + "# Substation Cost\n", + "plt.plot(np.arange(100,2100,100), sub_cost[0+20*index:20*(index+1)])\n", + "# plt.plot(np.arange(100,2100,100), parametric.results.oss_cost[num+20*index:num+20*(index+1)])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,7.5e8])\n", + "plt.show()\n", + "\n", + "#Total Export System Cost\n", + "total_cost = sub_cost + parametric.results.cable_cost\n", + "plt.plot(np.arange(100,2100,100), total_cost[0+20*index:20*(index+1)])\n", + "# plt.plot(np.arange(100,2100,100), total_cost[num+20*index:num+20*(index+1)])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Total Export Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,7.5e8])\n", + "plt.rcParams.update({'font.size':16})\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4518cd2a-1f1b-4a9f-bfa8-e17638e81182", + "metadata": { + "tags": [] + }, + "source": [ + "# Varying distance to shore for given plant capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "54227dd3-14c9-418f-b6cb-00d78ac56039", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cable_vec = np.zeros((40,20))\n", + "oss_vec = np.zeros((40,20))\n", + "total_vec = np.zeros((40,20))\n", + "num2 = int(len(cable_vec) / 2)\n", + "print(num2)\n", + "for i in np.arange(20):\n", + " for j in np.arange(40):\n", + " index = 20 * j + i \n", + " cable_vec[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec[j,i] = parametric.results.oss_cost[index]\n", + " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", + "\n", + "ind = 19\n", + "# Cable Cost\n", + "plt.plot(np.arange(15,315,15), cable_vec[0:num2,ind])\n", + "plt.plot(np.arange(15,315,15), cable_vec[num2:40,ind])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", + "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.show()\n", + "\n", + "# Substation Cost\n", + "plt.plot(np.arange(15,315,15), oss_vec[0:num2,ind])\n", + "plt.plot(np.arange(15,315,15), oss_vec[num2:40,ind])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", + "plt.show()\n", + "\n", + "# Total Export System Cost\n", + "plt.plot(np.arange(15,315,15), total_vec[0:num2,ind])\n", + "plt.plot(np.arange(15,315,15), total_vec[num2:40,ind])\n", + "\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.ylabel(\"Export System Cost ($)\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "43c40ba5-5014-4b45-b9e1-9a5bfd4f5fb8", + "metadata": { + "tags": [] + }, + "source": [ + "# Contour for which is cheaper" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "fd400f16-b4b7-400b-a803-b02126008ce8", + "metadata": {}, + "outputs": [], + "source": [ + "cable_vec_ac = np.zeros((20,20))\n", + "oss_vec_ac = np.zeros((20,20))\n", + "total_vec_ac = np.zeros((20,20))\n", + "# dist = np.zeros((20,20))\n", + "\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " index = 20 * j + i \n", + " cable_vec_ac[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec_ac[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", + " total_vec_ac[j,i] = parametric.results.cable_cost[index] + oss_vec_ac[j,i]\n", + "# dist[j,i] = parameters.site.distance_to_landfall[index]\n", + "\n", + "\n", + "\n", + "# plt.colormap" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "6bb532b3-c160-49ab-b71c-ddf0ab8a4f51", + "metadata": {}, + "outputs": [], + "source": [ + "cable_vec_dc = np.zeros((20,20))\n", + "oss_vec_dc = np.zeros((20,20))\n", + "total_vec_dc = np.zeros((20,20))\n", + "# dist = np.zeros((20,20))\n", + "\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " index = 20 * j + i + 400\n", + " cable_vec_dc[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec_dc[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", + " total_vec_dc[j,i] = parametric.results.cable_cost[index] + oss_vec_dc[j,i]\n", + "# dist[j,i] = parameters.site.distance_to_landfall[index]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "e322b0ac-16e5-4da0-bb20-e58edc0f3fb3", + "metadata": {}, + "outputs": [], + "source": [ + "contour_binary = np.ones((20,20))\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " if total_vec_dc[j,i] < total_vec_ac[j,i]:\n", + " contour_binary[j,i] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "d01fea0b-01ba-4417-b734-01b32fa6c34a", + "metadata": {}, + "outputs": [], + "source": [ + "cmap = LinearSegmentedColormap.from_list('custom_div_cmap',['#d73027', '#ffffbf','#1a9641'], 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "6b7bd029-1285-4283-94aa-86d6e5684da3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_binary, cmap=cmap, shading='auto')\n", + "# plt.colorbar()\n", + "plt.xlabel('Plant Capacity (MW)')\n", + "plt.ylabel('Distance to Shore (km)')\n", + "plt.title('HVDC is cheaper where green')\n", + "plt.suptitle('Cheaper Transmission Type (HVAC v HVDC)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "bec28390-032b-4265-a6bb-56d87b79dd36", + "metadata": {}, + "outputs": [], + "source": [ + "contour_cost = np.zeros((20,20))\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " if total_vec_dc[j,i] > total_vec_ac[j,i]:\n", + " contour_cost[j,i] = total_vec_ac[j,i]\n", + " else: \n", + " contour_cost[j,i] = total_vec_dc[j,i]\n" + ] + }, + { + "cell_type": "markdown", + "id": "86c53d30-1959-4b82-882e-07d52b33fa98", + "metadata": { + "tags": [] + }, + "source": [ + "# Color Map of Total Cost of Cheaper Option" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "82e6f4b7-fd6f-4f44-83a9-5cb0aabafa10", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApYAAAHsCAYAAABoo+0wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAACc60lEQVR4nOzdd3wURf8H8M9eek8g9JBQQw2QSC/SUYpID50oKNioFgLyCA8INhRRLPjQRJSO0kQI0gWkSw8lIaGTBJKQACk3vz/43XrH3SW57KSRz5vXvl5kd2d29vZu73szOzOKEEKAiIiIiEgjXUEXgIiIiIieDgwsiYiIiEgKBpZEREREJAUDSyIiIiKSgoElEREREUnBwJKIiIiIpGBgSURERERSMLAkIiIiIikYWBIRERGRFJoDy1u3buGzzz7Dc889h4CAALi6usLV1RUVK1ZEly5d8Omnn+LatWsW0yqKAkVRsHjxYq3FII0WL16sXo/cLiTH1KlToSgKKlWqVNBFMXlfFDVa38/F7b70zz//YPLkyWjatCnKly8PJycneHp6onr16ggNDcWSJUtw//79gi5mvggPD4eiKHjrrbfMthl/Jnbu3JltXjt37rT4nhoxYoS6/tKlSzkuW2ZmJsqVKwdFUdCgQQOL+8TFxcHR0VHN/48//shx/gYPHz7E4sWL0b9/f1SvXh3e3t5wdHRE6dKl0apVK7z33ns4fvy4zfnmlzZt2th0Hw0LCzO716WmpsLT0xOKouDZZ5+16fibNm1S85szZ4663nB/f3JxdXVFuXLlULduXQwaNAhz5syxGjtlJTMzE6tWrUJYWBhq1qyJEiVKwMHBAb6+vmjcuDFGjx6NvXv3Wkw7duxYKIqC8ePH23xcEyKXMjMzxQcffCBcXV0FgCwXe3t7MWrUKJGammqSh2H7okWLclsMkmTRokXZXsfsFpLjgw8+EABEQEBAQRfF5H1R1Gh9PxeX+1J8fLwIDQ0ViqJk+5r4+PiIuXPnFnSRVQEBAQKA+OCDD6TleeXKFeHs7CycnZ3FtWvXzLYbfyZ27NiRbX47duyw+J7avXu3un7q1Kk5Lt/mzZvVdJ9//rnFfb788kuT6zZw4MAc5y+EECtXrhR+fn45+px07NhRXL582ab880Pr1q1tuo8OGzbM4r3u5ZdfFgCEoigiKioqx8fv16+fGv/cunVLXW+4v+dksbe3F3379hU3btzI0TH//PNPUaNGjRzl3bBhQ3H06FGT9Ddu3BAuLi7C0dFR0zXNVY3lo0eP8OKLL2LatGlITU2Fn58fZs2ahb///hvXr1/H7du3cfz4cXz55Zdo3LgxMjIy8N133+HWrVu5ORzlg8GDByM5OdniEh4eru53+vRpq/sRFSbW3qenT59W9wkPD7e63+DBgwuw9PkjOjoaTZs2xYoVKyCEQOPGjfH999/j1KlTuHPnDmJjY7Fv3z5MmTIF/v7+uHv3LmbPnl3Qxc5T4eHhePjwIUaOHIny5cvn2XFatmyJKlWqAAB++umnHKf78ccfAQD29vYYNGiQxX2WLFli8ve6deuQlJSUo/w//PBD9OvXD1evXoWrqyvGjh2LiIgIXLlyBfHx8Th79ix++ukn9OzZE4qiYNu2bdi1a1eOy1/UDBs2DAAghMjxdUpMTMT69esBAJ07d0bp0qUt7mf8fXr37l1ERUVh586d+PDDD1G9enVkZGRg1apVCAoKwsGDB7M85pIlS9CpUyecP38e9vb2GD58ODZu3IjLly8jPj4ekZGRWLt2LYYOHQoHBwccPnwYv/32m0keZcuWxahRo5CWlmbyvW+z3ESjr732mskvoSdrIp+0bt06Ubp0abNo35BHcakZKKqMf2HZ8ouNqDCKiopS388ya7qKmocPH4rg4GC1NmbOnDnZ7v/RRx+JatWq5VMJsye7xvLixYtqze2lS5cs7iOrxlIIIaZOnapu27dvX7Z5JSYmChcXFwFAdOvWzeI+J0+eVPN88cUX1f//73//yzb/FStWqPvXq1dPxMbGZrn/iRMnRMOGDQvld7isGku9Xi8qV64sAIjAwMAc5TV//nw1r9WrV5tsy+n3aWZmpvj000+FnZ2dACDKlClj9Xrs3btX2NvbCwCiYsWK4uTJk1mW7/Lly+K5556z+LmJiooSiqIIRVFEZGRktudqic01lnv27MG3334LAGjfvj1++uknuLi4ZJmmR48eOHLkCEqUKGHr4YiIKA98+umnOHbsGABg2rRpGDNmTJb7Ozk54b333sOvv/6aD6UrGPPnz4cQAs2bN1drE/PS0KFD1Wf6li5dmu3+q1atwoMHD9S0lhhqK+3t7fHdd98hICDAZL01ycnJGDlyJACgTJky2L59O/z8/LJMU69ePezZswetWrXKtuxFlaIo6msdGRmZbc0h8G+tso+PD1544YVcHVen0+Htt9/GRx99BOBxf5Zp06aZ7afX6/HSSy8hIyMDLi4u2LZtG+rWrZtl3pUrV8bmzZsRGhpqtq1SpUpo3rw5hBCYP39+7spua4JPPvkEwOMX+9tvv83xQ/1+fn7w9PTMcp8lS5agZcuW8PHxgaurK+rXr49PPvkEaWlp2eZ//PhxvPrqqwgMDIS7uzvc3NxQu3ZtjB8/PssHYB8+fIjNmzfjtddeQ7169eDp6QkHBweULl0aHTp0wA8//JDl8Q0P/LZp0wYAsG/fPvTu3Rvly5eHs7MzKlWqhNdffx1Xr17N9hwePnyIr7/+Gu3bt0fp0qXVB6U7d+6MlStXQghhMd2THSyuXr2KcePGoUaNGnBzc4OiKIiOjs72+Ln1ZGeTs2fP4tVXX0WVKlXg7Oxs9h45efIkZs6ciTZt2qBMmTJwcHCAp6cn6tWrhwkTJiA2NtbqsYwfhI+OjkZKSgr++9//om7dunBzc4OXlxfatGmD1atXZ1nmK1euYNy4cQgKCoK7uzscHR1Rvnx5NGjQAK+++irWrVtnlubJa3306FEMHDgQfn5+cHFxQfXq1TFp0iQkJiaqaR49eoS5c+eiYcOG8Pb2hoeHB1q3bo3ff/89x6/nk1JSUvDJJ5+gefPm6oPZpUqVQu3atdG3b1/88MMPSElJMUsXFxeHKVOm4JlnnoGXlxccHBxQpkwZ1K1bF0OGDMFPP/2EjIwMkzQ57bzz+++/o0+fPqhQoQKcnJxQokQJNG/eHJ999hlSU1OtpjM8YB8WFgbg8Q/XHj16oGzZsnByckLlypXx1ltv5dtjNO3atYOiKGjatGm2+06fPh2KosDZ2RkJCQnq+sJwT8hJvnPnzgXw+IvElmavOnXqWFwvhMAvv/yCrl27omzZsnB0dESpUqXQvn17zJ8/3+y99aTNmzejV69eqFixIpycnODh4YEqVaqgdevWmDZtGs6ePavua3iNr1y5AuBxYPxkZ4ipU6fm+JwAIC0tDYsWLQIADBkyxKa0uVW5cmU1KFu5cmW233WG4NPHxwfdu3c3256ZmYlly5YBADp16oSyZcuqj3Ts3bsXUVFRVvOeP38+7t27BwCYMWMGfH19c3QOzs7OqFq1ao72BYBBgwap97fs3r8LFy5Ur6fx9c9vtvwAiIqKwr59+wAA/fv3h6Ojo6ZjT5gwAYGBgQAeB6x37twx2b5u3TpcuHABADB+/HjUqFEjR/nqdDrUqlXL4jbDe2bJkiU5ir/M2FK9ef/+fbW6tW3btrmqIjUGoyr6Pn36WH3ItFOnTiIzM9NiHnq9Xrz77rtZPnju7u4uNm/ebDH92LFjs33ItWnTpuLu3bsW0xuqz1u3bi1++OEHtdr6ycXT0zPLpo5Tp06p1e3WlhdeeEGkpKSYpTVumjl48KAoUaKEWVotTdjZVd0bdzZZv3692lRjvBgcP34829fbw8NDbN261WJZjJuV9u/fL2rVqmU1n+nTp1vMY+fOncLNzS3LMri5uZmlM77WS5cuFQ4ODhbTPvPMMyIpKUnEx8eLFi1aWNxHURSxZMmSLF9vS004169fF9WrV8/2NTx06JBJutOnT4vSpUtnm+7OnTsm6bLrvPPo0SMxcODALPOsVKmSOHv2rMX0huaqYcOGic8//1zodDqLefj7+4urV69azMNWWTWFL1u2TN12+vRpq3no9XpRpUoVAUCEhoaabCsM94TsbNmyRc1j2rRpNqd/UmJiomjXrl2WZQ0ODhbXr1+3mP7NN9/M9r35xhtvqPsbN1taW2xtHt+6dauaNjo62up+MpvChRBiwYIF6vY1a9ZYzSc6Olr9nhs1apTFfYw79vzyyy9CCCHOnz+vrsuqk1DTpk3Ve19u3lM59fvvv6vl2bVrV5b7tmnTRgCPO5rYSlZTuEGrVq0EAFGyZEmRlpZmNZ9p06ap+Rw4cMBse24eLfvoo4/UNKtWrTLZ1r9//xy9b21hfI+09l2cFZsCy23btuX6Q2vx4P+fV5UqVYSdnZ147733xMmTJ0VCQoI4fvy46Nmzp7rP999/bzGP9957T/2iHjp0qNi1a5e4ffu2uH37tti8ebNo0qSJACBcXV3FqVOnzNJ/8MEHYvjw4WL58uXi0KFDIjY2Vty6dUscOXJE/Oc//xE+Pj4CgOjfv7/F4xvejBUqVBCOjo4iODhY/P777+L27dvi8uXL4rPPPlODmBIlSpj0DjOIjY0Vvr6+6ofg+++/F5GRkSIhIUGcPXtWTJs2TTg5OQkAYujQoWbpjW90fn5+ws/PTyxcuFDExMSIW7duid9//13cu3fPxqtj+hpl9UEwbPf09BQeHh6iVq1aYtWqVeL69evi+vXrJs+YnDhxQrRr107MmTNH7Nq1S0RGRor4+Hhx7tw5sWzZMtGwYUMBPO59aqknnPFNukqVKsLX11d8/fXX4vLlyyIuLk5ERESIunXrCgDCzs5OnDlzxiR9Zmam8Pf3FwBE6dKlxffffy/Onz8vEhISxPXr18WePXvEjBkzREhIiNmxDde6fPnywsnJSbRt21b8+eef4s6dO+LSpUsiPDxcLduUKVNEjx49hLu7u/j000/FxYsXRXx8vNi2bZsIDAxUX6/4+Hirr6elG+LgwYPVc5syZYo4fvy4+n4/duyY+Oabb0SbNm3E4cOHTdK1bNlS/Rx89tln4syZMyI+Pl7cunVLHDx4UMyePVs888wzNgeWo0aNUrd37txZ7NmzR8TFxYnz58+LqVOnCkdHRwE8fu7H0o8zw82/cuXKQlEU0aNHD7F3714RFxcnLl++LKZMmaJ+mQ4YMMBiGWyVVWD54MED9TM/YcIEq3kYvw+fvPEWhntCdiZPnmxTcJSdzp07q/kNGTJEHDp0SMTHx4t//vlHjBkzRr2GISEhZl/KERERatqOHTuKP/74Q8TExIi7d++KixcvinXr1okRI0aI9957T03z8OFDkZycrH6Ww8PDRXJyssny6NGjXL0mZcqUyXI/2YFlUlKSOrpKjx49rOYzffp0NZ/9+/db3Cc0NFS9txj3fTB8D1apUkXo9XqzdKmpqeoP5datW2d7TlpkZGSIsmXLCgDilVdesbpfTEyM+r758ssvbT6O7MDyf//7n7r9119/tZpPtWrVBABRo0YNi9tzE1ju2bNHTTN+/HiTbRUqVLDpPHOqTJkyAoCYPHmyzWltCiyNH0hdvny5zQczO7jRr8uffvrJbHtmZqZo0KCBACCaNGlitv3IkSPqG2/+/PkWj5GWlqZ+qVp72Dkr//zzj7CzsxOKolh8mNv4zVi3bl2RnJxsts+2bdvUcr7++utm2w0PWNepU0ckJCRYLIfxL9EngwbjG13JkiVFTEyMzeeZlZwGlsDjh5u1BLHp6elqLd9//vMfs+3GN2l3d3eLNWFXr15Va02Nv4yEeHw9Del/++03m8pmfK07d+4sMjIyzPYZNGiQAB4PE2Fvby/27t1rts/Zs2fV94OlH0xZBZaG2uhx48bluNyJiYlquW29QWcVWBrXPvfu3dviF9aaNWvUfSwFaoabf1ZfMm+99ZYAIBwdHUViYqJN5bcku847huOVKVNGpKenW8xj6NChAnhck/pka0phuCdkx7iW+ebNmzalfdKvv/6q5mXtfTl79mx1n6+++spk2/jx49XXO6uaIEtkdt4x1Ehl9z1h/JnYvHmzWUD75GJ8nax1cjHcNxwdHS3+2BRCqD9IrXUguXfvnnB2dhYAxMsvv2yy7ZtvvlHLsHv3brO0kZGR6nZrtaEyjRs3TgAQ3t7e4uHDhxb3mTVrlnovvX37ts3HMNxb/P39s71GycnJ6jWwFlgad5zq3bu3xX327dun5jFz5kyL++QmsLx586aaxvgHdlpamrr++eefz1FeOdW9e3cBQLRs2dLmtDY9Y2n8HJG3t7ctSbPUrFkzi8Mm6HQ69aHZY8eOmT2jM3fuXAgh0KJFC7zyyisW83ZwcMCMGTMAPH6Gx/AMSU4FBQUhJCQEQghERERkue/HH38Md3d3s/UdOnRAz549ATx+PsP4PKKiotRhCebMmQMfHx+LeXfu3Fl9ZsvwDI0l77zzDipWrJhlOfPSf//7X3h5eeU6vb29PQYOHAgA2LZtW5b7vvXWW6hZs6bZ+goVKqBjx44AgEOHDplsM37ttQwlMmfOHNjZ2Zmt79+/v3qc0NBQtGjRwmyfmjVrIjg4GABy9CC4MUP5bSl7Zmam+n+Zw6f873//A/D4mn311VcWn8Ps1asXnn/+eQCPn5fS6/UW83J1dVWf337SSy+9BODxM3AnTpyQUfQsGe4lt27dwqZNm8y2Jycnq8/wvvTSS9DprN9GC8M9wRKZ93LD+8DX1xczZ860uM+4ceNQu3ZtAMAPP/xgss1w7r6+vnBwcNBUFi3OnDkDADY9L9ilSxd4eHhkuXTp0iXbfAxD2qSlpWH58uVm2w8cOIDIyEgA1jvtrFixAg8fPrS4j/GzfpY68eTVd7s1hmdY7927h40bN1rcxzC0z/PPP49SpUrl+lgxMTHZXiMPD49sP0Oenp7qZ3bjxo24e/eu2T6GTjs6nU7qcGXG18T4uHl53Qyfg1OnTtmctlBM6di5c2er2wwPoqalpZldSEOg17FjR9y/f9/qYrih6fV6HDlyxOwYCQkJ+Pjjj9XOJMYzFiiKogYn58+ft1pONzc3PPfcc1a39+7dG8DjL6V//vlHXb99+3YIIeDs7IzGjRtneR6GWRaeDJaMde3a1eq2vKYoSpbX0ti6devQr18/VK1aVe1gZFjeeOMNAFm/3kDO3jc3b940W+/s7AzgcWCam0ClSpUq6sPUTzL+Usrq/VCtWjUAwI0bN2w6tuE98Omnn2LTpk0mQaM1Pj4+8Pf3BwBMnjwZe/bssemY1hjyadWqFcqVK2d1P0PPw7t371q9STVt2tTqjdH4YfQnr2deCAoKQuPGjQE8DoaftGLFCqSmpkJRFDXotaSw3BPykhBC7ajwwgsvqJ+tJymKgr59+wJ43HnP+Ae+4RxOnz6NyZMnm3xZ5pfMzEz1uAUxekn79u1RoUIFAJY7hxjWKYpitWORIWAMCAgwmyXGx8cH3bp1A2Das7ygBAcHq53ALJ3vsWPH1PFm86sjVU4YfgA8evQIK1euNNmWlpamrmvbtq3UCh5h1Mkpv2ZBK1myJIDHwX96erpNaW0KLI0/cLbW/GUlq1oUV1dX9f/GvUvv37+v9vaeOnVqlr9EjAcnfbJH1YEDB1CzZk1MnDgRu3btwu3bt62+iMa9fZ9UvXp1izVYBobgFoBJD+1z584BeNxL08vLK8vzMEwL9eQ5GMuPITKs8fX1zbbnf2pqKp5//nn06tULq1atwuXLl632Gs7q9QZy9r55Mm9XV1e1BvvAgQNo0KABqlSpgpdeegkLFy7Mskd6To5rPPRWTvaz9Qb/0UcfwdHREbdv30a3bt1QpkwZ9OrVC59//nmWQfLs2bOhKAoiIyPx7LPPonz58hgwYAC++eYbtUehrQw9co3f25YY9yK2NjpBbu4BeWnEiBEAHrdyPNkj3dBzuF27dupQLpYUlnuCJbLu5UlJSeoP/py+D4QQiImJUdcPHjwYISEhAICZM2eiTJkyaN68Od577z1s3rxZrYXLS/Hx8eqXty2B5Y4dOyAeP1JmddmxY0e2+eh0OjWAOnDgAC5evKhuS0tLw4oVKwA8DlgMPxKNXbhwAX/99ReAx6+npeDDUIuZlJRkNmRUXn23Z8Vwvr///rvZjwlDbaWXl5fF3u+2CAgIyPYaCSHUoDErHTp0sPoDYMOGDepnISd52cL4u9D4WuXldTMElsDjEUVsYVNgWblyZfX/hpufDFndfI0ZR+3ZBR3WGN+kkpKS0KNHD9y5cwelSpXCrFmzsH//fly7dg337t1TR8Q3NGdmNVyGpeYua9uNZ6nJzXlkdaM1/hLObzk59oQJE9R5a4cNG4aNGzfi4sWLiIuLU1/vb775BgCyrY3LyfvG+D1jXIbVq1ejSZMmAB43PS5evBjDhw9HQEAAOnfunOXQFjl9v+a2fFlp1qwZDhw4gB49esDBwQHx8fFYt24dJkyYgAYNGqBu3boWm2/79OmD7du3o3379tDpdLhx4waWL1+ON954A4GBgWjevDn2799vU1kM72MPD48s9zPebm2GptzcA/JS//794ebmhoyMDJMvkPPnz6tf4MOHD88yj8JyT7BE1r3cuNy5fR84ODhg586dmDRpEsqWLYuMjAzs378fn3zyCbp27YoyZcpg0qRJePToUa7LmR3jQCy/3mNPMg5GDE2qwOM5p+Pj4832MWa8f61atXD48GGzpXTp0uo9+snm8AoVKqiPIcj8bs/KoEGDoNPpTGr6gMf3/V9++QUA0LdvX6u14AXBuIl73759uHz5srrNcA3c3d3Rq1cvqcc1br0z/hHu4OCgBrqyr5vxY0u21pLaFFg2bdoU9vb2AFDgUzgZ35QNz1rmZDGMlwcAq1evxq1bt6DT6bBjxw5MnDgRTZs2Rfny5eHl5QV3d3e4u7vnaLrC+/fv53i78Q3WcB4lSpTI8Tnk5ZiUeSk1NRWLFy8GALz33ntYvHgxunbtiqpVq6JkyZLq650fNRS9e/fGgQMHcOvWLfz66694++23UatWLQghsGXLFjRr1szkplGYBAcHY926dbh79y62b9+OGTNm4Nlnn4WiKDh9+jS6deuGNWvWmKVr27YtIiIiEB8fj82bN+P999/HM888AwDYv38/2rRpgwMHDuS4HIb3cW7f+4WZh4eH2oRvqKE0/r+Pj4/6vJU1hfmeYDygtZZ7uXG5tbwPPDw88OGHH+L69es4efIk5s+fj4EDB8LLywtJSUmYNWuW2pSeF0qWLKk+K1sQTfHA42evDY9g/PTTT2qAaxywGB6fMCaEMPnxM3jwYDRq1Mhsad68uVrjHxERgevXr6tpXF1d1XvBoUOH8qVlwM/PT31G2Lj827dvVx8RKkzN4AbGwb2h3HFxcerYxH369IGbm5vUYxp+zAJA8+bNTbYZPsvR0dEmLQFaGT4HiqLkeExTA5sCS3d3d3Tq1AnA44Gqjavr85uXl5daVXvp0qVc5XH8+HEAj2cPsDbob1pamvrQdFYuXLiQZQ2b4cFwACYDXxuaru/evVtgN7T8cu7cOTVoHDBggNX9Tp48mV9FQunSpfHiiy/i008/xZkzZ/DTTz9BURQkJibiyy+/zLdy5IabmxvatWuHyZMnY9euXTh+/Lj6mfjvf/9rNZ23tzc6d+6M6dOn4/Dhw9i+fTucnZ2RlpaGWbNm5fj4hvex8dzblhg/V2lt0PfCyNCJ58yZMzhw4AAyMzPVL5KBAwdmW5NSmO8Jzz77rPplsWjRohw9q2uJp6en2rkop+8DRVEsNucattWtWxevvPIKli1bhmvXrqkB/IYNG9SZgmTT6XRqs6KlThn5xRC0GAbZNvwIBB53hLMUsOzcuVN9LCWnMjMzzea9NtSypaSkqDWGec0QOP7111/qD3lDuSpVqlQoZ/SpVasWGjVqBODfsv7yyy/qI3TWOlfllhBCfdbbycnJ7PlZ49rRJzvGaWG493h7e6sVijllc+ed9957D8Djk33ttddy3Gxw7do1JCUl2Xq4LBmC3LVr1+ZqdHhD00pWN9VVq1blqAYtJSVFbeK1xFCD5OHhgaCgIHW94RyEEGYPAz9tjJuyrL3m9+/fL9Ap4wYNGqTORpBfTUKy1KtXT61ls6Xs7dq1Q7t27WxOZ7jp7927N8uZcVatWgXgcS1fdlONFSZNmzZVy7to0SJs2bJFreV5+eWXs01fmO8JLi4ueOuttwA8rumw1pvbEuMAUlEUtGzZEsDjnrLWmquFEGpP+qCgoBz3YHVzczOZFejJ96eh+Ta3gbExw7UuyAoT497bP/74I1asWKF+t1lrBjc0a9vZ2eHWrVvZ1m4bztO4+RwARo4cqY7oMXny5Bw/V/fo0aNcV+707t1bfd78p59+QmpqqjrrmbVnRQsDw7W4ePEi/vrrL/UHZ0BAgFoLK8tnn32mPgf/0ksvmT0D3KtXL7Uz6Oeff56jijDgcVN3Vvd7w+cgN/dsmwPLZ599Fq+++iqAx9XpQ4YMyTbw2rhxI0JCQqT/+h4/fjwAIDY2FmPGjLE6lInBky+ioWbg7NmzFi/GtWvX1EA6JyZOnGhxKr2IiAj1wzJkyBCTITVq1Kih9tabPHlytr/6k5KSbO5JXFgYP9f122+/mW0XQmD06NF5WmNw7dq1LJvsUlNT1dfX+OHlwiAlJSXbzkWGG/yTD14bntGyJDMzU21KteWcDc8YpqenY/To0RZ/ZP72229qjcvw4cOzHJqnMDKc4/LlyzFv3jwAQP369dXOJtkpzPeEd999F/Xr1wfwuAOkYYpHa9LS0vDZZ5+ZPQJg6Oh0584dvP/++xbTzp07Vz0Pw/eHQXajPxgHLU++Pw21rsbNurllqAkqqB72wOPHHwxzS69atQoLFiwAAPj7+6Nt27Zm+6ekpKg/UDp06GDSUdUaw3Bup0+fNhklxdPTE99++y2Ax0NtdejQIdtpR0+fPo1WrVrleqQJDw8P9OjRA8DjIbPWrVun3p8LYzO4wYABA9QfAFOmTFHfM0OGDJEWDOv1esyePVv9YVW+fHn85z//MdvPzs4OCxcuhL29PVJTU9GxY8ds7xkxMTHo2rWrxaGtDAxD4T1ZQ5ojNo98KR7PTmE800LFihXFrFmzxKFDh8SNGzfE7du3xYkTJ8TXX38tmjdvbnUwUMN6a4PGCmE6ILalwUQnTZqkbm/WrJlYvny5iIqKEnfv3hVXr14Vu3fvFh999JEICQkRderUMUl74cIFdbq1atWqibVr14rr16+L2NhYsWjRIuHn5ydcXV3VQXiHDRtmdvwnZ9kICQkRv//+u7hz546Ijo4Ws2fPFu7u7gKwPstGTEyMOsq9m5ubCA8PFwcPHhR37twRcXFx4uzZs2L58uVi2LBhwsPDw2xKp+xmR9HKlikds2MYtNbBwUFMnTpVnDt3TsTFxYldu3aJrl27CgCidu3aVs8nu/dDdmVatGiR8PLyEsOHDxdr1qwRFy5cEAkJCeLKlStiw4YNolmzZmr+69evN0lrPFWfNcaDb2c1K0dWeVkre1RUlLC3txfdu3cXCxcuFP/884+4c+eOuHHjhti3b58YMmSIemzj2Rl27NghXFxcxIABA8TPP/8szp49K+Lj48XVq1fF9u3b1dcdgJg7d67Z65XVe8t45p2uXbuKvXv3ivj4eBEZGSn++9//qrPDZDfzjqXPlrGc3CtyKrsB0o3FxcWp52DtNXpSYbgn5NSlS5dE1apV1XNr0qSJmD9/vjhz5oyIi4sTV69eFX/99ZeYNm2aqFSpktXPufH3QVhYmDh8+LCIj48XJ0+eFGPHjlWn6rQ0807r1q1FnTp1xPTp08XOnTvFtWvX1BmG5syZI7y8vATweMarBw8emKQ1TAVZokQJsWPHDnH//n2Rnp4u0tPTrU4DbM327dtzdG+RPfPOk9avX2/yfgOsz36yZMkSdZ8ff/wx27yFMJ0a8q233jLbPnXqVDVPV1dXMXbsWLF9+3YRExOjzpL2yy+/iL59+6rXVcvn0ngAecN7rHHjxrnOz0D2zDtP6tWrl9l1ioyMzDad8ffp6dOn1QHa7927J6Kjo8WuXbvEzJkzTabuLVWqlNk0vU9asGCBOuW2g4ODGD58uNi0aZOIjo4WCQkJ4sKFC+LXX38VL730knpPs3b/y9cpHY1lZGSIyZMnW5wX+snF0dFRjBkzxuymICOw1Ov1YsaMGVbn4zVegoODzdJ/8sknVvd3dnYWq1evzvLLzzhAmD9/vtW5jrObFzgyMlIEBQVlew6A+YwxRSmwPHv2rChZsqTVcwsNDTWZO/dJMgLLnLzGEydONMuzMASWOSl7hw4dxP3799V0xq9ZVsvgwYPNZhPKz7nCs5KTe0VO2RJYCmE6F6+Tk5PVmVEMCsM9wRZxcXGiT58+arCR1eLr6yu+++47szy0zBVuPPuStaVkyZLir7/+Mkt75swZdbaZJxdbZ+NJS0tTg/l58+ZZ3S+vA8v09HRRunRpk3M5f/68xX0Nr7mLi4vFGZ6sMcxu5uvra3G2o19++UWUL18+R++9bt26iStXruT42E/KyMhQX3fD8vXXX+c6P4O8Dix/++03kzI3b948R+mMv0+zW+zt7UVoaGiOZ8eKiIgwCUizWlq0aCH++ecfi/nMmzdPAI8DWlunRhXCxpl3jNnZ2WHGjBm4fPkyPvnkE3To0AF+fn5wcXGBs7Mz/Pz80LlzZ8yePRtXrlzBnDlz8mTYAEVRMHnyZFy4cAHvvPMOQkJC4O3tDTs7O3h6eqJu3boYOnQoli1bZrG6/p133sGGDRvQrl07eHp6wsnJCZUqVcLLL7+MQ4cOWeyFZ80rr7yCnTt3okePHihbtiwcHR0REBCAUaNG4fTp02a9uYxVr14dx44dw7Jly9CzZ0/4+fnByckJjo6OKF++PNq1a4cPPvgAJ06c0DyuV0GqWbMmjhw5ghEjRqhDXJQqVQrt2rXD0qVLsXz58jxtLu3Xrx82btyIcePGoWnTpqhYsSKcnJzg4uKCwMBAhIWFYf/+/TZ1Yskv/v7+2LdvH6ZNm4b27durg8s7OjrCz88P3bt3x4oVK7B161aTh/ybN2+OiIgIhIeHo1WrVqhUqRJcXFzU93poaCi2bNmCpUuX5njYHwNHR0csW7YMmzdvRq9evVC+fHk4ODjA29sbzZo1wyeffILTp09bnCGpqDA09QJAjx49bBrnsCjcE0qWLIlVq1bh2LFjmDhxIho3bowyZcrAwcEB7u7uqFatGkJDQ7F06VJcuXIFI0eONMvD09MTERERWLZsGTp37ozSpUvDwcEBJUuWRNu2bfHdd9/h77//tjiQ/pIlS/DDDz+gf//+CAoKgq+vL+zs7ODt7Y0mTZpg2rRpOH/+PJo1a2aWtlatWti3bx/69esHPz8/TTP3ODg4qM/OPtmxJT8Zzz4GPH7W19KEDDExMeoYmS+88EK2w1sZM8x0FxcXZ3F4sv79++PSpUtYsGAB+vbtiypVqsDDw0O9X7ds2RITJ07EyZMnsWHDBqudsXLCzs7OpDOng4OD+qx4Yda5c2eTGYG0dtpxdnZG6dKlUbt2bQwYMABz5szBlStXsHz5cpQpUyZHebRv3x5nz57FihUrMGTIEAQGBqqdb0qUKIHGjRtjzJgx2L9/P/bu3WvybLcxwyxEw4YNU5v8baEIUUCDdj0lwsLCsGTJErRu3Ro7d+4s6OIQkWQHDx5E06ZNAQB//PGH2rnGGt4Tiq6oqChUq1YNer0eFy9etGl6R6KnQVRUFKpUqQJFUXDu3Dmrs8xlpWg9SU9ElM8MY1f6+/ujQ4cOBVwaykuVK1dWa/Oy68xE9DQyvO/79euXq6ASYGBJRGRVXFyc2iz66quvFrle7WS7Dz/8EM7Ozpg/f76U3uZERcXNmzfx/fffw9HR0aYhyJ7EuyQRkQXR0dEYOnQoUlJS4OHhgddee62gi0T5oGLFihg7diwePnxYKJ+1JsorH330ER48eIA33nhDHY4xN2wbTp2I6ClneEbS2EcffWRTpx0q2mbNmsWgkoqdOXPmYM6cOZrzYWBJRGSBYaSACRMmFOrBmomIChP2CiciIiIiKfiMJRERERFJwcCSiIioCDh//jy++uorhIWFISgoCPb29lAUBTNmzMiT4/31118IDQ1FxYoV4ejoCDc3NwQFBeG9997D7du38+SYVPTxGUsiIqIi4Ntvv8WXX36ZL8f65ptv8Oabb0IIgbp166JZs2a4f/8+Dhw4gE8++QSLFy/Grl27ivSsWpQ3WGNJRERUBNStWxdvv/02li1bhrNnz+ZZp7Jbt25h3LhxEEJg8eLFOHnyJFauXInNmzfjypUr6NSpE27fvo2xY8fmyfGpaGONJRERURFgPG89gDwbsH/v3r1IS0tD7dq1MWzYMJNtHh4e+OCDD7B161bs378/T45PRRtrLImIiJ5iGRkZ+N///oc2bdqgRIkScHJyQuXKlfHaa68hNjbWbH9nZ+cc5evr6yu7qPQUYGBJRET0lEpOTkbHjh3xyiuv4MiRI6hXrx66d+8OJycnfPfddwgODsaxY8dM0jRr1gxeXl44c+aM2WQB9+/fx7Rp0wAAI0eOzLfzoKKDgSUREdFTatSoUdi5cye6deuGS5cuYefOnVi1ahXOnTuHL774AvHx8QgNDUVmZqaapkSJEliyZAnc3NzUHuj9+vVD165d4e/vj0OHDuHDDz/EO++8U4BnRoUVA0siIqKn0NmzZ/HLL7+gfPny+Pnnn1G6dGmT7WPHjkWXLl1w4cIF/P777ybbXnzxRezatQtVq1bFqVOnsGrVKmzevBl3795Fo0aN0KJFCyiKkp+nQ0UEA0siIqKn0ObNmyGEQOfOneHh4WFxnzZt2gB4PGalsW+//RbNmjVDyZIlsXPnTiQmJiI2Nhbz5s3DgQMH0K5dOyxevDiPz4CKIvYKJyIiegpdvnwZALBgwQIsWLAgy33v3Lmj/n/fvn14/fXXUa5cOWzduhVeXl4AAE9PT7z++usoUaIEBgwYgLFjx6JHjx7w9vbOs3OgooeBJRER0VNIr9cDABo0aID69etnuW+TJk3U/xtqIrt06aIGlcb69OmDYcOGITExEYcOHULHjh3lFZqKPAaWRERET6GKFSsCAFq0aIGvv/46x+liYmIAPK6htMTe3h5ubm5IS0tDQkKC9oLSU4XPWBIRET2FOnfuDABYv349Hj58mON0FSpUAAAcPHjQ4vbz58/j7t27AIDKlStrLCU9bRhYEhERPYWCg4PRu3dvxMbGolevXoiOjjbbJyUlBcuWLcOtW7fUdX369AHwuEPPp59+CiGEuu327dsYPnw4ACAwMBANGzbM25OgIkcRxu8YIiIiKpSOHj2K119/Xf370qVLiIuLg5+fn1rLCADr1q1DuXLlADweIL1nz57Yvn07HB0dUb9+fVSuXBlCCERHR+PEiRNIS0vD2bNnUbNmTTWPUaNG4fvvvwcAVKtWDfXq1UNycjIOHjyIpKQkeHt7448//kDjxo3z6eypqGBgSUREVATs3LkTbdu2zXa/qKgoVKpUSf1br9djxYoV+Omnn3DkyBEkJCTA09MT5cqVQ6NGjdC9e3d07doVDg4OJvn89ttvWLBgAQ4fPoy4uDjY29ujcuXKeO655zB+/Hj4+fnJPkV6CjCwJCIiIiIp+IwlEREREUnB4YbyiV6vx/Xr1+Hh4cFpsIiIKEtCCCQnJ6N8+fLQ6fKuDujhw4dIS0vTnI+joyOcnZ0llIiKOgaW+eT69evqmGJEREQ5ERsbm2fPMj58+BCVA9xx83am5rzKli2LqKgoBpfEwDK/GOZprd97Cuwc5HzwhJ2UbFR6e7k1qfLLJy8vIbkCQC/5XGW/do6t5A5ibKfopeanU+Q96m2nk1s2RWLZAMBe8msn+3xlXgsAuJ/mJC2vzXXWScsLAOwUuTcCHeTdQ5Pu6xEQEm11jm8Z0tLScPN2Jq4cqQRPj9y/FknJegQ8E420tDQGllR0Astly5bhjz/+wIkTJ3Djxg3cvXsXrq6uqFGjBnr27Im33noL7u7uFtNGRETg888/x99//42UlBQEBASgd+/eCA8Pt5oGAC5evIgZM2YgIiICd+7cQalSpdChQwf85z//QZUqVWwqv6H5287BGXaOhTOwVAp5YKnIDCxll62QB5Z2rvK+3AH5gaWdjoFlbhX2wNLeQd57T0vwY4n8wFJ+k3V+PDrl7qHA3SP3x9FLDKip6CsynXe+/fZb/PTTT8jIyEBISAj69u2Lhg0b4tSpU5g0aRKCg4Nx/fp1s3RffPEFOnbsiC1btqBOnTp44YUXkJiYiJkzZ6Jhw4aIi4uzeLx9+/ahfv36WLJkCby9vdGzZ094e3tjyZIlqFevHg4cOJDXp0xERJTnMoVe80JkUGRqLGfPno3q1aujRIkSJuvj4+PRo0cP7N27FxMmTMAvv/yibjt27BgmTJgAOzs7bNiwQZ3eKjU1Fd27d8f27dsxatQorF692iTP1NRU9OvXD6mpqQgPD8fMmTPVbZMmTcKsWbPQr18/nD9/Hi4uLnl41kRERHlLDwE9cl9TrSUtPX2KTI1lkyZNzIJKAChZsqQa+G3dutVk26xZsyCEwEsvvaQGlQDg6uqKBQsWQKfTYc2aNTh37pxJusWLF+P69esIDAzEjBkzTLbNmDEDgYGBiI2NxY8//ijr9IiIiIiKvCITWGbF3v5xxauT07/P8qSlpWHTpk0AgIEDB5qlCQgIQIsWLQA8nv7KmOHv/v37mw3zoNPpEBoaCgBYu3atpDMgIiIqGHoJ/4gMinxgmZycjKlTpwIAunfvrq6PjIxEamoqAKBhw4YW0xrWHzt2zGS94W9b0xERERU1mUJoXogMiswzlgZbt27Fzz//DL1ej1u3bmH//v1ITk7G888/j48//ljdLyoqCgDg7e1tdbgGw7iShn2Bx4FqfHw8AMDf3z/LdHfu3EFKSgrc3NzM9nn06BEePXqk/p2UlGTLaRIREREVOUUusDxz5gyWLFlism7gwIH4/PPP4eXlpa5LTk4GAItBn4FhqCHjoM+QLqu0xkMUJSUlWdxv1qxZmDZtWlanQkREVODYeYdkKnJN4WPHjoUQAmlpabh48SJmz56N33//HbVr18bu3bsLuniq8PBwJCYmqktsbGxBF4mIiMiMHgKZGhYGlmSsyAWWBg4ODqhatSrGjx+P33//HXfv3sXgwYPx4MEDAP/OdJOSkmI1j/v37wMAPD091XXGzebW0hrSPZnWmJOTEzw9PU0WIiIioqdZkQ0sjTVp0gS1a9dGbGwsDh8+DACoVKkSAODevXsmzdvGDLWIhn2Bx4GlYVijmJiYLNP5+vpm2dRORERU2BmawrUsRAZPRWAJ/Ps85O3btwEANWrUgKurKwCoweaTDOtDQkJM1hv+tjUdERFRUcNe4STTUxFYxsXF4cSJEwCAwMBAAICjoyO6du0KAPj555/N0ly5cgV//fUXAKBnz54m2wx/L1++HHq96fhcer0eK1asAAD06tVL4lkQEREVHzExMXjzzTdRo0YNuLi4wNnZGZUrV8awYcPU73QqeopEYHnmzBksW7YMDx8+NNsWGRmJvn374tGjR2jatCmCgoLUbRMnToSiKFi0aBG2bNmirk9NTcXw4cORmZmJ3r17o2bNmiZ5hoWFoXz58oiMjMSUKVNMtk2ZMgWRkZHw8/PD0KFDJZ8pERFR/tJLWGx18OBB1K1bF/PmzUNKSgo6deqELl26QFEU/Pjjj2jYsCFWrVql+dwo/ylCFP467J07d6Jt27Zwc3NDcHAw/Pz8kJaWhpiYGBw9ehR6vR61atXCli1bzMae/OKLLzB+/HgoioLWrVujdOnS2LNnD27cuIEaNWpg79698PX1NTvmvn370KlTJ6SmpqJu3bqoW7cuTp06hVOnTsHNzQ0RERFo2rRpjs8hKSkJXl5eCOn/IewcnTW/JgAg7KRko9LbK1Lzk18+eXlJL5vk/GSXz7FNvNT87BS5M23Y6eTdhux0csumKHJvkfbSXzu5+ekkn+/9NKfsd8qhnUErpeUFAHaK3LoVncS6mqTkTPgEXkZiYmKedf40fC+dPlsaHh65L3tysh51at22qaz169fHP//8g1dffRVff/01HBwcADxuFfzggw8wY8YMeHt748aNG3B2lvOdSfmjSASWd+7cwQ8//IA9e/bg3LlzuHPnDtLT01GiRAkEBQWhV69eeOmll0ymdDQWERGB2bNn4++//0ZKSgr8/f3Rp08fhIeHWx08HQAuXryI6dOnIyIiAnfu3EGpUqXQoUMH/Oc//0HVqlVtOgcGltoxsMw9Bpa5x8BSGwaWuZOfgeU/Z7QHlvVq5zywjI+PVyt0bt++jVKlSplsz8zMhIeHBx48eICjR48iODg412Wj/FckBkgvVaoUJk2alOv0HTp0QIcOHWxOV61aNbPB2ImIiCj3rFUCWWKpRZEKtyIRWD5NlEwBXYacGgEh5NYwQvKQEXrJ5ZNZt6CXXE8v+2Fl2eVLfegoNT+d5FoymTWWssumSP6Yya5htJNcwyi7xjI1zUFaXjGZ5s/Za2En+Z7nIPG9kpwp932Sldw+J2mc3hbu7u5o1aoV9uzZg/fff9+sKXzq1Kl48OABOnfurE6hTEUHA0siIqJiTA8Fmch9VKzPRdoffvgBXbp0wfz587Fp0yY0bNgQdnZ2OHbsGK5du4YhQ4bg66+/znWZqOAwsCQiIiLNkpKSTP52cnKy2uxdo0YN7N+/H0OGDMHWrVtx7do1dVvt2rXRpk0bzlhXRBWJ4YaIiIgob+iF9gUAKlasCC8vL3WZNWuW1WPu27cPQUFBOHXqFH7++WfcvHkTCQkJ2LBhA9LT0zF8+HAMHz48n14Bkok1lkRERMVYpsamcEPa2NhYk1pGa7WV9+7dQ8+ePREXF4f9+/ejSZMm6rZu3bqhdu3aCAoKwsKFCzF48GC0bds212Wj/McaSyIiItLM09PTZLEWWG7atAl37txBlSpVTIJKA+P1EREReVpmko81lkRERMWYrBrLnIqJiQGALJ+h9PLyAgAkJCTkulxUMBhYEhERFWN6oWgaHs7WtBUqVAAAnDt3DomJiWoQaZCeno6jR48CACpXrpzrclHBYFM4ERER5ZvOnTvDzc0NDx48wCuvvIL79++r29LS0jBu3DjExMTAwcEBffr0KcCSUm6wxpKIiKgYy++m8FKlSuG7777DSy+9hFWrVmHnzp1o1KgRHBwccPjwYVy7dg06nQ5z585FlSpVcl0uKhgMLImIiIqxTOiQqaEBMzMXaQYPHoygoCDMmTMHu3fvxvbt2yGEQLly5TBo0CCMHj0ajRs3znWZqOAwsCQiIirGhMZnLHM7vXD9+vWxaNGiXB+XCic+Y0lEREREUrDGkoiIqBjL72cs6enGwJKIiKgYyxQ6ZAoNz1gKiYWhIo9N4UREREQkBWssiYiIijE9FOg11DPpwSpL+hcDSyIiomKMz1iSTAws85kuXd7zB0LI/pUo+eYguXx6ieXTSX7p9HKzg85Obn5pj+R+1BXJL6BOYn6yy6Yoks9Vdn6Sz9dOJ/fd/PCRg7S8otO9st/JBnaK3HN1yNWIjpalpMu+qxDlDwaWRERExZj2zjtsCqd/MbAkIiIqxh4/Y5n7FiGZrUlU9LFXOBERERFJwRpLIiKiYkyvca5w9gonYwwsiYiIijE+Y0kyMbAkIiIqxvTQcRxLkobPWBIRERGRFKyxJCIiKsYyhYJMoWGAdA1p6enDwJKIiKgYy9TYeSeTTeFkhE3hRERERCQFayyJiIiKMb3QQa+hV7ievcLJCANLIiKiYoxN4SQTm8KJiIiISArWWBIRERVjemjr2a2XVxR6CjCwJCIiKsa0D5DOxk/6F98NRERERCQFayyJiIiKMe1zhbOOiv7FwJKIiKgY00OBHlqeseTMO/QvBpb5TJchoFPkDM0g+8Oskz1khPRpvuSVT/6wa3LPVXb59Gl2cjOUfGkzJX0mAEDRyX3xFIllAwBFcuWOopPbdUIn+fVLfyjva+ZKuq+0vAD59zwHJUNaXg8yMgBEScsvK6yxJJn4biAiIiIiKVhjSUREVIxpHyCddVT0L6mB5f3793Hr1i3cvXsXPj4+KFOmDNzd3WUegoiIiCTSCwV6LeNYSn/siYoyzYHlH3/8gV9//RXbt2/HpUuXzLZXq1YN7dq1Q48ePfDcc89pPRwRERERFVK5CiwzMzPx7bffYu7cubh06RKEUU8Dd3d3eHp6IjExESkpKbhw4QIuXLiA+fPno1q1ahg9ejRGjRoFOzvJnQmIiIjIZnqNTeEcIJ2M2fxu2LJlC+rWrYvRo0fjypUr6N69O77++mscPXoUjx49QlJSEq5evYrk5GQ8fPgQhw8fxty5c9GtWzdER0dj9OjRCAoKwh9//JEX50NEREQ20Aud5oXIwOYayy5duqBMmTL47LPPMHToUPj6Wh/+wdHRESEhIQgJCcGbb76JuLg4LFmyBJ988gm6dOmCzMxMTYUnIiIiosLD5p8Z06dPx6VLlzB+/Pgsg0pLfH19MWHCBERFReG///1vjtKkp6dj+/bteOedd9CoUSN4e3vDwcEBZcuWRffu3bFp0yaL6aZOnQpFUbJczp07Z/W4Fy9eRFhYGPz8/ODk5AQ/Pz+EhYXh8uXLNp0zERFRYZYJRfNCZGBzjeXkyZM1H9TV1TXH+ezatQsdO3YEAJQtWxYtW7aEm5sbzpw5gw0bNmDDhg149dVX8d1330FRzN/c9evXR4MGDSzm7eXlZXH9vn370KlTJ6SmpqJOnTpo2bIlTp06hSVLlmD16tWIiIhA06ZNc3ayREREhZjW5mw2hZOxQj+OpU6nQ+/evTFmzBi0atXKZNuKFSswaNAgzJ8/Hy1atMDQoUPN0vfo0QNTp07N8fFSU1PRr18/pKamIjw8HDNnzlS3TZo0CbNmzUK/fv1w/vx5uLi45Pq8iIiIiJ42hf5nRrt27bB69WqzoBIAQkNDERYWBgD48ccfpRxv8eLFuH79OgIDAzFjxgyTbTNmzEBgYCBiY2OlHY+IiKggZUJrczjRv6TVWO7fvx/bt2/H9evX8fDhQ4v7KIqCBQsWyDokACA4OBgAEBsbKyW/devWAQD69+8Pnc407tbpdAgNDcX06dOxdu1ajBw5UsoxiYiICgqbwkkmzYGloen4999/BwCTMS2flBeB5YULFwAA5cqVs7j96NGjmDhxIhISEuDl5YXg4GC88MIL8PDwsLj/sWPHAAANGza0uN2w3rAfERFRUZYpdMjUEBxqSUtPH82B5aRJk7B582b4+Phg8ODBqF69utWgTbabN29i8eLFAIDevXtb3MfQwceYl5cX5s6da/ZMZnJyMuLj4wEA/v7+FvOrWLEiAODOnTtISUmBm5ubxf0ePXqER48eqX8nJSVlf0JERERERZjmwHLVqlXw9vbG0aNHERAQIKNMOZKRkYHBgwcjMTERQUFBZs3SVatWxcyZM9G5c2e1XGfOnMFHH32EjRs3YtiwYbCzs8OgQYPUNMnJyer/rQWMxnOfJyUlWd1v1qxZmDZtWq7Pj4iIKD8IKNBrGDJIcLghMqK5/vru3bto1apVvgaVADBq1Chs374dJUuWxOrVq+Ho6GiyfciQIQgPD0eDBg3g4+MDHx8ftGjRAhs2bMBbb70FABg3bhzS0tLypHzh4eFITExUF1nPgBIREclkaArXshAZaH43BAQEmHVyyWtjxozBggUL4OPjg23btiEwMNCm9FOnToWdnR3u3LmDgwcPquuNm/BTUlIspr1//776f09PT6vHcHJygqenp8lCRERE9DTT3BQ+cOBAfP7557h37x68vb0lFClrEyZMwNy5c+Ht7Y2tW7eqvcJtUaJECZQuXRo3btzA1atX1fUeHh4oUaIEEhISEBMTg/r165ulNdQ8+vr6Wm0Gz4ouQ0CnWO/gVJCEkNyckUVHrtyRVz7pRYPcDPWyr8VDO7n5SX4Py6zwEDq5ZbMw74I2kssHRe4Pe0Vy+fSP5L33rjyybba37Ngpeqn5OSjyBt55mJYuLa/s6IWi6Z4j/X5FRZrmO9J7772HunXronPnzjh79qyMMln17rvv4vPPP4eXlxe2bt1qted2djIzM5GYmAgAZh2NQkJCAACHDx+2mNaw3rAfERFRUZYJneaFyEBzjaWjoyP++OMPNGvWDEFBQfD394e/v7/F5nFFUbB9+/ZcHWfixIn49NNP4eXlhW3btqFRo0a5LvP69euRmpoKRVHMgtOePXsiIiICy5cvxwcffGByHnq9HitWrAAA9OrVK9fHJyIiInoaaQ4s7969i44dO+LUqVMQQiA6OhrR0dEW97U0l3dOvP/++/j444/V5u/sgsqYmBjs3r0bffr0gbOzs8m2X3/9FSNGjAAADBo0CGXLljXZHhYWhg8//BCRkZGYMmUKPvzwQ3XblClTEBkZCT8/P4vTRxIRERU1bAonmaSMY3n06FFUr14dr732GqpXr24yJI9W69evV4O7atWqYd68eRb38/X1xWeffQYASEhIwJAhQ/Daa68hODgYFSpUwIMHD3DmzBl1QPW2bdvi22+/NcvH1dUVK1euRKdOnTBz5kysX78edevWxalTp3Dq1Cm4ublh1apVnCeciIieCnrooNfQnK0lLT19NAeWv/32G8qUKYMDBw7Ax8dHRplMJCQkqP8/fPiw1WcfAwIC1MCyYsWKeO+993Do0CFcvHgRR48eRVpaGnx9fdGtWzcMHDgQoaGhVnuzt2jRAidOnMD06dMRERGBNWvWoFSpUhg6dCj+85//oGrVqtLPk4iIiKio0xxYJiYm4vnnn8+ToBJ43DQdFhZmU5qSJUvio48+0nTcatWqYcmSJZryICIiKuwyhYJMDc3ZWtLS00dzYFmtWjU8fPhQRlmIiIgon/EZS5JJ84MRw4cPx65du0zGgyQiIqKiQQgd9BoWwZl3yIjmd8Nbb72FF198Ee3atcMff/wBvV7ugLNEREREVDRobgo3dGSJjo5Gly5dYG9vj3Llylkdx/LSpUtaD0lERESSZEJBpoaZzbSkpaeP5sDSeMxKIQTS09MRExNjcd/cjmNJREREeUMvtD0nqS+csxRTAdEcWEZFRckoBxEREREVcZoDy4CAABnlICIiogJg6ISjJT2RgeZ3w7Vr13K87+bNm7UejoiIiCTSQ9G8EBloDiy7dOmClJSUbPfbsWMH+vbtq/VwRERERFRIaQ4sT548iT59+iAzM9PqPgcOHED37t2RkZGh9XBEREQkkWHmHS0LkYHmwHLkyJH4448/MGrUKIvbT5w4gS5duuDBgwdYvHix1sMRERGRRFoGR9f6fCY9fTR33pk3bx6uXLmChQsXonLlypg0aZK67fz58+jUqRMSExPx7bffYsCAAVoPR0RERESFlObAUqfTYdWqVWjZsiWmTJmCypUrY8CAAYiOjkaHDh0QFxeHTz75BK+++qqM8hZ5ugwBHQrnoF9CdrEK52kCAERhb7qRfDF0j+Ser5A8Jq3M7IRO8htP9ltFduWO5PPVS85PeWgnLa+rD72l5QUAdorcc7VXrD8SZqu0h2nS8sqOHhrnCmfnHTKiObAEADc3N2zcuBFNmzbFyy+/DACYMmUKrl27hilTpmDChAkyDkNERESSCY09uwUDSzIi7bdzhQoVsGnTJjg4OGDw4MG4fPkyxowZg2nTpsk6BBEREUmmF4rmhchAaqNMvXr1sHr1atjZ2WHEiBH44osvZGZPRERERIWYzU3hdnY5e15mwYIFWLBggck6RVE45BAREVEhwpl3SCabA0uhoVOBlrREREQkn9bmbDaFkzGbA0u9Xp8X5SAiIiKiIk5Kr3AiIiIqmrTO983hhsgYA0siIqJijE3hJJPNT9w+ePBAyoFl5UNEREREhYPNgWXVqlXx3XffITMzdzMMZGRkYN68eahatWqu0hMREZE8HMeSZLI5sCxfvjxef/11VKpUCe+//z4uXLiQo3Tnz59HeHg4KlWqhLfeegsVKlSwubBEREQkFwNLksnmZywPHTqE//3vf3j//fcxc+ZMzJo1C35+fmjWrBlq1aqFkiVLwtPTE0lJSYiPj8eZM2ewf/9+XLt2DUIIlCpVCvPnz8fw4cPz4nyIiIiIqIDYHFgqioJXXnkFQ4YMwdKlS/H111/j5MmTiI2NhaKY/2oxjF1Zr149vPnmmxg0aBBcXFy0l5yIiIg0K8jOO2lpafjuu++wcuVKnDlzBqmpqfD19UVQUBDCwsIQGhqa67ypYOS6V7izszNeeeUVvPLKK4iOjsaff/6JY8eO4datW0hMTIS3tzdKly6NkJAQtG3bFpUqVZJYbCIiIpJBQNuQQbmd+uTq1at47rnncObMGfj6+qJFixZwc3NDbGwsdu/eDTc3NwaWRZCU4YYqVaqEl19+WUZWRERElI8KosbywYMH6NixI86dO4epU6di0qRJcHBwULenpqYiMjIy12WigsNxLImIiChfzZo1C+fOncOrr76KDz74wGy7q6srGjRokP8FI80YWBIRERVj+V1jmZ6ejm+//RYA8M477+T6uFQ4MbDMZ7oMPXSQNd+6zaNFZUnk9kEZqxlKzk8iIX3Ke8nDbUh+7XQP5b5XoMgtoJBYPKGTfC1kj6Sik/zaWeg0qYnkt4rdI3nlu/nAU1peAKCT/EGz18m7saQ/TJOWV3byO7A8evQo4uLiUL58eVSrVg0nT57E2rVrcf36dfj4+KBVq1bo3LkzdDrJb0bKFwwsiYiISLOkpCSTv52cnODk5GS23z///AMA8PPzw8SJE/HJJ5+oI8gAwMcff4zg4GD8+uuv8Pf3z9tCk3T8OUBERFSMyRogvWLFivDy8lKXWbNmWTxefHw8AODYsWP4+OOP8frrr+P8+fNITEzEtm3bEBgYiGPHjqFr165IT0/Pt9eB5GCNJRERUTEmhAKhoSnckDY2Nhaenv8+rmCptvLx/o9rJ9PT0zFgwAB8/fXX6rYOHTpg27ZtqFGjBk6dOoXly5djyJAhuS4b5T/WWBIREZFmnp6eJou1wNLDw0P9/8iRI822+/v7o2vXrgCAiIiIvCks5RnWWBIRERVjeiiaBki3NW2VKlUs/t/SPjdu3Mh1uahgSK+xTEtLw40bN5CQkCA7ayIiIpJM1jOWORUSEqJOAR0XF2dxH8N6d3d3bSdH+U5aYPnTTz+hcePGcHNzg5+fH95++21127p16zBw4EBERUXJOhwREREVQWXLlkXLli0BWG7qTk9Px65duwAAjRs3zteykXZSAssRI0Zg2LBhOHz4MFxcXEyGDQCAwMBALF++HGvWrJFxOCIiIpLE0HlHy2Irw2w7s2bNwoEDB9T1GRkZmDBhAi5fvgwPDw+89NJL0s6T8ofmwHLZsmVYuHAh6tati0OHDiExMdFsnzp16sDPzw+///671sMRERGRRPndFA4A7du3x/Tp03H37l20atUKLVq0QO/evVG9enV89dVXcHFxwS+//IIyZcrkwRlTXtIcWM6fPx/u7u7YuHEjnnnmGfW5iScFBQWxKZyIiKiQKYgaSwB4//338ccff6Bjx444d+4cNmzYgMzMTISFheHo0aNqz3AqWjT3Cj9x4gSaNGmCihUrZrlfiRIlcOvWLa2HIyIioqdEp06d0KlTp4IuBkmkObB89OgRvLy8st3vzp07sLOz03o4IiIikkhonCtcy+Dq9PTRHFhWqFABZ8+ezXIfIQTOnDmDypUraz0cERERSSQAPNHn1ub0RAaan7Fs3749zp07h99++83qPkuXLsXVq1fRsWNHm/NPT0/H9u3b8c4776BRo0bw9vaGg4MDypYti+7du2PTpk1Zpo+IiECXLl3g6+sLFxcX1KxZE5MnT8b9+/ezTHfx4kWEhYXBz88PTk5O8PPzQ1hYGC5fvmzzORAREREVB5oDy7fffhtOTk4YOHAg5syZg+vXr6vbEhIS8N133+H111+Hm5sbRo8ebXP+u3btQocOHfDZZ5/h6tWraNmyJXr16oVSpUphw4YN6NatG0aOHGk2xBEAfPHFF+jYsSO2bNmCOnXq4IUXXkBiYiJmzpyJhg0bWh2Ydd++fahfvz6WLFkCb29v9OzZE97e3liyZAnq1atnMjQCERFRUWaYeUfLQmSgObCsXr06lixZAr1ejwkTJqBixYpQFAVLlixBqVKl8MYbbyAjIwOLFy+Gv7+/7QXU6dC7d2/s3r0bN27cwMaNG7FixQqcPHkSy5cvh52dHebPn4+lS5eapDt27BgmTJgAOzs7bNq0Cbt27cLKlStx6dIltG/fHufPn8eoUaPMjpeamop+/fohNTUV4eHhOHXqFJYvX45Tp04hPDwcKSkp6NevHx48eJDr14yIiKiwKKhe4fR0kjJAet++fXHo0CH07dsXHh4eEEJACAFnZ2e88MIL2L9/P3r37p2rvNu1a4fVq1ejVatWZttCQ0MRFhYGAPjxxx9Nts2aNQtCCLz00kvo3Lmzut7V1RULFiyATqfDmjVrcO7cOZN0ixcvxvXr1xEYGIgZM2aYbJsxYwYCAwMRGxtrdjwiIiKi4k5z5x2DunXrYvny5RBCID4+Hnq9Hr6+vtDppE9HbiI4OBgAEBsbq65LS0tTn70cOHCgWZqAgAC0aNECe/bswbp16xAeHq5uW7duHQCgf//+ZmXX6XQIDQ3F9OnTsXbtWowcOdLm8irpeihCb3M6S2S/slp6BVqi0xfeX7FaHlTPF5LLZ/dI9rWQm5+Q+GaWmVde5AcrY/3mltBJfrNIPl+7h/LONy7FTVpegPRLATudnHs7AGSkPpKWV3b0QoGi4f4v+7uDijbNtxCdToeQkBD1b0VR4Ovri9KlS+d5UAkAFy5cAACUK1dOXRcZGYnU1FQAQMOGDS2mM6w/duyYyXrD37amIyIiKoqE0L4QGWiO/Nzc3FC7dm0ZZbHZzZs3sXjxYgAwaWo3zPDj7e0NDw8Pi2kNA7obzwaUnJyM+Ph4ALD6PKgh3Z07d5CSkqLtBIiIiIieIpqbwqtXr47bt2/LKItNMjIyMHjwYCQmJiIoKMikWTo5ORnA46DXGnd3dwBAUlKSWbqs0hrSGdJa2+/Ro0d49OiRyb5ERESFjdYOOOy8Q8Y011gOHjwYe/bswaVLl2SUJ8dGjRqF7du3o2TJkli9ejUcHR3z9fjZmTVrFry8vNQluykviYiICgJ7hZNMmgPLsWPH4rnnnkO7du3w888/4+HDhzLKlaUxY8ZgwYIF8PHxwbZt2xAYGGiy3dD8nVVTtWGAdE9PT7N0WaU1HljdOO2TwsPDkZiYqC7GnYuIiIgKC/3/T+moZSEy0NwUXq1aNQghEBsbiyFDhmDIkCEoXbo0XFxczPZVFEVzzeaECRMwd+5ceHt7Y+vWrWqvcGOVKlUCANy7dw/JyckWn7M0BHqGfYHHgWWJEiWQkJCAmJgY1K9f32o6X1/fLJvanZyc4OTkZMupERERERVpmgPL6Oho9f+G2W9u3bplcV9F49gO7777Lj7//HN4eXlh69atVntu16hRA66urkhNTcXhw4fRtm1bs30OHz4MACY92g1/R0RE4PDhw3jhhRdynI6IiKgo0tqzm73CyZjmwNK4V3VemjhxIj799FN4eXlh27ZtaNSokdV9HR0d0bVrV6xatQo///yzWWB55coV/PXXXwCAnj17mmzr2bMnIiIisHz5cnzwwQcmQybp9XqsWLECANCrVy9Zp0ZERFRgHgeWWjrvSCwMFXman7EMCAiwacmN999/Hx9//DG8vb2zDSoNJk6cCEVRsGjRImzZskVdn5qaiuHDhyMzMxO9e/dGzZo1TdKFhYWhfPnyiIyMxJQpU0y2TZkyBZGRkfDz88PQoUNzdS5ERERETytpM+/klfXr1+PDDz8E8Ph5znnz5lncz9fXF5999pn6d0hICGbPno3x48ejS5cuaN26NUqXLo09e/bgxo0bqFGjBr777juzfFxdXbFy5Up06tQJM2fOxPr161G3bl2cOnUKp06dgpubG1atWmXxGVIiIqKihsMNkUxSA8sDBw5gx44duHbtGgCgQoUKaNu2LZo2bZrrPBMSEtT/Hz58WH3G8UkBAQEmgSUAjBs3DkFBQZg9ezb+/vtvpKSkwN/fH+Hh4QgPD7c6eHqLFi1w4sQJTJ8+HREREVizZg1KlSqFoUOH4j//+Q+qVq2a6/MhIiIqTAS0zSLLlnAyJiWwjImJwaBBg9TnFg2deAyddVq0aIGffvrJ6mw2WQkLC0NYWFiuy9ahQwd06NDB5nTVqlXDkiVLcn1cIiIiouJGc2B57949tG3bFlFRUXB2dsZzzz2n1uhdvnwZW7Zswd69e9G+fXscPnwYXl5emgtNREREcrApnGTSHFjOnj0bUVFR6NKlC+bPn4/y5cubbL958yZeeeUVbN68GbNnz8Z///tfrYckIiIiWdgWThJp7hW+bt06lCpVCitXrjQLKgGgbNmyWLFiBXx9fbF27VqthyMiIiKZtE7nyBpLMqI5sIyKikLr1q3h6upqdR9XV1e0bt0638a8JCIiIqL8p7kp3M7ODunp6dnul5GRYTLYOBERERU8zrxDMmmO9KpXr46dO3fi3r17VvdJSEjAjh07EBgYqPVwREREJJGWZnCtHX/o6aO5xrJv376YNGkSunbtivnz56NOnTom20+ePImRI0ciKSkJoaGhWg9X5OnS9dAJvZS85OTyL51ebo1yYf4VW5jLBkD6M0t2D6VmB0j+HhES33oy88qL/KS/dorkDCWfr+6RvLwSU+VOTKEocm8EOon5ZaYyWKOiSXNgOWbMGKxYsQL79+9H/fr1ERwcjMqVKwN4PNzQ8ePHodfr0aBBA4wePVpzgYmIiEgirR1wWGNJRjQHli4uLvjzzz/x2muvYfXq1Thy5AiOHDmibtfpdAgNDcW8efPg7Oys9XBEREQkEZ+xJJmkzLzj4+OD5cuXIzY2Frt37zaZ0vHZZ59FxYoVZRyGiIiIiAoxqXOFV6xYEYMGDZKZJREREeUlDpBOEkkNLImIiKho4ZSOJJO0wPLRo0c4fPgwrl27hocPrXdBHTp0qKxDEhEREVEhIiWwnDt3LqZOnYrExMRs92VgSUREVMiwOZsk0RxYLl26FGPHjgUA1KxZE7Vq1YKnp6fWbImIiCgfsCmcZNIcWM6ZMweKomDRokWsjSQiIipq2HmHJNI8x8LZs2fRtGlTBpVERERExZzmGktnZ2dUqlRJQlGIiIgo/ynQNtcom8LpX5oDy4YNG+LChQsyykJERET5jU3hJJHmpvDw8HAcOXIEv//+u4zyEBEREVERZXONZUxMjMnfVatWxfvvv4+ePXti9OjR6NatG/z9/aHTWY5Z/f39c1dSIiIiko81liSRzYFlpUqVoCjmz1MIITB79mzMnj3balpFUZCRkWHrIYmIiCivCOXxoiU90f+zObD09/e3GFgSERERUfFmc2AZHR2dB8UgIiKigiDE40VLeiIDaXOFU84oGXooQi8lL809r54g++YgfzYGeWesl3yusq+F7GeW7B7KzU/26CJC4gsoM6+8yK8wv3Z5kZ/M997DFAd5meUBRSfvg6t/IOd7Ikf4jCVJJP37kIiIiIiKJ+mBZUZGBmbPno1WrVqhVq1a6NixIxYuXCj7MERERCSDofOOloXo/9kcWK5duxalS5fG5MmTzbbp9Xp07doV7777Lvbt24fz589j+/bteOWVVxAWFiajvERERCSRIrQvRAY2B5Y7duxAfHw8+vTpY7bthx9+wLZt2yCEQPfu3fH111/j3XffhYuLC5YuXYqtW7dKKTQRERFJIiQsRP/P5s47Bw8eRLly5RAcHGy27fvvv4eiKOjfvz+WLVumrm/cuDH69OmDpUuXolOnTtpKTERERESFks2B5Y0bN9CgQQOz9XFxcTh+/DgURcE777xjsq1Xr16oVKkSDh48mOuCEhERUR7gAOkkkc1N4XFxcfDx8TFbf+jQIQBAqVKlLAaetWvXxvXr120vIREREeUdNoWTRDYHlnZ2drhz547Z+qNHjwIAQkJCLKbz9vbmdI5ERERETzGbA8uAgAAcPXoUaWlpJuu3b98ORVHQpEkTi+ni4uJQpkyZ3JWSiIiI8gZrLEkimwPLtm3bIj4+HlOmTFHX7dixA7t27QIAdO3a1WK6Y8eOoXz58rksJhEREeUJBpYkkc2B5dixY+Ho6IjPPvsMFStWREhICJ577jkAQJMmTdCwYUOzNPv378edO3es1mYSERERUdFnc2BZrVo1LFu2DG5ubrh27RqOHz+OjIwMlC9fHkuWLLGY5vvvvwcAtG/fXltpiYiISC7OvEMS2TzcEPB4+KCWLVti48aNuHXrFvz9/dGjRw+4ublZ3L9x48YIDg5Gu3btNBWWiIiI5NI6ew5n3iFjuQosAaB06dJ4+eWXc7Tv66+/ntvDEBEREVERkevAkoiIiJ4CWjvgsMaSjNj8jCURERERkSWssSQiIirGFGh8xlJaSehpwBpLIiIiIpKCNZb5TEnXQ9FnFnQxLJP+nIzc3y066OVlJuSWTWLJAAA6ydfC7pHc/GRXUci8HJIvrfyRVArxa5cX+dnLfO+lFO6vLKnv4wf5+D2hdcggDjdERgr3p5SIiIjyFjvvkERFoin8/Pnz+OqrrxAWFoagoCDY29tDURTMmDHDapqpU6dCUZQsl3PnzllNf/HiRYSFhcHPzw9OTk7w8/NDWFgYLl++nBenSERERFTkFYkay2+//RZffvllrtLWr18fDRo0sLjNy8vL4vp9+/ahU6dOSE1NRZ06ddCyZUucOnUKS5YswerVqxEREYGmTZvmqjxERESFCmssSSKpgeWBAwewY8cOXLt2DQBQoUIFtG3bVnMQVrduXbz99tsIDg5GSEgIZs6ciaVLl+YobY8ePTB16tQcHys1NRX9+vVDamoqwsPDMXPmTHXbpEmTMGvWLPTr1w/nz5+Hi4uLradCRERUqHDmHZJJSmAZExODQYMG4a+//gIACPH4XaYojx/obdGiBX766Sf4+/vnKv8RI0aY/K3T5V0L/uLFi3H9+nUEBgaaNbXPmDEDa9asQWRkJH788UeMHDkyz8pBREREVNRojtDu3buHtm3bYt++fXByckL37t0xfvx4jB8/Hi+++CKcnJywd+9etG/fHomJiTLKnKfWrVsHAOjfv79ZAKvT6RAaGgoAWLt2bb6XjYiISDohYSH6f5prLGfPno2oqCh06dIF8+fPR/ny5U2237x5E6+88go2b96M2bNn47///a/WQ9rk6NGjmDhxIhISEuDl5YXg4GC88MIL8PDwsLj/sWPHAAANGza0uN2w3rAfERFRkcZnLEkizYHlunXrUKpUKaxcuRKurq5m28uWLYsVK1agcuXKWLt2bb4Hlhs2bMCGDRtM1nl5eWHu3LkYOnSoyfrk5GTEx8cDgNVm+4oVKwIA7ty5g5SUFLi5uVnc79GjR3j06N8B3JKSknJ9DkRERERFgeam8KioKLRu3dpiUGng6uqK1q1bIyoqSuvhcqxq1aqYOXMmjh07hoSEBCQkJGDv3r3o1q0bEhMTMWzYMCxbtswkTXJysvp/awGju7u7+v+sgsVZs2bBy8tLXQwBKRERUWFi6LyjZSEy0BxY2tnZIT09Pdv9MjIy8rTTzZOGDBmC8PBwNGjQAD4+PvDx8UGLFi2wYcMGvPXWWwCAcePGIS0tLU+OHx4ejsTERHWJjY3Nk+MQERFpYph5R8tC9P80R3rVq1fHzp07ce/ePav7JCQkYMeOHQgMDNR6OCmmTp0KOzs73LlzBwcPHlTXGz93mZKSYjHt/fv31f97enpaPYaTkxM8PT1NFiIiokKHnXdIIs2BZd++fZGYmIiuXbvi9OnTZttPnjyJbt26ISkpSe1RXdBKlCiB0qVLAwCuXr2qrvfw8ECJEiUAPB5CyRJDzaOvr6/V5nIiIiKi4khzYDlmzBjUr18f+/fvR/369dGoUSP069cP/fr1Q8OGDREcHIwDBw6gfv36GD16tIwya5aZmakOffRk7/CQkBAAwOHDhy2mNaw37EdERFSUFZZnLN999111yuWspmymwk1zYOni4oI///wT/fr1AwAcOXIEq1evxurVq3H06FEAQGhoKCIiIuDs7Kz1cFKsX78eqampUBTFbFihnj17AgCWL18OvV5vsk2v12PFihUAgF69euVPYYmIiPJSIWgK/+uvvzB79mx1YhUquqTMvOPj44Ply5cjNjYWu3fvNpnS8dlnn833HtExMTHYvXs3+vTpYxbM/vrrr+pMPoMGDULZsmVNtoeFheHDDz9EZGQkpkyZgg8//FDdNmXKFERGRsLPz89sqCIiIiKyXWpqKsLCwlCuXDk0atQIv/76a0EXiTSQOld4xYoVMWjQIJlZAng8yPnrr7+u/n3p0iUAwPfff4+NGzeq69etW4dy5cohISEBQ4YMwWuvvYbg4GBUqFABDx48wJkzZ3DhwgUAQNu2bfHtt9+aHcvV1RUrV65Ep06dMHPmTKxfvx5169bFqVOncOrUKbi5uWHVqlWcJ5yIiJ4OWpuzNdZYhoeH48KFC9i0aRNWrlypLTMqcJqbwtu1a4dPPvkk2/0+++wztGvXLlfHSEpKwsGDB9UlLi4OwOOON8brDQOSV6xYEe+99x4aN26MK1euYMOGDdi8eTPu37+Pbt264eeff0ZERITJmJTGWrRogRMnTmDo0KFISEjAmjVrkJCQgKFDh+LEiRNo2rRprs6DiIio0CnApvCdO3fiq6++wtChQ9GlS5fcZ0SFhuYay507d6JSpUrZ7nf+/Hns2rUrV8do06YNhMj5O7dkyZL46KOPcnUsg2rVqmHJkiWa8rBEyciAIuyk5yuDYsNrnBP67HexjcSx0nTSh8eQO0ar5EsB+4dyMxSSn4MSMl8+ycPlSi0b5A/5J7t8sl8/u4cS80rJv7GQc0Vi8ZSHhfxcJbh//z5efvlllClTBnPmzCno4pAkUpvCs5Kenp6vA6QTERFRDkiaK/zJ2eicnJzg5ORkNdnbb7+NqKgorFu3Dj4+PhoKQIVJvkV6J0+eRMmSJfPrcERERJQDsoYbqlixoslUxrNmzbJ6zK1bt+L7779H//790aNHj/w5UcoXuaqxfPnll03+3rt3r9k6g4yMDJw5cwbHjx9H9+7dc3M4IiIiKuRiY2NNZpmzVluZmJiI4cOHo1SpUvjqq6/yq3iUT3IVWC5evFj9v6IouHjxIi5evJhlmvLly5sM3UNERERPj5xOXzx27FhcvXoVK1asgK+vbz6UjPJTrgLLRYsWAQCEEHj55ZfRsmVLDB8+3OK+jo6O8PPzQ9OmTeHg4JD7khIREZF8kp6xzKl169bB3t4e33zzDb755huTbefOnQMALFiwABEREShbtiyWL1+uoXCU33IVWA4bNkz9/9SpU9G0aVOTdURERFQ0aJ2WMTdpMzIyshwpJjo6GtHR0QgICMh9wahAaO68Ex0dnaNxLImIiIju3bsHIYTFxVBJNX36dAghEB0dXbCFJZvl23BDREREVEhJH9uXiisGlkRERMVZPj9jSU83jlhORERERFKwxpKIiKgYK4jOO9YsXrzYZEhDKnoYWBIRERVnbAonidgUTkRERERSsMaSiIioGCtMTeFU9EkPLC9evIg7d+6gZMmSCAwMlJ09ERERycSmcJJISlN4ZmYmZsyYgbJly6JGjRpo2bIlPvroI3X7smXL0Lx5c5w+fVrG4YiIiIioENIcWGZmZqJbt2744IMPcPfuXdSqVQtCmP58adGiBQ4cOIC1a9dqPRwRERHJJCQsRP9Pc2D53Xff4Y8//kDbtm0RFRWFU6dOme1TqVIlVK1aFVu3btV6OCIiIpLI8IylloXIQPMzlkuWLEGJEiWwatUq+Pj4WN2vVq1aOHHihNbDFXlKWiYUu8yCLoZlwk5qdrKHHBBCXo5CLy2rPCGEIjU/+4dSs4PQyf0mkXm6Et8meZIf5F5aCJ3cDGWfr/1Dee8VhxTJ5yr5Wsi8tpkPZRcuC3zGkiTSfAs5d+4cGjdunGVQCQBeXl64ffu21sMRERERUSGlucYyMzMTTk5O2e5348aNHO1HRERE+Yg1liSR5sAyICAA//zzT5b7pKen49SpU6hevbrWwxEREZFEHMeSZNLcFP78888jOjoa8+fPt7rPV199hTt37qBr165aD0dEREREhZTmGst33nkHixcvxuuvv44zZ86gX79+AICUlBQcPXoUK1euxOeffw5fX1+8+eabmgtMREREErEpnCTSXGNZrlw5/Prrr/D29sbcuXPRqlUrKIqC1atXo1GjRvjkk0/g7u6ONWvWwNfXV0aZiYiISBION0QySRlY4tlnn8Xp06fx7rvvok6dOnBxcYGTkxOqVauG0aNH4+TJk2jZsqWMQxERERFRISVtrvAyZcrgo48+MpnKkYiIiAo5NoWTRNICSyIiIiqCGFiSRJqbwmNjY/Hjjz/i/PnzVvc5d+4cfvzxR1y9elXr4YiIiIiokNIcWH711Vd46aWXIIT1nyxCCISFheGbb77RejgiIiKSSJGwEBloDiy3bt2KWrVqoWbNmlb3qVWrFmrXro0tW7ZoPRwRERHJJCQsRP9PSlN4tWrVst2vWrVqiI2N1Xo4IiIikojDDZFMmgPL1NRUuLi4ZLufi4sLkpOTtR6OiIiIiAopzb3Cy5Urh+PHj2e734kTJ1C6dGmthyMiIiKZ2CucJNJcY9mqVStERkZizZo1VvdZu3Ytzp07h2effVbr4YiIiEg2Pl9JkmgOLMeMGQNFUTB06FB8+eWXJs3dycnJ+PLLLzF06FDodDqMHj1a6+GIiIiIqJDS3BQeEhKCWbNm4b333sP48ePx9ttvo1y5cgCAGzduQK/XQwiBmTNnonHjxpoLXORlZAB6OylZyR7iQUgeLl/6EBRZDGlVoHlB0tyoRvRC7qtn/0AvNT+hk1s+macr5Hy8/s1P9sVVJL92OrnvZdnna/9AXvns70u+q0jOTub7WHkkL69sj6WxAw4775AxKbeQd955B7/++ivq1auHzMxMXL16FVevXkVmZibq1auHtWvXYuLEiTIORURERDJxuCGSSFodVffu3dG9e3fcunULMTExAAB/f3+UKVNG1iGIiIiIqBCTPld4mTJlGEwSEREVEWwKJ5mkB5ZERERUhHC4IZJIWmB58OBBRERE4Nq1a3j48KHFfRRFwYIFC2QdkoiIiIgKEc2BZVpaGgYMGIBff/0VACCy6G3LwJKIiKhwYVM4yaQ5sJw+fTrWrVsHNzc3DBkyBLVq1YKnp6eMshEREVFeY1M4SaQ5sPzll1/g6uqKgwcPonbt2jLKRERERPmFgSVJpHkcy6tXr6JFixZ5GlSeP38eX331FcLCwhAUFAR7e3soioIZM2ZkmzYiIgJdunSBr68vXFxcULNmTUyePBn379/PMt3FixcRFhYGPz8/ODk5wc/PD2FhYbh8+bKs0yIiIiJ6qmgOLH18fFCiRAkZZbHq22+/xejRo7FkyRKcOnUKmZmZOUr3xRdfoGPHjtiyZQvq1KmDF154AYmJiZg5cyYaNmyIuLg4i+n27duH+vXrY8mSJfD29kbPnj3h7e2NJUuWoF69ejhw4IDM0yMiIiowhmcstSxEBpoDyw4dOuDgwYNZdtrRqm7dunj77bexbNkynD17FkOGDMk2zbFjxzBhwgTY2dlh06ZN2LVrF1auXIlLly6hffv2OH/+PEaNGmWWLjU1Ff369UNqairCw8Nx6tQpLF++HKdOnUJ4eDhSUlLQr18/PHjwIC9OlYiIKH9x5h2SSHNgOX36dCQkJGDq1KkSimPZiBEj8Omnn2LgwIGoWbMmdLrsiz1r1iwIIfDSSy+hc+fO6npXV1csWLAAOp0Oa9aswblz50zSLV68GNevX0dgYKBZU/uMGTMQGBiI2NhY/Pjjj3JOjoiIiOgpobnzzu7du/HSSy9hxowZ2LJlC7p27Qp/f3+rwd/QoUO1HjJbaWlp2LRpEwBg4MCBZtsDAgLQokUL7NmzB+vWrUN4eLi6bd26dQCA/v37m52DTqdDaGgopk+fjrVr12LkyJF5eBZERER5TxECioZWRy1p6emjObAMCwuDoigQQuDQoUM4fPhwlvvnR2AZGRmJ1NRUAEDDhg0t7tOwYUPs2bMHx44dM1lv+DurdMb7ERERFWnsFU4SaQ4shw4dCkVRZJRFmqioKACAt7c3PDw8LO5TsWJFk30BIDk5GfHx8QAAf3//LNPduXMHKSkpcHNzs7jfo0eP8OjRI/XvpKQkG8+CiIiIqGjRHFguXrxYQjHkSk5OBgCrQR8AuLu7AzAN+AzpskprSGdIa22/WbNmYdq0aTkvNBERUQHgzDskk+bOO2RZeHg4EhMT1SU2Nragi0RERGSOvcJJIs01loWRofk7JSXF6j6GAdKNp580bja3ltZ4YPWspq50cnKCk5NTzgpMRERE9BSQGlieO3cO58+fR1JSktVxLfOj806lSpUAAPfu3UNycrLF5ywNNYiGfYHHgWWJEiWQkJCAmJgY1K9f32o6X1/fLJvarUpPB3IwXFJBkN2zT/aPWKnlK+S9GHVC7nvE7oFean6wk/tctZCYneSXDkIn+Rlyye2Gsssn+/WzfyjvveeQIrlwki+tzPexLk1eXtlhUzjJJCWwPHDgAF599VWcPn3a6j5CCCiKki+BZY0aNeDq6orU1FQcPnwYbdu2NdvH0Hs9JCTEZH1ISAgiIiJw+PBhvPDCCzlOR0REVCSxVzhJpPnnX2RkJDp27IhTp06hadOmqFy5MoDH40A+88wzsLOzAwD07NkzX4JKAHB0dETXrl0BAD///LPZ9itXruCvv/5Sy2XM8Pfy5cuh15v+0tbr9VixYgUAoFevXtLLTURElN84pSPJpDmw/Pjjj5GSkoJvvvkG+/btQ6tWrQAAy5Ytw99//41jx46hQYMGuHDhAr7++mvNBc6piRMnQlEULFq0CFu2bFHXp6amYvjw4cjMzETv3r1Rs2ZNk3RhYWEoX748IiMjMWXKFJNtU6ZMQWRkJPz8/PItSCYiIiIqKjQHljt27EDVqlUtzrsNAHXq1MHGjRtx6dIlfPjhh7k6xtGjR9G0aVN1Mcyq8/3335usv3HjhpomJCQEs2fPRmZmJrp06YK2bdsiNDQU1apVw/bt21GjRg189913ZsdydXXFypUr4erqipkzZyIoKAgDBgxAUFAQZs6cCTc3N6xatQouLi65OhciIqJChb3CSSLNgeWNGzdQt25d9W9D03da2r9PHpcrVw6tW7fG2rVrc3WMpKQkHDx4UF3i4uIAAFevXjVZbzwgOQCMGzcO27Ztw3PPPYd//vkHv/32G9zd3REeHo5Dhw7B19fX4vFatGiBEydOYOjQoUhISMCaNWuQkJCAoUOH4sSJE2jatGmuzoOIiKgwYjM4yaK5846Liwvs7f/NxtAD+9atW+osNcDjoXlyO5ZjmzZtrPYyz06HDh3QoUMHm9NVq1YNS5YsydUxiYiIiIojzTWWFSpUQExMjPp3tWrVAAD79+9X1wkhcPToUfj4+Gg9HBEREckkhPaF6P9prrFs0qQJVqxYgQcPHsDFxQXPP/88gMfN0G5ubvD398e8efNw6dIldO/eXXOBiYiISB6OY0kyaa6x7NKlCx4+fIiNGzcCAKpWrYpXX30VN27cQPfu3dGgQQPMnz8fjo6OmDFjhuYCExEREVHhpLnGslevXkhPTzdZN2/ePFSvXh2rVq1CQkICatWqhUmTJqFOnTpaD0dEREQycYB0kihP5grX6XQYP348xo8fnxfZExERkSSK/vGiJT2Rgeam8N27dyMyMjLb/S5cuIDdu3drPRwRERERFVKaA8s2bdrg448/zna/Tz75xOKc3URERFSAOEA6SSSlKTy3Y0wSERFRwWKvcJIpT56xtOTu3btwdnbOr8MRERFRTmgdi5KVS2QkV4Gl8YDoAHD//n2zdQYZGRk4ffo0tm7diqpVq+bmcERERERUBOQqsKxUqRIURVH/XrNmDdasWZNlGiEEBg8enJvDERERUR5hUzjJlKvA0t/fXw0sY2Ji4OrqCl9fX4v7Ojo6ws/PD71798Zrr72W+5I+LdIzAJ3mPlN5Q8gdM0LJfhfbCDuJeRXyO6Hk4TvsH2RKzU/o5F5dYScxP8lvPOnnKvvjX8jLZ/dA3pvZ8b7cz62QfZOSmF9mWj7eoziOJUmUq8AyOjpa/b9Op0Pfvn2xcOFCWWUiIiIioiJIc+edRYsWoVq1ajLKQkRERPmMTeEkk+bActiwYTLKQURERAWBvcJJIs1P09y7dw///PMP7t69a7L+1q1beOmllxAcHIyePXvin3/+0XooIiIiIirENNdYzpo1C5999hkOHToEHx8fAEB6ejpatmyJy5cvQwiBEydOYPfu3Th58iTKly+vudBEREQkB5vCSSbNNZY7duxAQEAAQkJC1HWrVq3CpUuX0KxZM/z6668YPnw47t69i2+++Ubr4YiIiEgmTulIEmkOLGNjY1G9enWTdRs3boSiKFi4cCG6d++OH374AQEBAdi0aZPWwxERERFRIaU5sExISECpUqVM1u3fvx9VqlRBYGCgui4kJASxsbFaD0dEREQSGZrCtSxEBpoDSycnJ9y7d0/9++bNm7hy5Qpatmxpsp+LiwsePHig9XBEREQkk15oX4j+n+bAMjAwEPv27UNqaioAYO3atVAUxSywvH79OkqXLq31cERERCQTn7EkiTQHlqGhoUhMTETr1q0xbtw4TJw4EU5OTujevbu6T0ZGBo4ePWr2LCYRERERPT00Dzc0ZswY/PHHH/jzzz9x5MgR2NnZYc6cOSbPXW7btg1JSUlo1aqV1sMRERGRRAo0DjckrST0NNAcWDo6OmLbtm3Yu3cvbt26hZCQEFSpUsVkH2dnZ3zxxRcmtZhERERUCBTAzDvp6enYvXs3tmzZgp07d+LChQtISUlByZIl0bhxY4wcORJdu3bNfZmowGgOLAFAUZQsayPbtm2Ltm3byjgUERERFXG7du1Cx44dAQBly5ZFy5Yt4ebmhjNnzmDDhg3YsGEDXn31VXz33XdQFNaJFiWan7EkIiKioqsghhvS6XTo3bs3du/ejRs3bmDjxo1YsWIFTp48ieXLl8POzg7z58/H0qVL5Z8w5Smbayx3794NAGjcuDGcnZ3Vv3Pq2WeftfWQRERElFe09uzORdp27dqhXbt2FreFhoZi27ZtWLBgAX788UcMHTpUQ+Eov9kcWLZp0waKouDs2bMIDAxU/84JRVGQkZFhcyGJiIio+AgODgYATqxSBNkcWD777LNQFAWurq4mfxMREVHRowgBRUPnHS1prblw4QIAoFy5ctLzprxlc2C5c+fOLP+mrIn0dAhJgbj0cD4Pbg5SSSyfIuyk5ZUn9HKzs5M86ZXQSX48Wyfv3SwkF01ILBsAqecKQNr9RM3PTm5+9qnyWqkck+V+boXsm6jE/DLSJd8EsqKHtnvO/6dNSkoyWe3k5AQnJyebs7t58yYWL14MAOjdu7eGglFBYOcdIiIi0qxixYrw8vJSl1mzZtmcR0ZGBgYPHozExEQEBQVh5MiReVBSyktShhsiIiKioklWU3hsbCw8PT3V9bmprRw1ahS2b9+OkiVLYvXq1XB0dMx1uahgaA4sjx07hm3btuH06dOIj4+HoigoUaIEgoKC0KlTJ9SrV09GOYmIiCgvSOoV7unpaRJY2mrMmDFYsGABfHx8sG3bNgQGBmooFBWUXAeWV65cwYgRI/Dnn3+q68T//2oxdOZ577330KlTJ8yfPx8VK1bUWFQiIiKSrgBm3nnShAkTMHfuXHh7e2Pr1q1qr3AqenIVWEZFRaFFixa4desWhBAoUaIEQkJC4OvrC71ej7i4OBw7dgx3797F1q1b0bx5c+zduxcBAQGyy09ERERF2LvvvovPP/8cXl5e2Lp1Kxo2bFjQRSINchVYvvzyy7h58yaqV6+OOXPmoHPnzhb327RpE8aNG4eLFy9i+PDhiIiI0FRYIiIikiu3s+cYp8+tiRMn4tNPP4WXlxe2bduGRo0a5T4zKhRs7hV+6NAh7Nq1C4GBgfj777+tBpUA0LVrVxw6dAjVq1fHjh07cOTIEU2FJSIiIskMTeFallx4//338fHHH8Pb25tB5VPE5hrLlStXQlEUzJkzB15eXtnu7+XlhTlz5qBr165YuXIlnnnmmVwVlIiIiJ4O69evx4cffggAqFatGubNm2dxP19fX3z22Wf5WTTSyObA8siRI/Dx8cHzzz+f4zSdO3dGiRIlcOjQIVsPR0RERHlI0T9etKS3VUJCgvr/w4cP4/Dhwxb3CwgIYGBZxNjcFH7hwoVc9dYKCQlRp2giIiKiQqIAmsLDwsIghMh2iY6Oln++lKdsDiwTExPh6+tr84F8fX2RmJhoczoiIiIiKhpsbgpPSUmBi4uLzQdycnJCSkqKzemIiIgoD0kaIJ0IyEVgKXLZ+4uIiIgKH1lTOhIBuRzH8uLFi/jxxx9tTlMQwsLCsGTJkiz3efDgAZydnc3WHzlyBB999BF2796NxMRElCtXDt26dcOUKVNQunTpvCoyERERUZGUq8By37592Ldvn01phBDqVI8FoUWLFqhWrZrFbXZ2dmbrVq9ejQEDBiAjIwONGjVC5cqVcfjwYXz99ddYtWoV9u7dazU/IiKiIqMQTOlITw+bA0t/f/8CDRBza8SIEQgLC8vRvtevX8ewYcOQkZGB77//Hq+++ioAIDMzE2FhYfjpp58wcOBAHDx4sEi+FkRERCoBQMNwQ3zGkozZHFgWh67/c+bMQWpqKjp06KAGlcDjms1vv/0WGzZswKFDh7B161Y899xzBVhSIiIibfiMJcmUq6bwp926desAAAMHDjTb5u7uju7du2Pp0qVYu3atzYGlSEuDKKSVnIX+5lCIyyf9kko+VyUzU2p+0Nk8UlmWhJ3EV1ByK4KQfK6Qea4AhOxWE53c/HQP0qTl5ZBk/tiSJpIvrcxroWRI/swS5ZNiE1ju2LEDJ0+eRHJyMkqWLInGjRujS5cucHJyMtkvOTlZ7WjUsGFDi3k1bNgQS5cuxbFjx/K83ERERHlKQOMzltJKQk+BYhNYWurFXq5cOSxcuNBkekrjpn5/f3+LeVWsWBEAEBUVZfV4jx49wqNHj9S/k5KSbC0yERFR3mPnHZJIckNA4VO/fn18+eWXOHXqFJKSknDr1i1s3boVzZs3x40bN9C9e3fs3LlT3T85OVn9v5ubm8U83d3dAWQdLM6aNQteXl7qYghGiYiIiJ5WT31gOW7cOIwePRp16tSBh4cHSpcujY4dO2Lv3r148cUXkZ6ejrFjx0o/bnh4OBITE9UlNjZW+jGIiIg000tYiP7fUx9YWqMoCqZNmwYAOHHihBr4eXh4qPtYm4Ly/v37AABPT0+r+Ts5OcHT09NkISIiKmwMvcK1LEQGxTawBIBatWqp/7969SoAICAgQF0XExNjMZ0hCK1UqVLeFY6IiIioiCnWgWV8fLz6f0NNpaenpzqjzuHDhy2mM6wPCQnJ4xISERHlMUPnHS0L0f8r1oHl8uXLATwOJmvUqKGu79mzJwDg559/Nktz//59bNiwAQDQq1evfCglERFRHmJgSRI91YHl8ePHsX79emRkZJis1+v1WLBgASZNmgQAGD16NBwcHNTtY8eOhaurKyIiIvDDDz+o6zMzM/H666/j3r17aNSoETp16pQ/J0JERERUBDzV41hGR0ejZ8+e8PHxQUhICMqUKYN79+7h1KlT6vOTAwYMwAcffGCSrnz58li8eDEGDBiAV199FQsWLEClSpVw6NAhXL58GWXKlMHPP//MecKJiKjo4ziWJNFTXWNZv359jB07FnXq1MG5c+ewdu1abN++HQDQp08fbNq0CT///DPs7c3j6759++LgwYPo1asXLl++jHXr1iEzMxNvvPEGTpw4oT6HSUREVKRxuCGS6KmusaxcuTK++OKLXKd/5plnsGbNGoklIiIiKly0DhnE4YbI2FNdY0lERERE+eeprrEkIiKibPAZS5KIgSUREVFxpheAoiE41DOwpH+xKZyIiIiIpGCNJRERUXHGpnCSiIElERFRsaZ19hwGlvQvBpb5TKRlQBTWgdUl/+qUfpaF+Vex7NdObyc1P2Rmys1PJ/cpGsVOYn6SP1/CTvI7WfJrV9jPV5eaJi0vB8mvnfR7scTXTsmQ97oR5ScGlkRERMUZm8JJIgaWRERExZleQFNzNnuFkxH2CiciIiIiKVhjSUREVJwJ/eNFS3qi/8fAkoiIqDjjM5YkEQNLIiKi4ozPWJJEfMaSiIiIiKRgjSUREVFxxqZwkoiBJRERUXEmoDGwlFYSegqwKZyIiIiIpGCNJRERUXHGpnCSiIElERFRcabXA9AwFqWe41jSv9gUTkRERERSsMaSiIioOGNTOEnEwJKIiKg4Y2BJErEpnIiIiIikYI0lERFRccYpHUkiBpb5TGSkQygFXQorCnlzhlKYb16yy2YvOb8HD+TmZ2cnNz+dxMYTndwPmKKTfK52khuKFMnnK7t8Dx5Ky0qXKbn3seTXTua1FZmPpOWV7bGEHkLk/rXVkpaePgwsiYiIijMhtP04LuSVEpS/+IwlEREREUnBGksiIqLiTGh8xpI1lmSEgSUREVFxptcDiobnJPmMJRlhUzgRERERScEaSyIiouKMTeEkEQNLIiKiYkzo9RAamsI53BAZY1M4EREREUnBGksiIqLijE3hJBEDSyIiouJMLwCFgSXJwaZwIiIiIpKCNZZERETFmRAAtIxjyRpL+hcDSyIiomJM6AWEhqZwwcCSjDCwJCIiKs6EHtpqLDncEP2Lz1gSERERkRSssSQiIirG2BROMjGwJCIiKs7YFE4SMbDMJ4ZfdBlI1zQOrTEtw45Zzk/uzUF6+fQSy6eXXTjJT5XoMyXnlyY3P8VObn5QCmleACD5XGW/V6Sfr+z38iN5eWXK/twW3tcuI/Px65YftYFav5cykC6vMFTkMbDMJ8nJyQCAvdgsL9MMeVnlSX4PJOdHRFTMJCcnw8vLK0/ydnR0RNmyZbH3pvbvpbJly8LR0VFCqaioUwQfjsgXer0e169fh4eHBxTpv5IJAJKSklCxYkXExsbC09OzoItT7PF6FB68FoVHTq+FEALJyckoX748dLq862f78OFDpKVpb9FwdHSEs7OzhBJRUccay3yi0+ng5+dX0MUoFjw9PfnlWYjwehQevBaFR06uRV7VVBpzdnZmQEhScbghIiIiIpKCgSURERERScHAkp4aTk5O+OCDD+Dk5FTQRSHwehQmvBaFB68FPe3YeYeIiIiIpGCNJRERERFJwcCSiIiIiKRgYElEREREUjCwpEIhLCwMiqJkuTx8+NBi2iNHjqBv374oU6YMnJ2dUblyZbz11lu4fft2lse8desW3nzzTVSuXBlOTk4oU6YM+vbti6NHj+bFKRYq58+fx1dffYWwsDAEBQXB3t4eiqJgxowZ2aaNiIhAly5d4OvrCxcXF9SsWROTJ0/G/fv3s0x38eJFhIWFwc/PD05OTvDz80NYWBguX76cZbrk5GRMmjQJNWrUgIuLC3x9fdG1a1f8+eefNp1zYZWbazF16tRsPy/nzp2zmp7Xwlx6ejq2b9+Od955B40aNYK3tzccHBxQtmxZdO/eHZs2bcoyPT8XRP9PEBUCw4YNEwBEixYtxLBhwywuaWlpZulWrVol7O3tBQDRqFEj0a9fP1GlShUBQJQpU0ZcuHDB4vHOnz8vSpcuLQCIKlWqiH79+olGjRoJAMLe3l6sXbs2r0+5QI0ZM0bg8ezAJsv06dOzTPf5558LAEJRFPHss8+Kvn37irJlywoAokaNGuLOnTsW0+3du1e4uroKAKJOnToiNDRU1KlTRwAQbm5uYv/+/RbT3bp1SwQGBgoAoly5cqJv377i2WefFYqiCEVRxNy5czW/FgUtN9figw8+EABE/fr1rX5erl+/bjEtr4Vl27ZtU1/7smXLiq5du4p+/fqJunXrqutfffVVodfrzdLyc0H0LwaWVCgYAstFixblOM21a9fUm/L333+vrs/IyBCDBw9Wg80nvwj0er0IDg4WAMSQIUNERkaGuu37778XAIS7u7u4ceOG5vMqrH744Qfx9ttvi2XLlomzZ8+KIUOGZBvMHD16VCiKIuzs7MTmzZvV9SkpKaJ9+/YCgOjdu7dZupSUFFG+fHkBQISHh5tsCw8PFwBExYoVRWpqqlnaF198UQAQ7du3FykpKer6TZs2CTs7O6HT6cSJEydy8xIUGrm5FobA8oMPPrDpWLwW1m3fvl307t1b7N6922zb8uXLhZ2dnQAglixZYrKNnwsiUwwsqVDITWD5zjvvCACiQ4cOZtuSk5OFl5eXACC2bNlism3Tpk0CgPD29hbJyclmaQ1fBhMnTrT5PIoqw+ufVTDTt29fAUCMGDHCbFt0dLTQ6XQCgDh79qzJtnnz5gkAIjAwUGRmZppsy8zMVGtevvvuO5Ntp0+fFgCEnZ2diI6ONjvm8OHDBQDRv39/W0610MvJtchtYMlrkXuGc2zfvr3Jen4uiEzxGUsqstatWwcAGDhwoNk2d3d3dO/eHQCwdu1ai+m6d+8Od3d3s7SG/J5MV5ylpaWpz5hZer0DAgLQokULAP++vgaGv/v37w+dzvSWo9PpEBoaCsD6dWrRogUCAgLMjmkox4YNG5Cenm7zORVHvBa5FxwcDACIjY1V1/FzQWTOvqALQGRsx44dOHnyJJKTk1GyZEk0btwYXbp0MZulIjk5GRcvXgQANGzY0GJeDRs2xNKlS3Hs2DGT9Ya/s0oHABcuXEBKSgrc3Nw0ndPTIDIyEqmpqQCyft327NmT69c7t+lSUlJw4cIF1K5dOyen8lQ5evQoJk6ciISEBHh5eSE4OBgvvPACPDw8LO7Pa5F7Fy5cAACUK1dOXcfPBZE5BpZUqPz4449m68qVK4eFCxfi+eefV9dFR0er//f397eYV8WKFQEAUVFRJusNf2eXTgiB6Oho1KlTJ+cn8JQyvGbe3t5WgxZLr3dycjLi4+MBZP9637lzxySQz+46eXp6wtPTE0lJSYiKiiqWX6AbNmzAhg0bTNZ5eXlh7ty5GDp0qMl6Xovcu3nzJhYvXgwA6N27t7qenwsic2wKp0Khfv36+PLLL3Hq1CkkJSXh1q1b2Lp1K5o3b44bN26ge/fu2Llzp7p/cnKy+n9rNYqGZu6kpCST9Ya02aWzlLa4yu41Ayy/3rZcJ2tpbT1mcVC1alXMnDkTx44dQ0JCAhISErB3715069YNiYmJGDZsGJYtW2aShtcidzIyMjB48GAkJiYiKCgII0eOVLfxc0FkjjWWVCiMGzfO5G8PDw907NgRHTp0QM+ePfHbb79h7NixOH78eMEUkKgQGTJkiNm6Fi1aYMOGDRg9ejS++uorjBs3Dn379oWjo2MBlPDpMWrUKGzfvh0lS5bE6tWr+XoSZYM1llSoKYqCadOmAQBOnDihPjhv3OyUkpJiMa1hYGJPT0+T9Ya02aWzlLa4yu41Ayy/3rZcJ2tpbT1mcTd16lTY2dnhzp07OHjwoLqe18J2Y8aMwYIFC+Dj44Nt27YhMDDQZDs/F0TmGFhSoVerVi31/1evXgUAk96QMTExFtMZgtBKlSqZrDf8nV06RVEs9rosjgyv2b1790ya8YxZer09PDxQokQJANm/3r6+vibNe9ldp6SkJLWp78lrXJyVKFECpUuXBvDv5wXgtbDVhAkTMHfuXHh7e2Pr1q1qr3Bj/FwQmWNgSYWe4SF34N9f656enqhWrRoA4PDhwxbTGdaHhISYrDf8nV266tWrWxyOqDiqUaMGXF1dAeTd653bdG5ubmY1ScVZZmYmEhMTAcCsQwmvRc68++67+Pzzz+Hl5YWtW7da7YHNzwWROQaWVOgtX74cwONgskaNGur6nj17AgB+/vlnszT3799Xe8v26tXLZJsh3fr16y02JxnyezJdcebo6IiuXbsCsPx6X7lyBX/99ReAf19fA8Pfy5cvh16vN9mm1+uxYsUKAOavd48ePQAA+/bts1g7YyjHCy+8AAcHB1tP6am1fv16pKamQlEUs4CI1yJ7EydOxKeffgovLy9s27YNjRo1srovPxdEFhT0CO1Ex44dE7/99ptIT083WZ+ZmSn+97//CWdnZwFAvP/++ybbjad0nD9/vro+IyNDnRYvuykdhw4dWiyndHxSTmZ7OXLkiDp13e+//66ut2XqukmTJplsmzRpkgAg/Pz8spy6rkOHDibbN2/e/NROXZfdtbhy5YpYunSpePDggdm2devWiRIlSggAYvDgwWbbeS2yNnnyZHVWrr///jtHafi5IDLFwJIK3Lp16wQA4ePjI9q3by8GDhwounTpIvz9/QUAAUAMGDDALPAUQoiVK1eqc/g2adJEhIaGiipVqggAokyZMuLChQsWj3nu3DlRqlQpAUBUqVJFhIaGisaNGwsAwt7eXqxduzavT7tAHTlyRDRp0kRdfH191S8y4/XXr183Sff5558LAEJRFNGmTRvRr18/Ua5cOQFA1KhRQ9y5c8fi8fbu3av+CKhbt67o37+/qFu3rgAg3NzcxP79+y2mu3XrlqhevboAIMqVKyf69esn2rRpIxRFEQDEl19+Kf21yW+2Xotjx46pP35atWol+vfvL1588UX1dQIg2rZta3G6UiF4Laz57bff1NevYcOGYtiwYRaXCRMmmKXl54LoXwwsqcBdvnxZjB07VrRs2VJUqFBBODs7CycnJ+Hv7y/69OkjNm3alGX6w4cPi169eolSpUoJR0dHERAQIN544w1x8+bNLNPduHFDvPHGGyIgIEA4OjqKUqVKiV69eokjR47IPL1CaceOHeqXaFZLVFSUWdpt27aJ559/XpQoUUI4OTmJ6tWri/DwcJGUlJTlMS9cuCCGDh0qypcvLxwcHET58uXF0KFDxcWLF7NMl5iYKCZOnCiqV68unJycRIkSJcTzzz8vIiIitLwEhYat1yIuLk689957ol27dsLf31+4ubkJBwcHUa5cOdGtWzfx888/m809/SReC3OLFi3K0XUICAiwmJ6fC6LHFCGEyFUbOhERERGREXbeISIiIiIpGFgSERERkRQMLImIiIhICgaWRERERCQFA0siIiIikoKBJRERERFJwcCSiIiIiKRgYElEREREUjCwJCIiIiIpGFjSU6NSpUpQFMVkcXJygr+/P0JDQ7Fnzx6zNFOnToWiKJg6dWr+FziPnD17FuPHj0dwcDBKliwJBwcHlCxZEs2aNUN4eDjOnj1b0EXMF4X12o4bNw46nQ6HDx82WR8WFqa+bxs0aJBlHocOHTJ5n+/du1fd1qpVKyiKgs8++8xi2rS0NLi6ukJRFHTo0MHqMbp16wZFUTBlyhR13YgRI2Bvb4+TJ0/m4EyJqDhiYElPnRYtWmDYsGEYNmwYOnfuDL1ej5UrV6J169b4/PPPC7p4FskIgjIyMjBu3DjUrVsXX3zxBWJiYtCoUSP069cPTZs2RVRUFD766CPUrVsXX3/9tbzCFzE7d+6Eoiho06ZNvh/77Nmz+Prrr9G7d280bNjQ6n4nTpzAkSNHrG5fsGCB1W1t27YF8Pg8LTl48CAePHgAANi/fz/S0tLM9snMzFR/iBnyAx6/Tx0cHDB69Girxyei4o2BJT11RowYgcWLF2Px4sX49ddfcfHiRQwdOhRCCLz77ruIjIws6CLmicGDB2POnDlwd3fHokWLcPv2bWzZsgXLli3Dpk2bcOPGDfzxxx9o0KABLl68WNDFzXNvvvkmzp49izfffLOgi6J65513kJGRkeUPCEPAuXDhQovbHzx4gOXLl6NcuXLw8/Mz224IBPfs2YPMzEyz7YaAMyQkBKmpqfj777/N9jl69CiSkpLg5OSE5s2bq+v9/PwwYsQI7Ny5E+vXr7d6DkRUfDGwpKees7Mz5s2bBzc3N2RmZmLt2rUFXSTpFi5ciBUrVsDBwQFbt25FWFgY7OzsTPZRFAWdOnXCgQMHEBoaWkAlzT++vr6oWbMmfH19C7ooAIDIyEhs3rwZTZs2RZ06dazu17VrV5QpUwa//PILHj58aLZ99erVSExMxNChQ82uMQA0a9YMTk5OSEpKsljruXPnTtjZ2WHy5MkAgB07dpjtY1jXtGlTODs7m2wbPnw4AGDOnDnWT5aIii0GllQsuLu7o0aNGgCA6OjobPdPT0/HTz/9hEGDBqFmzZrw9PSEi4sLatSogdGjR+P69esW07Vp0waKomDnzp04fvw4evXqBV9fXzg5OaF27dqYPXs2hBAmaRRFwbRp0wAA06ZNM3l2LiwsLNuyCiHw4YcfAgBee+01NGnSJMv9HRwc0KxZM5N1a9euxYgRI1C3bl34+PjA2dkZlStXxssvv4zz589bzMfwTODixYtx4sQJ9OrVC6VKlYKLiwvq1auHL7/80mKNWXJyMn744Qf06tUL1atXh5ubG9zc3BAUFITJkyfj3r17VsuekZGBhQsXokOHDurr6ufnhw4dOuCrr74y2dfS4wVt2rRRa/R27dpl8lpXqlQJANC6dWsoioJffvnFajk++eQTKIqCfv36Wd3nSfPmzYMQIttram9vjyFDhuDu3btYt26d2XZDTebLL79sMb2zs7N6fZ9sDk9LS8P+/fsRHByM559/Hg4ODhabzA3rjJvBDRo0aID69etjx44dxeZ5XSLKOQaWVGwkJSUBAJycnLLd99atWxgyZAj+r707D6qq/B84/uaCTKKY5CiKDqbiroCow6qE6IgOaqIjuaEYY4Y60uQfYiVq5TSZzTiGSElENeaShjIiKAq4IKmjYpqiGLkSriCgXZZ7fn8453y53HvhYvzs+9XP6z+f8yznOfeMfObZzt69e3FyciIkJIRRo0ZRWVnJhg0bmpxOzszMxNvbm0uXLjFmzBh8fX25fPkyS5cu5b333jPKO2fOHDw8PADw8PDQ1ofOmTOHgICAJu/1t99+448//tDqehbTpk3jp59+onXr1owaNYqxY8ei0+lITk5m6NCh5OXlWSx74sQJfHx8OHPmDMHBwYwcOZLCwkJiYmJ46623TALpgoIC5s+fz9GjR+ncuTMTJkwgICCAkpIS1qxZw/Dhw7l//75JO+Xl5QQFBfH2229z+PBhBg0axJQpU+jTpw/nzp2zat1fSEgIY8eOBcDZ2dnoWU+dOhWAJUuWAFhch2owGEhISABo1jR7amoqQKMbZlRq0NhwOvzq1avk5ubi7+9Pnz59LJZXA8KGo5Hq+srAwEAcHBwYNmwYx48fR6/Xa3lqa2u1zUDmAkuAMWPGGPVJCCE0ihAviO7duyuAkpycbHKtoKBA0el0CqB8++23WnpcXJwCKHFxcUb5Hz16pOzevVvR6/VG6dXV1UpsbKwCKOPHjzdpJzAwUAEUQNm0aZPRtYMHDyo2NjaKra2tcuPGDaNrlu7DGklJSQqg2NvbKzU1Nc0uryiKsnXrVqWystIozWAwKPHx8QqgDBw4UDEYDEbX58yZo/U1OjraqO3z588rHTt2NPscbty4oWRlZSl1dXVG6VVVVUpERIRWX0NhYWEKoAwZMkQpLi42ulZTU6OkpqYapVl6ptnZ2QqgBAYGmn0WtbW12rt0+vRpk+tpaWkKoLi7u5stb05RUZECKB07drSYR32eH3/8saIoiuLr66vodDrl2rVrWp4PPvjA6B1W7/PIkSNGdR0+fFgBlLZt2xr9LqtXr1YAJS0tTVEURVm2bJkCKLm5uVqe/Px8BVBat25t8v6rdu3apQBKcHCw1c9ACPFykBFL8UIrLy8nPT2dsLAwDAYDLi4uVk1fOjo6MnHiROzt7Y3SW7VqxZo1a3BxcSEjI4OKigqz5cPCwnjnnXeM0tSRwLq6OrPr2p7V3bt3AXjttdews7N7pjrCw8Np06aNUZqNjQ3R0dH4+vpy4cIFi9OeXbp0Yd26dUZtDxw4kBUrVgCwbt06o/zdunUjODgYnc74vx8HBwcSEhKws7Njx44dRtcKCgrYtWsXr7zyCmlpadq0tcrOzo5JkyY1q8+W2NrasnDhQuDp9HVD6kimmscaZ86cAaB///5Wl5k3bx4Gg4Hk5GTg6UhpSkoKbdu2bfId9vb2pnXr1lRWVnLy5EktPTs7G51Ox4gRI4Cn0/5qev08AH5+fibvv0pdI3r69Gmr+yOEeDk8218hIf6LRUZGEhkZaZLeq1cvdu7caRJANaagoICDBw9SXFxMVVUVBoMBeDpdaDAYKCoqYsiQISblJkyYYLa+/v37k5GRwa1bt6y+h+elqKiIjIwMioqKqKio0NZHlpaWAlBYWMiAAQNMyk2bNs1kgwc8nZZfvHgxV65c4fbt27i4uBhdz8vL48iRI1y/fp3Hjx9rU+b29vbcvXuXhw8f4uTkBEBGRgbwdGNL165dW67TFkRFRbFy5Uq2bNnC2rVrtfsoKipi//79tG/fnlmzZlldn/oMO3ToYHWZ8PBwYmJi+O6771ixYgWZmZncvHmTefPmNfkO29vb4+/vT1ZWFjk5Ofj6+qLX68nPz8fT05NXX30VeHo0l62tLTk5OcTFxQGNr69Uqf14+PAh1dXVFgNQIcTLRwJL8cLx9/fHzc0NePoHtlOnTvj4+BASEmL1iF5VVRWzZ882u3miPnXdZkOurq5m09u1awdgdrfvs+rYsSMADx48oK6uzuxO4cbU1dWxaNEiEhMTTdZD1meprz169DCb7ujoSIcOHbh//z43b97UAss7d+4wZcoUo0O9LbWnBnTXrl0DoF+/fk32pyU4OTkxe/ZsEhMTSUpKYunSpQBs3LgRRVGIjIzEwcHB6vrKy8uB//z+1nB0dGTq1KmkpKRw6NChJjftNBQUFERWVhbZ2dnExsZq6yvrn9/p6OiIl5cX+fn56PV6bG1tOXbsmFbekvr9KCsro1OnTlb3SwjxYpOpcPHCqX+O5ddff80nn3xCaGhos6aJY2Nj+eWXX+jXrx+pqancunULvV6PoigoiqLturUUiDWc5v3/NHToUODpjt+CgoJml1+/fj2bNm3C2dmZLVu28Oeff/LkyROtr9OnTwcs99Ua9ctGRUVx9OhRfH192b9/P6WlpVRXV2vtdenS5R+31xLUzUAJCQkYDAYeP35McnIyNjY2zZoGB2jfvj1gOTi3RA0i165dy549e+jbty/+/v5WlVUDw2PHjlFdXa2NRDY8GD4wMJC///6b48ePc/LkSSorK2nTpg3Dhw+3WLcaKANa8C+EECAjlkKYtX37dgC2bduGu7u7yfUrV64871uyyN3dnR49elBcXExKSgpeXl7NKq/2NTExkYkTJ5pcb6qvxcXFZtMrKiq03d3qQd5VVVWkp6ej0+lIT0/XAi5VVVUVf/31l0ld6gjwpUuXGu9MCxowYACjR48mKyuLffv2cfv2bcrKyhg3bhy9evVqVl3qiJ653e6NGTlyJG5ubmRmZgKYXeJhyfDhw2nbti2VlZWcOHGCnJwco/WVqsDAQL744gtycnK0ExMCAgJo1aqVxbrVfjg5OTWaTwjx8pERSyHMePDgAQDdu3c3uZaZmcm9e/datD11jVptbW2zy9rY2LB8+XLg6eiauS+p1FdbW0t+fr7278b6euHCBc6ePdtofTt27DA6rkb1ww8/AODm5qatiywvL6euro527dqZBJUAP/74o9mRypCQEADS09MtniFqreY86/pHD6kbeZ7lSz5qsP8s5z4uWLCADh060KlTJyIiIqwuZ2dnpx1XlZmZSX5+Ph4eHibPPSAgAJ1OR3Z2trZxp7FpcIDz588D/xktF0IIlQSWQpih7t5teOh2YWEhCxYsaPH21BG9CxcuPFP5qKgopk6dSk1NDWPGjCElJcXkcHJFUTh06BB+fn5s3bpVS1f7Gh8fr21OAigpKSEiIqLJAOz27dssXbrUqL2LFy+yevVqAKNzO52dnXFycqKsrEwLPFX5+fnExsaabcPT05NJkybx5MkTJk2axPXr142u19bWWv2JQfVZX7lyhZqamkbzjh8/Hjc3NzIyMigoKKBXr16MGzfOqnbq69mzJ66urty9e7fZn9N8//33uXfvHqWlpdoyAWupAeLGjRtN1leq2rdvj4eHB7/++qt2XmlTgaWab9SoUc26HyHEi08CSyHMiIuLw8bGho8++gh3d3emT59OcHAwgwcPpmfPnkbfT24JY8eOpU2bNqSmphIQEEBkZCRRUVHaUTPW2LJlC4sWLaKiooK5c+fi7OzMuHHjmDlzJqGhoXTt2pXg4GBOnz5tdLj28uXLsbe355tvvqFv376Eh4dr0716vZ7Jkyc32u6CBQvYvHkzvXv3Zvr06YSEhODp6UlpaSmTJ0/m3Xff1fLa2tpqxxBFRETg4+PDjBkzCAgIwM/Pj9DQULMjpwDJycn4+Phw6tQpevfuTVBQEDNnziQ4OBgXFxerjxtydXVl2LBh3Llzh8GDBzNr1iyioqJYtmyZSV6dTmc0QhkdHY2NjY1V7TT05ptvAnDgwIFnKv8s1ABRHZVWjxdqKDAwEL1eT1VVFe3atWtyJDIrKwugxY54EkK8OCSwFMKMsLAwcnNzCQ4OpqSkhD179nDnzh1WrlzJvn37WnxdmbOzM/v27WP06NH8/vvvfP/99yQlJZGbm2t1Ha1atWLDhg2cP3+eJUuW0K1bN/Lz89m+fTt5eXm4urqyfPlyLl68SHR0tFbO29ubU6dOMXHiRKqqqtizZw9Xr15l8eLFHD9+vMmdzN7e3uTl5TFo0CAOHDhATk4OvXv35ssvv2T79u0mgVhMTAypqan4+flRWFhIWloaer2e+Ph4UlJSLLbj5OREbm4uCQkJeHt7c/bsWX7++WcuX76Mp6en2TMnLdm5cyczZszg0aNHbNu2jaSkJKNR3PrUL/U4ODhYvSPbnIULF2qfwHxevLy8tN9Pp9MxcuRIs/nqB5wjRoxo9GSBM2fOcO7cOYKCgswePyWEeLnZKP/21kshxP+kuXPnkpKSQnJyslXfNP9f9eGHH/Lpp58yf/58EhMT/1FdoaGh7N27l3PnzjF48OAWusPna/HixXz11Vfs3r3b7GYvIcTLTUYshRDCgpKSEuLj49HpdMTExPzj+j7//HPs7OxYtWrVP7+5f8GNGzfYvHkzb7zxhgSVQgizJLAUQogGli1bxuzZs/Hy8qKsrIz58+c363OMlgwYMIBFixaxc+dOTp061QJ3+nytWrWKmpoa1q9f/2/fihDiv5RMhQshnsmLPBX++uuvc/36dTp37kx4eDifffaZdsajEEIIyySwFEIIIYQQLUKmwoUQQgghRIuQwFIIIYQQQrQICSyFEEIIIUSLkMBSCCGEEEK0CAkshRBCCCFEi5DAUgghhBBCtAgJLIUQQgghRIuQwFIIIYQQQrSI/wPflWtdRgI7PAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_cost, shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Plant Capacity (MW)')\n", + "plt.ylabel('Distance to Shore (km)')\n", + "# plt.title('HVDC is cheaper where green')\n", + "plt.suptitle('Cheaper Transmission Type Cost (HVAC v HVDC)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6ff5f19d-e474-4800-bada-c4b682ad451e", + "metadata": { + "tags": [] + }, + "source": [ + "# Overall Bar Chart" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "840bbe59-471c-424f-bba2-c1bc2d7b3fa0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ind = np.arange(0,20)\n", + "index = 3\n", + "width = 0.4\n", + "plt.figure(figsize=(12,5))\n", + "plant_cap = np.arange(100,2100,100)\n", + "\n", + "cable_data_ac = parametric.results.cable_cost[20*index:20*(index+1)]\n", + "# print(len(parametric.results.cable_cost[20*index:20*(index+1)]))\n", + "substation_data_ac = parametric.results.oss_cost[20*index:20*(index+1)]\n", + "plt.bar(ind,cable_data_ac, width, label = 'ac cable', color = 'lightsteelblue')\n", + "plt.bar(ind,substation_data_ac, width, label = 'ac oss', color = 'cornflowerblue', bottom = cable_data_ac)\n", + "\n", + "cable_data_dc = parametric.results.cable_cost[num+20*index:num+20*(index+1)]\n", + "substation_data_dc = parametric.results.oss_cost[num+20*index:num+20*(index+1)]\n", + "plt.bar(ind+width, cable_data_dc, width, label = 'dc cable', color = 'lightcoral')\n", + "plt.bar(ind+width, substation_data_dc, width, label = 'dc oss', color = 'indianred', bottom = cable_data_dc)\n", + "plant_cap_str = np.char.mod('%d',plant_cap)\n", + "# print(plant_cap)\n", + "\n", + "total_cost = parametric.results.oss_cost + parametric.results.cable_cost\n", + "plt.plot(ind, total_cost[0+20*index:20*(index+1)], color = 'blue', label = 'HVAC')\n", + "plt.plot(ind, total_cost[num+20*index:num+20*(index+1)], color = 'red', label = 'HVDC')\n", + "\n", + "plt.xticks(ind,plant_cap_str)\n", + "plt.legend(loc = 'upper left')\n", + "plt.ylabel(\"Project Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83910fe9-93e7-4a11-bd62-6603d766d76c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index 1a2fe071..e762eab5 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -151,7 +151,7 @@ def calc_num_mpt_and_rating(self): capacity = num_turbines * turbine_rating self.num_substations = _design.get( - "num_substations", int(np.ceil(capacity / 500)) + "num_substations", int(np.ceil(capacity / 800)) ) self.num_mpt = np.ceil( num_turbines * turbine_rating / (250 * self.num_substations) diff --git a/bycap_bydist.ipynb b/bycap_bydist.ipynb index f8f54f95..1619aa45 100644 --- a/bycap_bydist.ipynb +++ b/bycap_bydist.ipynb @@ -279,7 +279,7 @@ "data": { "text/plain": [ "{'Export System': 165624900.0,\n", - " 'Offshore Substation': 135441185.21562335,\n", + " 'Offshore Substation': 122731375.30288924,\n", " 'Export System Installation': 116801066.62180227,\n", " 'Offshore Substation Installation': 3098929.2998477924,\n", " 'Turbine': 780000000,\n", @@ -331,7 +331,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -386,7 +386,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/hvdc_comparison.ipynb b/hvdc_comparison.ipynb index 2a4fc896..e26858db 100644 --- a/hvdc_comparison.ipynb +++ b/hvdc_comparison.ipynb @@ -10,7 +10,9 @@ "from ORBIT.phases.design import ElectricalDesign\n", "from ORBIT import ParametricManager, ProjectManager\n", "import numpy as np\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" ] }, { @@ -18,9 +20,6 @@ "execution_count": 2, "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", "metadata": { - "jupyter": { - "source_hidden": true - }, "tags": [] }, "outputs": [], @@ -33,8 +32,9 @@ "# 'distance_to_landfall': 50\n", " },\n", " 'plant': {\n", - " 'num_turbines': 60, \n", - "# 'capacity': 600\n", + " 'turbine_rating': 10\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", " },\n", " 'turbine': {'turbine_rating': 10},\n", " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", @@ -54,9 +54,9 @@ "source": [ "parameters = {\n", " 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(30,330,30),\n", + " 'site.distance_to_landfall': np.arange(15,315,15),\n", "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2300,300)\n", + " 'plant.capacity': np.arange(100,2100,100)\n", "}" ] }, @@ -70,7 +70,7 @@ "results = {\n", " 'cable_cost': lambda run: run.total_cable_cost,\n", " 'oss_cost': lambda run: run.substation_cost,\n", - " 'compensation': lambda run: run.cable.compensation_factor\n", + " 'num_substations': lambda run: run.num_substations\n", "}" ] }, @@ -86,87 +86,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n", - "Design uses HVDC cable\n" + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" ] }, { @@ -195,54 +115,54 @@ " plant.capacity\n", " cable_cost\n", " oss_cost\n", - " compensation\n", + " num_substations\n", " \n", " \n", " \n", " \n", " 0\n", " XLPE_1000m_220kV\n", - " 30\n", + " 15\n", " 100\n", - " 28067000.0\n", - " 3.325204e+07\n", - " 3.174298\n", + " 15317000.0\n", + " 2.818467e+07\n", + " 1\n", " \n", " \n", " 1\n", " XLPE_1000m_220kV\n", - " 30\n", - " 400\n", - " 56134000.0\n", - " 6.481958e+07\n", - " 3.174298\n", + " 15\n", + " 200\n", + " 15317000.0\n", + " 3.488367e+07\n", + " 1\n", " \n", " \n", " 2\n", " XLPE_1000m_220kV\n", - " 30\n", - " 700\n", - " 84201000.0\n", - " 9.638712e+07\n", - " 3.174298\n", + " 15\n", + " 300\n", + " 15317000.0\n", + " 4.102442e+07\n", + " 1\n", " \n", " \n", " 3\n", " XLPE_1000m_220kV\n", - " 30\n", - " 1000\n", - " 112268000.0\n", - " 7.151858e+07\n", - " 3.174298\n", + " 15\n", + " 400\n", + " 30634000.0\n", + " 5.468484e+07\n", + " 1\n", " \n", " \n", " 4\n", " XLPE_1000m_220kV\n", - " 30\n", - " 1300\n", - " 140335000.0\n", - " 8.702323e+07\n", - " 3.174298\n", + " 15\n", + " 500\n", + " 30634000.0\n", + " 6.138384e+07\n", + " 1\n", " \n", " \n", " ...\n", @@ -254,83 +174,83 @@ " ...\n", " \n", " \n", - " 155\n", + " 795\n", " XLPE_1200m_300kV_DC\n", " 300\n", - " 1000\n", - " 451499800.0\n", - " 1.863550e+08\n", - " NaN\n", + " 1600\n", + " 506043400.0\n", + " 2.053356e+08\n", + " 2\n", " \n", " \n", - " 156\n", + " 796\n", " XLPE_1200m_300kV_DC\n", " 300\n", - " 1300\n", - " 451499800.0\n", - " 1.958453e+08\n", - " NaN\n", + " 1700\n", + " 506043400.0\n", + " 1.441509e+08\n", + " 3\n", " \n", " \n", - " 157\n", + " 797\n", " XLPE_1200m_300kV_DC\n", " 300\n", - " 1600\n", - " 451499800.0\n", - " 2.053356e+08\n", - " NaN\n", + " 1800\n", + " 759065100.0\n", + " 1.924958e+08\n", + " 3\n", " \n", " \n", - " 158\n", + " 798\n", " XLPE_1200m_300kV_DC\n", " 300\n", " 1900\n", - " 677249700.0\n", + " 759065100.0\n", " 1.947288e+08\n", - " NaN\n", + " 3\n", " \n", " \n", - " 159\n", + " 799\n", " XLPE_1200m_300kV_DC\n", " 300\n", - " 2200\n", - " 677249700.0\n", - " 2.008696e+08\n", - " NaN\n", + " 2000\n", + " 759065100.0\n", + " 1.969618e+08\n", + " 3\n", " \n", " \n", "\n", - "

160 rows × 6 columns

\n", + "

800 rows × 6 columns

\n", "" ], "text/plain": [ " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", - "0 XLPE_1000m_220kV 30 100 \n", - "1 XLPE_1000m_220kV 30 400 \n", - "2 XLPE_1000m_220kV 30 700 \n", - "3 XLPE_1000m_220kV 30 1000 \n", - "4 XLPE_1000m_220kV 30 1300 \n", + "0 XLPE_1000m_220kV 15 100 \n", + "1 XLPE_1000m_220kV 15 200 \n", + "2 XLPE_1000m_220kV 15 300 \n", + "3 XLPE_1000m_220kV 15 400 \n", + "4 XLPE_1000m_220kV 15 500 \n", ".. ... ... ... \n", - "155 XLPE_1200m_300kV_DC 300 1000 \n", - "156 XLPE_1200m_300kV_DC 300 1300 \n", - "157 XLPE_1200m_300kV_DC 300 1600 \n", - "158 XLPE_1200m_300kV_DC 300 1900 \n", - "159 XLPE_1200m_300kV_DC 300 2200 \n", + "795 XLPE_1200m_300kV_DC 300 1600 \n", + "796 XLPE_1200m_300kV_DC 300 1700 \n", + "797 XLPE_1200m_300kV_DC 300 1800 \n", + "798 XLPE_1200m_300kV_DC 300 1900 \n", + "799 XLPE_1200m_300kV_DC 300 2000 \n", "\n", - " cable_cost oss_cost compensation \n", - "0 28067000.0 3.325204e+07 3.174298 \n", - "1 56134000.0 6.481958e+07 3.174298 \n", - "2 84201000.0 9.638712e+07 3.174298 \n", - "3 112268000.0 7.151858e+07 3.174298 \n", - "4 140335000.0 8.702323e+07 3.174298 \n", - ".. ... ... ... \n", - "155 451499800.0 1.863550e+08 NaN \n", - "156 451499800.0 1.958453e+08 NaN \n", - "157 451499800.0 2.053356e+08 NaN \n", - "158 677249700.0 1.947288e+08 NaN \n", - "159 677249700.0 2.008696e+08 NaN \n", + " cable_cost oss_cost num_substations \n", + "0 15317000.0 2.818467e+07 1 \n", + "1 15317000.0 3.488367e+07 1 \n", + "2 15317000.0 4.102442e+07 1 \n", + "3 30634000.0 5.468484e+07 1 \n", + "4 30634000.0 6.138384e+07 1 \n", + ".. ... ... ... \n", + "795 506043400.0 2.053356e+08 2 \n", + "796 506043400.0 1.441509e+08 3 \n", + "797 759065100.0 1.924958e+08 3 \n", + "798 759065100.0 1.947288e+08 3 \n", + "799 759065100.0 1.969618e+08 3 \n", "\n", - "[160 rows x 6 columns]" + "[800 rows x 6 columns]" ] }, "execution_count": 5, @@ -339,7 +259,7 @@ } ], "source": [ - "parametric = ParametricManager(base_config, parameters, results, module=ElectricalDesign, product=True)\n", + "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", "parametric.run()\n", "parametric.results\n", "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", @@ -347,20 +267,18 @@ ] }, { - "cell_type": "code", - "execution_count": 6, - "id": "0f9311f2-9b72-4c71-b8e1-5ffc448bdaf8", - "metadata": {}, - "outputs": [], + "cell_type": "markdown", + "id": "541a0f21-04e4-4125-8d2c-0fa20a7eb357", + "metadata": { + "tags": [] + }, "source": [ - "# plt.plot(parametric.results.cable_cost)\n", - "# plt.show()\n", - "# index = results.index" + "# Varying plant capacity for given distance to shore" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 29, "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", "metadata": {}, "outputs": [ @@ -368,12 +286,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "80\n" + "400\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -383,7 +301,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -393,7 +311,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -409,48 +327,81 @@ "num = int(len(parametric.results) / 2)\n", "print(num)\n", "\n", + "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", + "plant_cap = np.arange(100,2100,100)\n", + "index = 3\n", + "\n", "# Cable Cost\n", - "plt.plot(np.arange(100,2300,300), parametric.results.cable_cost[0:8])\n", - "plt.plot(np.arange(100,2300,300), parametric.results.cable_cost[num:num+8])\n", + "plt.step(plant_cap, parametric.results.cable_cost[0+20*index:20*(index+1)])\n", + "plt.step(plant_cap, parametric.results.cable_cost[num+20*index:num+20*(index+1)])\n", "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,1.1e9])\n", + "\n", "plt.show()\n", "\n", "# Substation Cost\n", - "plt.plot(np.arange(100,2300,300), parametric.results.oss_cost[0:8])\n", - "plt.plot(np.arange(100,2300,300), parametric.results.oss_cost[num:num+8])\n", + "plt.plot(plant_cap, sub_cost[0+20*index:20*(index+1)])\n", + "plt.plot(plant_cap, sub_cost[num+20*index:num+20*(index+1)])\n", "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,1.1e9])\n", + "\n", "plt.show()\n", "\n", "#Total Export System Cost\n", - "total_cost = parametric.results.oss_cost + parametric.results.cable_cost\n", - "plt.plot(np.arange(100,2300,300), total_cost[0:8])\n", - "plt.plot(np.arange(100,2300,300), total_cost[num:num+8])\n", + "total_cost = sub_cost + parametric.results.cable_cost\n", + "plt.plot(plant_cap, total_cost[0+20*index:20*(index+1)])\n", + "plt.plot(plant_cap, total_cost[num+20*index:num+20*(index+1)])\n", "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", + "plt.ylabel(\"Total Export Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.ylim([0,1.1e9])\n", + "plt.rcParams.update({'font.size':16})\n", "plt.show()\n" ] }, + { + "cell_type": "markdown", + "id": "011bc16a-e7ca-44a9-97b2-f23be59a1025", + "metadata": { + "tags": [] + }, + "source": [ + "# Varying distance to shore for given plant capacity" + ] + }, { "cell_type": "code", - "execution_count": 23, - "id": "0846621f-977c-4334-a263-4fda8b6ad271", + "execution_count": 68, + "id": "fbdb3740-680a-4d92-a89d-caab35ee70b8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "10\n" + "20\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -460,7 +411,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -470,49 +421,279 @@ } ], "source": [ - "cable_vec = np.zeros((20,8))\n", - "oss_vec = np.zeros((20,8))\n", - "total_vec = np.zeros((20,8))\n", - "\n", - "for i in np.arange(8):\n", - " for j in np.arange(20):\n", - " index = 8 * j + i \n", - " cable_vec[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec[j,i] = parametric.results.oss_cost[index]\n", - " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", - "\n", + "cable_vec = np.zeros((40,20))\n", + "oss_vec = np.zeros((40,20))\n", + "total_vec = np.zeros((40,20))\n", "num2 = int(len(cable_vec) / 2)\n", "print(num2)\n", + "for i in np.arange(20):\n", + " for j in np.arange(40):\n", + " index = 20 * j + i \n", + " cable_vec[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", + " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", "\n", + "ind = 10\n", "# Cable Cost\n", - "plt.plot(np.arange(30,330,30), cable_vec[0:num2])\n", - "plt.plot(np.arange(30,330,30), cable_vec[num2:20])\n", + "plt.plot(np.arange(15,315,15), cable_vec[0:num2,ind])\n", + "plt.plot(np.arange(15,315,15), cable_vec[num2:40,ind])\n", "\n", - "plt.legend([\"100 MW\",\"400 MW\",\"700 MW\"], loc = \"lower right\")\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", "plt.ylabel(\"Cable Cost ($)\")\n", + "plt.ylim([0,1.32e9])\n", "plt.show()\n", "\n", "# Substation Cost\n", - "plt.plot(np.arange(30,330,30), oss_vec[0:num2])\n", - "plt.plot(np.arange(30,330,30), oss_vec[num2:20])\n", + "plt.plot(np.arange(15,315,15), oss_vec[0:num2,ind])\n", + "plt.plot(np.arange(15,315,15), oss_vec[num2:40,ind])\n", "\n", - "plt.legend([\"100 MW\",\"400 MW\",\"700 MW\",\"1000 MW\",\"1300 MW\",\"1600 MW\",\"1900 MW\",\"2200 MW\"], loc = \"lower right\")\n", + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", "plt.ylabel(\"Substation Cost ($)\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", + "plt.ylim([0,1.32e9])\n", "plt.show()\n", "\n", - "# # Total Export System Cost\n", - "# plt.plot(np.arange(30,330,30), total_vec[0:num2])\n", - "# plt.plot(np.arange(30,330,30), total_vec[num2:20])\n", + "# Total Export System Cost\n", + "plt.scatter(np.arange(15,315,15), total_vec[0:num2,ind])\n", + "plt.scatter(np.arange(15,315,15), total_vec[num2:40,ind])\n", "\n", - "# plt.legend([\"100 MW\",\"400 MW\",\"700 MW\"], loc = \"lower right\")\n", - "# plt.ylabel(\"Export System Cost ($)\")\n", - "# plt.show()" + "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", + "plt.ylabel(\"Export System Cost ($)\")\n", + "plt.xlabel(\"Distance to Shore (km)\")\n", + "plt.ylim([0,1.32e9])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "13162103-9236-4ba2-9b21-fcca8fc1605c", + "metadata": { + "tags": [] + }, + "source": [ + "# Contour for which is cheaper" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "eca84092-1fba-4b06-a70f-79d818758d77", + "metadata": {}, + "outputs": [], + "source": [ + "cable_vec_ac = np.zeros((20,20))\n", + "oss_vec_ac = np.zeros((20,20))\n", + "total_vec_ac = np.zeros((20,20))\n", + "# dist = np.zeros((20,20))\n", + "\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " index = 20 * j + i \n", + " cable_vec_ac[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec_ac[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", + " total_vec_ac[j,i] = parametric.results.cable_cost[index] + oss_vec_ac[j,i]\n", + "# dist[j,i] = parameters.site.distance_to_landfall[index]\n", + "\n", + "\n", + "\n", + "# plt.colormap" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "198770c5-171b-4134-8091-5a7b4876d6a3", + "metadata": {}, + "outputs": [], + "source": [ + "cable_vec_dc = np.zeros((20,20))\n", + "oss_vec_dc = np.zeros((20,20))\n", + "total_vec_dc = np.zeros((20,20))\n", + "# dist = np.zeros((20,20))\n", + "\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " index = 20 * j + i + 400\n", + " cable_vec_dc[j,i] = parametric.results.cable_cost[index]\n", + " oss_vec_dc[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", + " total_vec_dc[j,i] = parametric.results.cable_cost[index] + oss_vec_dc[j,i]\n", + "# dist[j,i] = parameters.site.distance_to_landfall[index]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "cf33552a-14e3-41ef-a0bf-59b9a29a26ac", + "metadata": {}, + "outputs": [], + "source": [ + "contour_binary = np.zeros((20,20))\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " if total_vec_dc[j,i] < total_vec_ac[j,i]:\n", + " contour_binary[j,i] = 1\n", + "# print(total_vec_dc[j,i])" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "42f80e56-fdc7-4732-878e-c9588aeb8349", + "metadata": {}, + "outputs": [], + "source": [ + "cmap = LinearSegmentedColormap.from_list('custom_div_cmap',['#d73027', '#ffffbf','#1a9641'], 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "0d4a44b7-e89c-402b-925b-634014fe94c9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_binary, cmap=cmap, shading='auto')\n", + "# plt.colorbar()\n", + "plt.xlabel('Plant Capacity (MW)')\n", + "plt.ylabel('Distance to Shore (km)')\n", + "# plt.title('HVDC is cheaper where green')\n", + "plt.title('Cheaper Transmission Type (HVAC v HVDC)')\n", + "plt.rcParams.update({'font.size':10})\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "b5306152-3345-4b33-a53e-14de50ff6913", + "metadata": {}, + "outputs": [], + "source": [ + "contour_cost = np.zeros((20,20))\n", + "for i in np.arange(20):\n", + " for j in np.arange(20):\n", + " if total_vec_dc[j,i] > total_vec_ac[j,i]:\n", + " contour_cost[j,i] = total_vec_ac[j,i]\n", + " else: \n", + " contour_cost[j,i] = total_vec_dc[j,i]\n" + ] + }, + { + "cell_type": "markdown", + "id": "0b768f48-927b-45c3-8f9a-2088323bd732", + "metadata": { + "tags": [] + }, + "source": [ + "# Color Map of Total Cost of Cheaper Option" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "414b80bf-1ace-41d4-8a30-01f623ce4059", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_cost, shading='auto')\n", + "plt.colorbar()\n", + "plt.xlabel('Plant Capacity (MW)')\n", + "plt.ylabel('Distance to Shore (km)')\n", + "# plt.title('HVDC is cheaper where green')\n", + "plt.title('Cheaper Transmission Type Cost (HVAC v HVDC)')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "29ae71b4-2fbc-4cea-885b-201c3f2834e6", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "# Overall Bar Chart" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3b7753e2-b221-45d3-b6d0-d299991eac40", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ind = np.arange(0,20)\n", + "index = 3\n", + "width = 0.4\n", + "plt.figure(figsize=(20,8))\n", + "plant_cap = np.arange(100,2100,100)\n", + "\n", + "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", + "\n", + "cable_data_ac = parametric.results.cable_cost[20*index:20*(index+1)]\n", + "# print(len(parametric.results.cable_cost[20*index:20*(index+1)]))\n", + "substation_data_ac = sub_cost[20*index:20*(index+1)]\n", + "plt.bar(ind,cable_data_ac, width, label = 'ac cable', color = 'lightsteelblue', bottom = substation_data_ac)\n", + "plt.bar(ind,substation_data_ac, width, label = 'ac oss', color = 'cornflowerblue')\n", + "\n", + "cable_data_dc = parametric.results.cable_cost[num+20*index:num+20*(index+1)]\n", + "substation_data_dc = sub_cost[num+20*index:num+20*(index+1)]\n", + "plt.bar(ind+width, cable_data_dc, width, label = 'dc cable', color = 'lightcoral', bottom = substation_data_dc)\n", + "plt.bar(ind+width, substation_data_dc, width, label = 'dc oss', color = 'indianred')\n", + "plant_cap_str = np.char.mod('%d',plant_cap)\n", + "# print(plant_cap)\n", + "\n", + "total_cost = sub_cost + parametric.results.cable_cost\n", + "# plt.plot(ind, total_cost[0+20*index:20*(index+1)], color = 'blue', label = 'HVAC')\n", + "# plt.plot(ind, total_cost[num+20*index:num+20*(index+1)], color = 'red', label = 'HVDC')\n", + "\n", + "plt.xticks(ind,plant_cap_str)\n", + "plt.legend(loc = 'upper left')\n", + "plt.ylabel(\"Project Cost ($)\")\n", + "plt.xlabel(\"Plant Capacity (MW)\")\n", + "plt.rcParams.update({'font.size':10})\n", + "# plt.figure(figsize=(12,5))\n", + "plt.show()\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "fbdb3740-680a-4d92-a89d-caab35ee70b8", + "id": "d116c707-edeb-4e92-a5cb-598237daf19d", "metadata": {}, "outputs": [], "source": [] diff --git a/library/cables/XLPE_1200m_300kV_DC.yaml b/library/cables/XLPE_1200m_300kV_DC.yaml index ecb5b1ef..b19ccd23 100644 --- a/library/cables/XLPE_1200m_300kV_DC.yaml +++ b/library/cables/XLPE_1200m_300kV_DC.yaml @@ -1,7 +1,7 @@ ac_resistance: 0 # ohm/km capacitance: 0 # nF/km conductor_size: 1200 # mm^2 -cost_per_km: 745000 # $ +cost_per_km: 835000 # $ current_capacity: 1458 # A inductance: 0 # mH/km linear_density: 44 # t/km diff --git a/library/cables/XLPE_500mm_132kV.yaml b/library/cables/XLPE_500mm_132kV.yaml index e1363774..e58a7a02 100644 --- a/library/cables/XLPE_500mm_132kV.yaml +++ b/library/cables/XLPE_500mm_132kV.yaml @@ -5,5 +5,6 @@ cost_per_km: 200000 current_capacity: 625 inductance: 0.4 linear_density: 50 +cable_type: HVAC name: XLPE_500mm_132kV rated_voltage: 132 diff --git a/library/cables/XLPE_630mm_66kV.yaml b/library/cables/XLPE_630mm_66kV.yaml index 150a0149..85b92661 100644 --- a/library/cables/XLPE_630mm_66kV.yaml +++ b/library/cables/XLPE_630mm_66kV.yaml @@ -8,3 +8,4 @@ linear_density: 42.5 name: XLPE_630mm_66kV rated_voltage: 66 switchgear_cost: 1e6 +cable_type: HVAC # HVDC vs HVAC From 5fbb691ce90ace4ff19716359ae3cea42b9f392c Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Fri, 10 Dec 2021 14:10:10 -0700 Subject: [PATCH 018/240] atlantic osw project spec spreadsheet, config generator, configs, adn base case df --- ORBIT/phases/design/electrical_export.py | 17 +- ORBIT/phases/design/export_system_design.py | 1 + atlantic_tx_base_case.ipynb | 459 ++++++++ cable_comparison.ipynb | 3 - define_configs.ipynb | 326 ++++++ gut_check_runs.ipynb | 61 +- hvdc_comparison.ipynb | 66 +- library/cables/XLPE_630mm_33kV.yaml | 3 + osw_project_details.xlsx | Bin 0 -> 10551 bytes param_model.ipynb | 1001 +++++++++++++++++ .../Atlantic Shores Offshore Wind 1 base.yaml | 21 + .../Atlantic Shores Offshore Wind 2 base.yaml | 21 + .../Bay State Wind base.yaml | 21 + .../Beacon Wind base.yaml | 21 + .../CVOW Commercial base.yaml | 21 + .../Empire Wind 2 base.yaml | 21 + .../Empire Wind base.yaml | 21 + .../Garden State Offshore Energy base.yaml | 21 + .../Hudson North WEA base.yaml | 21 + .../Hudson South WEA base.yaml | 21 + .../Kitty Hawk base.yaml | 21 + .../Liberty Wind base.yaml | 21 + shared_transmission_configs/MarWin base.yaml | 21 + .../Mayflower Res base.yaml | 21 + .../Mayflower Wind 1 base.yaml | 21 + .../Mayflower Wind 2 base.yaml | 21 + .../Momentum Wind base.yaml | 21 + .../Ocean Wind 1 base.yaml | 21 + .../Ocean Wind 2 base.yaml | 21 + .../Ocean Wind Res base.yaml | 21 + .../Park City Wind base.yaml | 21 + .../Revolution Wind (CT) base.yaml | 21 + .../Revolution Wind (RI) base.yaml | 21 + .../Skipjack base.yaml | 21 + .../South Fork base.yaml | 21 + .../Sunrise Wind base.yaml | 21 + .../TBD SC Lease base.yaml | 21 + shared_transmission_configs/Untitled.ipynb | 694 ++++++++++++ .../Vineyard Wind South base.yaml | 21 + .../Vineyard Wind base.yaml | 21 + shared_transmission_configs/nan base.yaml | 21 + .../data/library/cables/XLPE_630mm_33kV.yaml | 1 + .../library/project/config/export_design.yaml | 2 +- tests/phases/design/test_cable.py | 13 +- tests/phases/design/test_electrical_design.py | 276 +++++ 45 files changed, 3487 insertions(+), 66 deletions(-) create mode 100644 atlantic_tx_base_case.ipynb create mode 100644 define_configs.ipynb create mode 100644 osw_project_details.xlsx create mode 100644 param_model.ipynb create mode 100644 shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml create mode 100644 shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml create mode 100644 shared_transmission_configs/Bay State Wind base.yaml create mode 100644 shared_transmission_configs/Beacon Wind base.yaml create mode 100644 shared_transmission_configs/CVOW Commercial base.yaml create mode 100644 shared_transmission_configs/Empire Wind 2 base.yaml create mode 100644 shared_transmission_configs/Empire Wind base.yaml create mode 100644 shared_transmission_configs/Garden State Offshore Energy base.yaml create mode 100644 shared_transmission_configs/Hudson North WEA base.yaml create mode 100644 shared_transmission_configs/Hudson South WEA base.yaml create mode 100644 shared_transmission_configs/Kitty Hawk base.yaml create mode 100644 shared_transmission_configs/Liberty Wind base.yaml create mode 100644 shared_transmission_configs/MarWin base.yaml create mode 100644 shared_transmission_configs/Mayflower Res base.yaml create mode 100644 shared_transmission_configs/Mayflower Wind 1 base.yaml create mode 100644 shared_transmission_configs/Mayflower Wind 2 base.yaml create mode 100644 shared_transmission_configs/Momentum Wind base.yaml create mode 100644 shared_transmission_configs/Ocean Wind 1 base.yaml create mode 100644 shared_transmission_configs/Ocean Wind 2 base.yaml create mode 100644 shared_transmission_configs/Ocean Wind Res base.yaml create mode 100644 shared_transmission_configs/Park City Wind base.yaml create mode 100644 shared_transmission_configs/Revolution Wind (CT) base.yaml create mode 100644 shared_transmission_configs/Revolution Wind (RI) base.yaml create mode 100644 shared_transmission_configs/Skipjack base.yaml create mode 100644 shared_transmission_configs/South Fork base.yaml create mode 100644 shared_transmission_configs/Sunrise Wind base.yaml create mode 100644 shared_transmission_configs/TBD SC Lease base.yaml create mode 100644 shared_transmission_configs/Untitled.ipynb create mode 100644 shared_transmission_configs/Vineyard Wind South base.yaml create mode 100644 shared_transmission_configs/Vineyard Wind base.yaml create mode 100644 shared_transmission_configs/nan base.yaml create mode 100644 tests/phases/design/test_electrical_design.py diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 6850234b..5c86c3f2 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -263,11 +263,10 @@ def substation_cost(self): """Returns total procuremet cost of the topside.""" return ( - (self.mpt_cost + self.mpt_cost + self.shunt_reactor_cost + self.switchgear_costs + self.converter_cost - ) / self.num_substations + self.topside_cost + self.ancillary_system_cost + self.land_assembly_cost @@ -327,7 +326,7 @@ def calc_ancillary_system_cost(self): other_ancillary_cost = self._design.get("other_ancillary_cost", 3e6) self.ancillary_system_cost = ( - backup_gen_cost + workspace_cost + other_ancillary_cost + (backup_gen_cost + workspace_cost + other_ancillary_cost) * self.num_substations ) def calc_converter_cost(self): @@ -353,8 +352,8 @@ def calc_assembly_cost(self): _design = self.config.get("substation_design", {}) topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) self.land_assembly_cost = ( - self.switchgear_costs / self.num_substations - + self.shunt_reactor_cost / self.num_substations + self.switchgear_costs + + self.shunt_reactor_cost + self.ancillary_system_cost ) * topside_assembly_factor @@ -379,7 +378,7 @@ def calc_substructure_mass_and_cost(self): self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate - ) + ) * self.num_substations self.substructure_mass = substructure_mass + substructure_pile_mass @@ -410,8 +409,8 @@ def calc_topside_deck_space(self): def calc_topside_mass_and_cost(self): """ - Calculates the mass and cost of the substation topsides. - + Calculates the mass and cost of the substation topsides. + Parameters ---------- topside_fab_cost_rate : int | float @@ -424,7 +423,7 @@ def calc_topside_mass_and_cost(self): self.topside_mass = 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 self.topside_cost = ( - self.topside_mass * topside_fab_cost_rate + topside_design_cost + (self.topside_mass * topside_fab_cost_rate + topside_design_cost) * self.num_substations ) diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 6c6ae0a0..23aaf27e 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -1,3 +1,4 @@ + """Provides the `ExportSystemDesign` class.""" __author__ = "Rob Hammond" diff --git a/atlantic_tx_base_case.ipynb b/atlantic_tx_base_case.ipynb new file mode 100644 index 00000000..d488615e --- /dev/null +++ b/atlantic_tx_base_case.ipynb @@ -0,0 +1,459 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "0439fc41-2ead-4ff6-b959-3155b776a2fd", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "38aa8c32-937e-41c8-ab52-f58bd9649eb9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + " 'distance_to_landfall': 60\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10,\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': 'XLPE_500mm_220kV',\n", + " }\n", + " \n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "7f7a9a85-4da3-4077-a1ad-a5ea448c08d1", + "metadata": {}, + "source": [ + "## Low Cap" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "96b81f59-4f64-4f6f-ac65-78f3e2de1725", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + "# 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e6db2414-3a88-45f3-920f-74d87891724e", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "456ea826-43c6-437c-a0a1-ff9c0809f38c", + "metadata": { + "tags": [] + }, + "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", + "
plant.capacitycable_costoss_cost
010041908300.03.894692e+07
120041908300.04.620032e+07
230083816600.06.972274e+07
340083816600.07.697614e+07
4500125724900.01.004986e+08
5600125724900.01.077520e+08
6700125724900.01.150054e+08
7800167633200.01.385278e+08
8900167633200.01.612057e+08
91000209541500.01.847281e+08
101100209541500.01.907726e+08
111200209541500.01.998393e+08
121300251449800.02.227573e+08
131400251449800.02.300107e+08
141500293358100.02.547420e+08
151600293358100.02.589732e+08
161700293358100.02.828600e+08
171800335266400.03.069869e+08
181900335266400.03.118225e+08
192000377174700.03.395760e+08
\n", + "
" + ], + "text/plain": [ + " plant.capacity cable_cost oss_cost\n", + "0 100 41908300.0 3.894692e+07\n", + "1 200 41908300.0 4.620032e+07\n", + "2 300 83816600.0 6.972274e+07\n", + "3 400 83816600.0 7.697614e+07\n", + "4 500 125724900.0 1.004986e+08\n", + "5 600 125724900.0 1.077520e+08\n", + "6 700 125724900.0 1.150054e+08\n", + "7 800 167633200.0 1.385278e+08\n", + "8 900 167633200.0 1.612057e+08\n", + "9 1000 209541500.0 1.847281e+08\n", + "10 1100 209541500.0 1.907726e+08\n", + "11 1200 209541500.0 1.998393e+08\n", + "12 1300 251449800.0 2.227573e+08\n", + "13 1400 251449800.0 2.300107e+08\n", + "14 1500 293358100.0 2.547420e+08\n", + "15 1600 293358100.0 2.589732e+08\n", + "16 1700 293358100.0 2.828600e+08\n", + "17 1800 335266400.0 3.069869e+08\n", + "18 1900 335266400.0 3.118225e+08\n", + "19 2000 377174700.0 3.395760e+08" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parametric_low = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric_low.run()\n", + "parametric_low.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "795c19de-6ef9-474e-9760-2f82d9cd9efc", + "metadata": {}, + "outputs": [], + "source": [ + "model_low = parametric_low.create_model([\"plant.capacity\"],'oss_cost')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9c0261f6-2ddc-4112-8626-ac9e1f895fef", + "metadata": {}, + "outputs": [], + "source": [ + "# model.perc_diff" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c17f27b8-b759-470b-b32a-848bec83add6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(model_low.predict(parameters))\n", + "plt.plot(parametric_low.results.oss_cost)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a69666b1-700f-4a80-a32a-0ecb46a9e9ab", + "metadata": {}, + "source": [ + "## Med Cap" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f7bbca3c-a54d-4ac8-8c54-159a6a08e580", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + "# 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(900,1700,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "18160b8a-dc10-4077-9923-a401da5b43db", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "27e83fbc-4bca-441c-894e-10be33a4e6bb", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parametric_med = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric_med.run()\n", + "# parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "76a3f864-8294-4df1-979a-86f3e330c62c", + "metadata": {}, + "outputs": [], + "source": [ + "model_med = parametric_med.create_model([\"plant.capacity\"],'oss_cost')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "f2f9dfd2-0584-4d97-a261-c5ad024903ad", + "metadata": {}, + "outputs": [], + "source": [ + "# model1.predict(parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "afce23f8-2eac-4184-a275-4dacf4541d18", + "metadata": {}, + "outputs": [], + "source": [ + "# model1.perc_diff" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c71303b7-d2d2-459c-a783-1c486aaf2e6d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(model_med.predict(parameters))\n", + "plt.plot(parametric_med.results.oss_cost)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1a082a1-6d64-4b91-a394-ca759d1f32e1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cable_comparison.ipynb b/cable_comparison.ipynb index 9df7fc58..2217d784 100644 --- a/cable_comparison.ipynb +++ b/cable_comparison.ipynb @@ -18,9 +18,6 @@ "execution_count": 2, "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", "metadata": { - "jupyter": { - "source_hidden": true - }, "tags": [] }, "outputs": [], diff --git a/define_configs.ipynb b/define_configs.ipynb new file mode 100644 index 00000000..40b9c58e --- /dev/null +++ b/define_configs.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "23ea6c69-4587-48a5-a1ac-b03074bde7c5", + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy\n", + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "0fb9f171-4f25-4d8c-b12b-b5606a9d3afe", + "metadata": {}, + "source": [ + "### Example: Bay State Wind" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0fc89ffb-5881-4c91-bff1-446a29d0b18d", + "metadata": {}, + "outputs": [], + "source": [ + "base = {\n", + " \"site\": {\n", + " \"distance\": 65,\n", + " \"depth\": 43,\n", + " \"distance_to_landfall\": 33\n", + " },\n", + " \"plant\": {\n", + " \"capacity\": 2277\n", + " },\n", + " \"turbine\": {\n", + " \"turbine_rating\": 15\n", + " },\n", + " \"install_phases\": [\n", + " \"ExportCableInstallation\",\n", + " \"ArrayCableInstallation\",\n", + " \"OffshoreSubstationInstallation\"\n", + " ],\n", + " \"design_phases\": [\n", + " \"ElectricalDesign\"\n", + " ],\n", + " \"array_system\": {\n", + " \"cables\": [\"XPLE_630mm_66kV\"],\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dc607c35-6e45-498b-8434-76c465f4c04c", + "metadata": {}, + "outputs": [], + "source": [ + "standard_base = {\n", + " **base,\n", + " \"export_system_design\": {\n", + " \"cables\": [\"XPLE_500mm_220kV\"],\n", + " }\n", + "}\n", + "\n", + "backbone_base = {\n", + " **base,\n", + " \"export_system_design\": {\n", + " \"cables\": [\"XPLE_500mm_220kV\"],\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "54233cfc-8237-40c0-96e6-9c287e997b5c", + "metadata": {}, + "outputs": [], + "source": [ + "standard_configs = []\n", + "backbone_configs = []\n", + "\n", + "for i in range(10,100,10):\n", + " \n", + " sconfig = deepcopy(standard_base)\n", + " sconfig[\"site\"][\"distance_to_landfall\"] = i\n", + "\n", + " standard_configs.append(sconfig)\n", + "\n", + " \n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5a8763bf-df12-41ae-9b52-b5bfb52145cd", + "metadata": {}, + "outputs": [], + "source": [ + "# standard_configs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "61d1f971-66c5-43ea-8622-850135382a13", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import load_config, save_config" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c0840454-6ef6-43f7-a65b-9d6ece99b13e", + "metadata": {}, + "outputs": [], + "source": [ + "# for config in standard_configs:\n", + "# dist = str(config[\"site\"][\"distance_to_landfall\"])\n", + "# filename = \"bay_state_%sm\" % dist\n", + "# print(filename)\n", + "# save_config(config, \"C:/Users/sbredenk/ORBIT/shared_transmission_configs/%s.yaml\" % filename, overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8f599f36-f68e-4f22-87a9-3497ff54b771", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function save_config in module ORBIT.config:\n", + "\n", + "save_config(config, filepath, overwrite=False)\n", + " Save an ORBIT `config` to `filepath`.\n", + " \n", + " Parameters\n", + " ----------\n", + " config : dict\n", + " ORBIT configuration.\n", + " filepath : str\n", + " Location to save config.\n", + " overwrite : bool (optional)\n", + " Overwrite file if it already exists. Default: False.\n", + "\n" + ] + } + ], + "source": [ + "help(save_config)" + ] + }, + { + "cell_type": "markdown", + "id": "bfb4726a-4123-4177-9663-55e9628afb07", + "metadata": {}, + "source": [ + "### Save Base Cases" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6e3c934e-8993-47fd-b7d8-387d5c36c4d0", + "metadata": {}, + "outputs": [], + "source": [ + "base = {\n", + " \"site\": {\n", + " \"distance\": 65,\n", + " \"depth\": 43,\n", + " \"distance_to_landfall\": 33\n", + " },\n", + " \"plant\": {\n", + " \"capacity\": 2277\n", + " },\n", + " \"turbine\": {\n", + " \"turbine_rating\": 15\n", + " },\n", + " \"install_phases\": {\n", + " \"ExportCableInstallation\",\n", + "# \"ArrayCableInstallation\",\n", + " \"OffshoreSubstationInstallation\"\n", + " },\n", + " \"export_cable_install_vessel\": \"example_cable_lay_vessel\",\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " \"design_phases\": {\n", + " \"ElectricalDesign\"\n", + " },\n", + " \"array_system\": {\n", + " \"cables\": [\"XLPE_630mm_66kV\"],\n", + " },\n", + " \"export_system_design\": {\n", + " \"cables\": \"XLPE_630mm_220kV\",\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "632b2056-28e7-45ee-9a87-b055c2d9792e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[15, 15, 12, 15, 15, 15, 15, 8, 11, 11, 12, 12, 15, 15, 15, 12, 14, 10, 12, 12, 15, 15, 15, 15, 15, 15, 15, 15, 15]\n" + ] + } + ], + "source": [ + "df = pd.read_excel(\"C:/Users/sbredenk/ORBIT/osw_project_details.xlsx\",sheet_name=0)\n", + "proj_name = df['name'].to_list()\n", + "cap = df['capacity'].to_list()\n", + "turbine_rating = df['turbine'].to_list()\n", + "distance = df['distance_to_site_(km)'].to_list()\n", + "distance_to_landfall = df['distance_to_shore'].to_list()\n", + "print(turbine_rating)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "bd832314-03dc-4b90-8254-93c38269d836", + "metadata": {}, + "outputs": [], + "source": [ + "# help(pd.read_excel)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1761dd4e-3b43-4d60-8435-0eca1a9753b8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'site': {'distance': 668, 'depth': 43, 'distance_to_landfall': nan}, 'plant': {'capacity': 400}, 'turbine': {'turbine_rating': 15}, 'install_phases': {'OffshoreSubstationInstallation', 'ExportCableInstallation'}, 'export_cable_install_vessel': 'example_cable_lay_vessel', 'oss_install_vessel': 'example_heavy_lift_vessel', 'feeder': 'future_feeder', 'design_phases': {'ElectricalDesign'}, 'array_system': {'cables': ['XLPE_630mm_66kV']}, 'export_system_design': {'cables': 'XLPE_630mm_220kV'}}\n" + ] + } + ], + "source": [ + "# Save base config for each project\n", + "base_configs = []\n", + "filename = deepcopy(proj_name)\n", + "for i in range(0,len(proj_name)):\n", + " filename[i] = \"%s base.yaml\" % proj_name[i]\n", + " b_config = deepcopy(base)\n", + " b_config[\"plant\"][\"capacity\"] = cap[i]\n", + " b_config[\"turbine\"][\"turbine_rating\"] = turbine_rating[i]\n", + " b_config[\"site\"][\"distance\"] = distance[i]\n", + " b_config[\"site\"][\"distance_to_landfall\"] = distance_to_landfall[i]\n", + " \n", + " save_config(b_config, \"C:/Users/sbredenk/ORBIT/shared_transmission_configs/%s\" % filename[i], overwrite = True) \n", + "print(b_config) " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "29eca601-511f-41ec-ad6c-7ca673324c00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Bay State Wind', 'Park City Wind', 'Vineyard Wind', 'Beacon Wind', 'Mayflower Wind 1', 'Mayflower Wind 2', 'Liberty Wind', 'Sunrise Wind', 'Revolution Wind (CT)', 'Revolution Wind (RI)', 'South Fork', 'Empire Wind', 'Empire Wind 2', 'Atlantic Shores Offshore Wind 1', 'Atlantic Shores Offshore Wind 2', 'Ocean Wind 1', 'Ocean Wind 2', 'Garden State Offshore Energy', 'Skipjack', 'MarWin', 'CVOW Commercial', 'Kitty Hawk', 'Vineyard Wind South', 'Mayflower Res', 'Ocean Wind Res', 'Hudson North WEA', 'Hudson South WEA', 'Momentum Wind', 'TBD SC Lease']\n", + "['Bay State Wind base.yaml', 'Park City Wind base.yaml', 'Vineyard Wind base.yaml', 'Beacon Wind base.yaml', 'Mayflower Wind 1 base.yaml', 'Mayflower Wind 2 base.yaml', 'Liberty Wind base.yaml', 'Sunrise Wind base.yaml', 'Revolution Wind (CT) base.yaml', 'Revolution Wind (RI) base.yaml', 'South Fork base.yaml', 'Empire Wind base.yaml', 'Empire Wind 2 base.yaml', 'Atlantic Shores Offshore Wind 1 base.yaml', 'Atlantic Shores Offshore Wind 2 base.yaml', 'Ocean Wind 1 base.yaml', 'Ocean Wind 2 base.yaml', 'Garden State Offshore Energy base.yaml', 'Skipjack base.yaml', 'MarWin base.yaml', 'CVOW Commercial base.yaml', 'Kitty Hawk base.yaml', 'Vineyard Wind South base.yaml', 'Mayflower Res base.yaml', 'Ocean Wind Res base.yaml', 'Hudson North WEA base.yaml', 'Hudson South WEA base.yaml', 'Momentum Wind base.yaml', 'TBD SC Lease base.yaml']\n" + ] + } + ], + "source": [ + "print(proj_name)\n", + "print(filename)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7fe29d7f-f3f4-4b32-b3e3-7e0227753509", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gut_check_runs.ipynb b/gut_check_runs.ipynb index 919f0217..fc601cae 100644 --- a/gut_check_runs.ipynb +++ b/gut_check_runs.ipynb @@ -10,7 +10,7 @@ "outputs": [], "source": [ "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import Cable\n", + "from ORBIT.phases.design import ElectricalDesign\n", "import numpy as np\n", "import matplotlib.pyplot as plt" ] @@ -30,7 +30,7 @@ " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", " 'feeder': 'future_feeder',\n", " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", + " 'cables': \"XLPE_630mm_33kV\",\n", "# 'num_redundant': 'int (optional)',\n", "# 'touchdown_distance': 'm (optional, default: 0)',\n", "# 'percent_added_length': 'float (optional)'\n", @@ -76,9 +76,9 @@ { "data": { "text/plain": [ - "{'Export System': 105802830.0,\n", - " 'Offshore Substation': 100262247.06430578,\n", - " 'Export System Installation': 114117083.59143695,\n", + "{'Export System': 357979500.0,\n", + " 'Offshore Substation': 83517917.74312852,\n", + " 'Export System Installation': 132656741.80730619,\n", " 'Offshore Substation Installation': 3126797.6636225265,\n", " 'Turbine': 777140000.0,\n", " 'Soft': 385580999.99999994,\n", @@ -105,19 +105,19 @@ { "data": { "text/plain": [ - "{'export_system': {'system_cost': 105802830.0,\n", - " 'cable': {'linear_density': 90,\n", + "{'export_system': {'system_cost': 357979500.0,\n", + " 'cable': {'linear_density': 42.5,\n", " 'sections': [53.034],\n", - " 'number': 3,\n", - " 'cable_power': 249.5885151507681}},\n", + " 'number': 15,\n", + " 'cable_power': 40.01037362112721}},\n", " 'offshore_substation_substructure': {'type': 'Monopile',\n", " 'deck_space': 1,\n", - " 'mass': 1588.3736050922225,\n", + " 'mass': 1698.496367544677,\n", " 'length': 44,\n", - " 'unit_cost': 3529800.0000000005},\n", + " 'unit_cost': 3807000.0},\n", " 'offshore_substation_topside': {'deck_space': 1,\n", - " 'mass': 2941.5,\n", - " 'unit_cost': 96732447.06430578},\n", + " 'mass': 3172.5,\n", + " 'unit_cost': 79710917.74312852},\n", " 'num_substations': 1}" ] }, @@ -140,10 +140,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "electrical system: 40487857.73423793\n", - "structure: 50681550.0\n", + "electrical system: 23003179.295933507\n", + "structure: 54308250.0\n", "facility: 6000000.0\n", - "land assembly: 3092839.3300678446\n" + "land assembly: 206488.4471950132\n" ] } ], @@ -168,24 +168,43 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "ca180f7b-6a49-44b1-a082-316783101acd", "metadata": {}, "outputs": [], "source": [ - "design = Cable(config)\n", + "design = ElectricalDesign(config)\n", "design.run()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "38e3babe-2b1d-4fec-afa6-e1b212ccb904", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "40.01037362112721" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "design.cable.compensation" + "design.cable.cable_power" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb3857d3-6cd8-49e4-b40d-885ea746b19d", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/hvdc_comparison.ipynb b/hvdc_comparison.ipynb index e26858db..feca9925 100644 --- a/hvdc_comparison.ipynb +++ b/hvdc_comparison.ipynb @@ -179,7 +179,7 @@ " 300\n", " 1600\n", " 506043400.0\n", - " 2.053356e+08\n", + " 4.106711e+08\n", " 2\n", " \n", " \n", @@ -188,7 +188,7 @@ " 300\n", " 1700\n", " 506043400.0\n", - " 1.441509e+08\n", + " 4.324526e+08\n", " 3\n", " \n", " \n", @@ -197,7 +197,7 @@ " 300\n", " 1800\n", " 759065100.0\n", - " 1.924958e+08\n", + " 5.774874e+08\n", " 3\n", " \n", " \n", @@ -206,7 +206,7 @@ " 300\n", " 1900\n", " 759065100.0\n", - " 1.947288e+08\n", + " 5.841864e+08\n", " 3\n", " \n", " \n", @@ -215,7 +215,7 @@ " 300\n", " 2000\n", " 759065100.0\n", - " 1.969618e+08\n", + " 5.908854e+08\n", " 3\n", " \n", " \n", @@ -244,11 +244,11 @@ "3 30634000.0 5.468484e+07 1 \n", "4 30634000.0 6.138384e+07 1 \n", ".. ... ... ... \n", - "795 506043400.0 2.053356e+08 2 \n", - "796 506043400.0 1.441509e+08 3 \n", - "797 759065100.0 1.924958e+08 3 \n", - "798 759065100.0 1.947288e+08 3 \n", - "799 759065100.0 1.969618e+08 3 \n", + "795 506043400.0 4.106711e+08 2 \n", + "796 506043400.0 4.324526e+08 3 \n", + "797 759065100.0 5.774874e+08 3 \n", + "798 759065100.0 5.841864e+08 3 \n", + "799 759065100.0 5.908854e+08 3 \n", "\n", "[800 rows x 6 columns]" ] @@ -278,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 6, "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", "metadata": {}, "outputs": [ @@ -291,7 +291,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -301,7 +301,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -311,7 +311,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -378,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 7, "id": "fbdb3740-680a-4d92-a89d-caab35ee70b8", "metadata": {}, "outputs": [ @@ -391,7 +391,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -401,7 +401,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -411,7 +411,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -477,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 8, "id": "eca84092-1fba-4b06-a70f-79d818758d77", "metadata": {}, "outputs": [], @@ -502,7 +502,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 9, "id": "198770c5-171b-4134-8091-5a7b4876d6a3", "metadata": {}, "outputs": [], @@ -523,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 10, "id": "cf33552a-14e3-41ef-a0bf-59b9a29a26ac", "metadata": {}, "outputs": [], @@ -538,7 +538,7 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 11, "id": "42f80e56-fdc7-4732-878e-c9588aeb8349", "metadata": {}, "outputs": [], @@ -548,13 +548,13 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 12, "id": "0d4a44b7-e89c-402b-925b-634014fe94c9", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -576,18 +576,22 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 16, "id": "b5306152-3345-4b33-a53e-14de50ff6913", "metadata": {}, "outputs": [], "source": [ "contour_cost = np.zeros((20,20))\n", + "MWcap = np.arange(100,2100,100)\n", "for i in np.arange(20):\n", " for j in np.arange(20):\n", " if total_vec_dc[j,i] > total_vec_ac[j,i]:\n", " contour_cost[j,i] = total_vec_ac[j,i]\n", " else: \n", - " contour_cost[j,i] = total_vec_dc[j,i]\n" + " contour_cost[j,i] = total_vec_dc[j,i]\n", + "\n", + "for i in np.arange(20):\n", + " contour_cost[:,i] = contour_cost[:,i] / MWcap[i]" ] }, { @@ -602,13 +606,13 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 26, "id": "414b80bf-1ace-41d4-8a30-01f623ce4059", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -619,11 +623,12 @@ ], "source": [ "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_cost, shading='auto')\n", - "plt.colorbar()\n", + "plt.colorbar(label='$/kW')\n", "plt.xlabel('Plant Capacity (MW)')\n", "plt.ylabel('Distance to Shore (km)')\n", "# plt.title('HVDC is cheaper where green')\n", "plt.title('Cheaper Transmission Type Cost (HVAC v HVDC)')\n", + "# plt.colorbar.set_ylabel('# of contacts', rotation=270)\n", "plt.show()" ] }, @@ -631,7 +636,6 @@ "cell_type": "markdown", "id": "29ae71b4-2fbc-4cea-885b-201c3f2834e6", "metadata": { - "jp-MarkdownHeadingCollapsed": true, "tags": [] }, "source": [ @@ -646,7 +650,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABl4AAAK2CAYAAAAv7+HrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB2pElEQVR4nOzdeZyXZb0//tewDZuA7KAouOEOqEW4pB0nQY0j5TEjjSWX48JRI1ExE7GFzFwLtdxtQ03Fvi6oUWASLqi4pKnYJC6ASwqCCgqf3x/9nNMcGBa9mWGY5/PxuB/5ue7rc13v++Ljp3FeXPddViqVSgEAAAAAAOBTa1TXBQAAAAAAAGwsBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvKzB/fffn8GDB6d79+4pKyvL5MmT13mMm266KX379k3Lli2z5ZZb5vzzzy++UAAAAAAAoM4JXtZgyZIl6dOnTyZOnPiJ3n/33XfniCOOyHHHHZenn346l112WS666KL87Gc/K7hSAAAAAACgrpWVSqVSXRdRX5SVleW2227LkCFDqtqWLl2a73znO/ntb3+bd955JzvvvHPOO++87LfffkmSr3/96/nwww9z8803V73npz/9aX784x9n7ty5KSsrq+WrAAAAAAAA1hc7Xj6lUaNGZebMmZk0aVKefPLJHHbYYRk0aFBeeOGFJP8KZpo3b17tPS1atMgrr7ySl156qS5KBgAAAAAA1hPBy6cwd+7cXHvttbn55puzzz77ZOutt86pp56avffeO9dee22SZODAgbn11lszderUrFixIs8//3wuuOCCJMm8efPqsnwAAAAAAKBgTeq6gPrsqaeeyvLly7PddttVa1+6dGk6dOiQJDnmmGPy4osv5ktf+lI+/PDDtGnTJieffHLOOeecNGok9wIAAAAAgI2J4OVTWLx4cRo3bpxHH300jRs3rnaudevWSf71XJjzzjsvP/zhDzN//vx06tQpU6dOTZJstdVWtV4zAAAAAACw/ghePoV+/fpl+fLlef3117PPPvustm/jxo2z2WabJUl++9vfZsCAAenUqVNtlAkAAAAAANQSwcsaLF68OHPmzKl6XVlZmdmzZ6d9+/bZbrvtcsQRR2TYsGG54IIL0q9fv7zxxhuZOnVqdt111xx88MF5880387vf/S777bdfPvjgg6pnwkyfPr0OrwoAAAAAAFgfykqlUqmui9iQTZs2LV/4whdWah8+fHiuu+66fPjhh/n+97+fG264Ia+++mo6duyYz33ucxk/fnx22WWXvPnmmxk8eHCeeuqplEqlDBgwID/4wQ/Sv3//OrgaAAAAAABgfRK8AAAAAAAAFKRRXRcAAAAAAACwsRC8AAAAAAAAFKRJXRewIVqxYkVee+21bLLJJikrK6vrcgAAAAAAgDpUKpXy7rvvpnv37mnUaPV7WgQvq/Daa6+lR48edV0GAAAAAACwAXn55Zez+eabr7aP4GUVNtlkkyT/WsA2bdrUcTUAAAAAAEBdWrRoUXr06FGVH6yO4GUVPr69WJs2bQQvAAAAAABAkqzV40lWfyMyAAAAAAAA1lqdBi8TJkzIZz7zmWyyySbp3LlzhgwZkueee26N77v55puz/fbbp3nz5tlll11y1113VTtfKpVy9tlnp1u3bmnRokUqKirywgsvrK/LAAAAAAAASFLHwcv06dNz4okn5sEHH8x9992XDz/8MAcccECWLFlS43v+8pe/ZOjQoTnqqKPy+OOPZ8iQIRkyZEiefvrpqj4//vGPc+mll+aKK67IQw89lFatWmXgwIH54IMPauOyAAAAAACABqqsVCqV6rqIj73xxhvp3Llzpk+fns9//vOr7HP44YdnyZIlueOOO6raPve5z6Vv37654oorUiqV0r1793z729/OqaeemiRZuHBhunTpkuuuuy5f+9rX1ljHokWL0rZt2yxcuLDGZ7yUSqV89NFHWb58+Se4UmpL06ZN07hx47ouAwAAAACAemxtcoOPNamlmtbKwoULkyTt27evsc/MmTMzevToam0DBw7M5MmTkySVlZWZP39+Kioqqs63bds2/fv3z8yZM1cZvCxdujRLly6ter1o0aLV1rls2bLMmzcv77333hqvibpVVlaWzTffPK1bt67rUgAAAAAAaAA2mOBlxYoVOeWUU7LXXntl5513rrHf/Pnz06VLl2ptXbp0yfz586vOf9xWU5//a8KECRk/fvxa11lZWZnGjRune/fuadasWcrKytbqvdSuUqmUN954I6+88kq23XZbO18AAAAAAFjvNpjg5cQTT8zTTz+dBx54oNbnHjt2bLVdNIsWLUqPHj1W2XfZsmVZsWJFevTokZYtW9ZWiXxCnTp1yj/+8Y98+OGHghcAAAAAANa7DSJ4GTVqVO64447cf//92XzzzVfbt2vXrlmwYEG1tgULFqRr165V5z9u69atW7U+ffv2XeWY5eXlKS8vX6eaGzVqtE79qRt2IwEAAAAAUJvqND0olUoZNWpUbrvttvzxj39Mr1691vieAQMGZOrUqdXa7rvvvgwYMCBJ0qtXr3Tt2rVan0WLFuWhhx6q6gMAAAAAALA+1OmOlxNPPDG/+c1vcvvtt2eTTTapegZL27Zt06JFiyTJsGHDstlmm2XChAlJkpNPPjn77rtvLrjgghx88MGZNGlSZs2alV/84hdJ/rXD4ZRTTsn3v//9bLvttunVq1e++93vpnv37hkyZEidXCcAAAAAANAw1GnwcvnllydJ9ttvv2rt1157bUaMGJEkmTt3brXbeu255575zW9+k7POOitnnnlmtt1220yePDk777xzVZ/TTjstS5YsybHHHpt33nkne++9d6ZMmZLmzZuv1+u5fUbleh3/3x2y15p3B23oevbsmVNOOSWnnHJKjX3Kyspy2223Cc0AAAAAAKgX6jR4KZVKa+wzbdq0ldoOO+ywHHbYYTW+p6ysLOeee27OPffcT1MeAAAAAADAOvGEeAAAAAAAgIIIXhqIKVOmZO+99067du3SoUOHfOlLX8qLL75Yrc8rr7ySoUOHpn379mnVqlX22GOPPPTQQzWOubr+L774Yg455JB06dIlrVu3zmc+85n84Q9/WGmMd999N0OHDk2rVq2y2WabZeLEiau9jpdffjlf/epX065du7Rv3z6HHHJI/vGPf6z7ggAAAAAAwHogeGkglixZktGjR2fWrFmZOnVqGjVqlC9/+ctZsWJFkmTx4sXZd9998+qrr+b3v/99nnjiiZx22mlV5/+vNfVfvHhxDjrooEydOjWPP/54Bg0alMGDB2fu3LnVxjn//PPTp0+fPP744znjjDNy8skn57777lvlnB9++GEGDhyYTTbZJH/+858zY8aMtG7dOoMGDcqyZcsKXC0AAAAAAPhk6vQZL9SeQw89tNrra665Jp06dcozzzyTnXfeOb/5zW/yxhtv5JFHHkn79u2TJNtss02N462pf58+fdKnT5+q19/73vdy22235fe//31GjRpV1b7XXnvljDPOSJJst912mTFjRi666KJ88YtfXGnOG2+8MStWrMhVV12VsrKyJMm1116bdu3aZdq0aTnggAPWdVkAAAAAAKBQdrw0EC+88EKGDh2arbbaKm3atEnPnj2TpGoHyuzZs9OvX7+qEGVN1tR/8eLFOfXUU7PDDjukXbt2ad26dZ599tmVdrwMGDBgpdfPPvvsKsd84oknMmfOnGyyySZp3bp1Wrdunfbt2+eDDz5Y6bZpAAAAAABQF+x4aSAGDx6cLbfcMldeeWW6d++eFStWZOedd666RVeLFi3Wabw19T/11FNz33335Sc/+Um22WabtGjRIv/1X//1qW4Jtnjx4uy+++759a9/vdK5Tp06feJxAQAAAACgKIKXBuCtt97Kc889lyuvvDL77LNPkuSBBx6o1mfXXXfNVVddlX/+859rtetlTf1nzJiRESNG5Mtf/nKSf4Um//jHP1bq9+CDD670eocddljlnLvttltuvPHGdO7cOW3atFljjQAAAAAAUNvcaqwB2HTTTdOhQ4f84he/yJw5c/LHP/4xo0ePrtZn6NCh6dq1a4YMGZIZM2bk73//e2655ZbMnDlzlWOuqf+2226bW2+9NbNnz84TTzyRr3/961mxYsVK48yYMSM//vGP8/zzz2fixIm5+eabc/LJJ69yziOOOCIdO3bMIYcckj//+c+prKzMtGnTctJJJ+WVV175lKsEAAAAAACfnh0vBTpkr151XcIqNWrUKJMmTcpJJ52UnXfeOb17986ll16a/fbbr6pPs2bNcu+99+bb3/52DjrooHz00UfZcccdM3HixFWOuab+F154Yb75zW9mzz33TMeOHXP66adn0aJFK43z7W9/O7Nmzcr48ePTpk2bXHjhhRk4cOAq52zZsmXuv//+nH766fnKV76Sd999N5tttln2339/O2AAAAAAANgglJVKpVJdF7GhWbRoUdq2bZuFCxeu9Av9Dz74IJWVlenVq1eaN29eRxWytvx5AQAAAADwaa0uN/i/3GoMAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKEiTui4AAAAAAABYtYXjx9f6nG3Hjav1OTcmdrwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABWlS1wVsTI657J+1NteVJ7SvtbkAAAAAAIC1I3gBAAAAAKBOLRw/vlbnaztuXK3OR8PiVmMAAAAAAAAFEbw0EFOmTMnee++ddu3apUOHDvnSl76UF198sVqfV155JUOHDk379u3TqlWr7LHHHnnooYdqHPOpp57Kf/zHf6RFixbp0KFDjj322CxevLjq/LRp0/LZz342rVq1Srt27bLXXnvlpZdeSpI88cQT+cIXvpBNNtkkbdq0ye67755Zs2atn4sHAAAAAIBaInhpIJYsWZLRo0dn1qxZmTp1aho1apQvf/nLWbFiRZJk8eLF2XffffPqq6/m97//fZ544omcdtppVedXNd7AgQOz6aab5pFHHsnNN9+cP/zhDxk1alSS5KOPPsqQIUOy77775sknn8zMmTNz7LHHpqysLElyxBFHZPPNN88jjzySRx99NGeccUaaNm1aO4sBAAAAAADriWe8NBCHHnpotdfXXHNNOnXqlGeeeSY777xzfvOb3+SNN97II488kvbt2ydJttlmmxrH+81vfpMPPvggN9xwQ1q1apUk+dnPfpbBgwfnvPPOS9OmTbNw4cJ86UtfytZbb50k2WGHHareP3fu3IwZMybbb799kmTbbbct9HoBAAAAAKAu2PHSQLzwwgsZOnRottpqq7Rp0yY9e/ZM8q8AJElmz56dfv36VYUua/Lss8+mT58+VaFLkuy1115ZsWJFnnvuubRv3z4jRozIwIEDM3jw4FxyySWZN29eVd/Ro0fn6KOPTkVFRX70ox+tdNszAAAAAACoj+x4aSAGDx6cLbfcMldeeWW6d++eFStWZOedd86yZcuSJC1atCh8zmuvvTYnnXRSpkyZkhtvvDFnnXVW7rvvvnzuc5/LOeeck69//eu58847c/fdd2fcuHGZNGlSvvzlLxdeBwAAAABsCBaOH1+r87UdN65W5wP+xY6XBuCtt97Kc889l7POOiv7779/dthhh7z99tvV+uy6666ZPXt2/vnPf67VmDvssEOeeOKJLFmypKptxowZadSoUXr37l3V1q9fv4wdOzZ/+ctfqm5p9rHtttsu3/rWt3LvvffmK1/5Sq699tpPeaUAAAAAAFC3BC8NwKabbpoOHTrkF7/4RebMmZM//vGPGT16dLU+Q4cOTdeuXTNkyJDMmDEjf//733PLLbdk5syZqxzziCOOSPPmzTN8+PA8/fTT+dOf/pT/+Z//yTe+8Y106dIllZWVGTt2bGbOnJmXXnop9957b1544YXssMMOef/99zNq1KhMmzYtL730UmbMmJFHHnmk2jNgAAAAAACgPnKrsQJdecLaPR+ltjVq1CiTJk3KSSedlJ133jm9e/fOpZdemv3226+qT7NmzXLvvffm29/+dg466KB89NFH2XHHHTNx4sRVjtmyZcvcc889Ofnkk/OZz3wmLVu2zKGHHpoLL7yw6vzf/va3XH/99XnrrbfSrVu3nHjiifnv//7vfPTRR3nrrbcybNiwLFiwIB07dsxXvvKVjK/lrZYAAAAAAFA0wUsDUVFRkWeeeaZaW6lUqvZ6yy23zO9+97u1HnOXXXbJH//4x1We69KlS2677bZVnmvWrFl++9vfrvU8AAAAAABQX7jVGAAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQZrUdQEbk4Xjx9faXG3HjfvUY+y3337p27dvLr744k9f0CcwYsSIvPPOO5k8eXKNfeq6RgAAAAAAWBd2vAAAAAAAABRE8AIAAAAAAFAQwUsDsWTJkgwbNiytW7dOt27dcsEFF6zUZ+nSpTn99NPTo0ePlJeXZ5tttsnVV19d45ir6798+fIcddRR6dWrV1q0aJHevXvnkksuWeU448ePT6dOndKmTZscd9xxWbZs2WrnPPXUU7PZZpulVatW6d+/f6ZNm7ZuiwEAAAAAAOuJZ7w0EGPGjMn06dNz++23p3PnzjnzzDPz2GOPpW/fvlV9hg0blpkzZ+bSSy9Nnz59UllZmTfffLPGMVfXf8WKFdl8881z8803p0OHDvnLX/6SY489Nt26dctXv/rVqjGmTp2a5s2bZ9q0afnHP/6RkSNHpkOHDvnBD36wyjlHjRqVZ555JpMmTUr37t1z2223ZdCgQXnqqaey7bbbFrNYAAAAAADwCQleGoDFixfn6quvzq9+9avsv//+SZLrr78+m2++eVWf559/PjfddFPuu+++VFRUJEm22mqrGsdcU/+mTZtm/PjxVa979eqVmTNn5qabbqoWvDRr1izXXHNNWrZsmZ122innnntuxowZk+9973tp1Kj6hqy5c+fm2muvzdy5c9O9e/ckyamnnpopU6bk2muvzQ9/+MNPukQAAAAAAFAIwUsD8OKLL2bZsmXp379/VVv79u3Tu3fvqtezZ89O48aNs++++67VmGvTf+LEibnmmmsyd+7cvP/++1m2bFm1HTZJ0qdPn7Rs2bLq9YABA7J48eK8/PLL2XLLLav1feqpp7J8+fJst9121dqXLl2aDh06rFXdAAAAAACwPgleSJK0aNGi0P6TJk3KqaeemgsuuCADBgzIJptskvPPPz8PPfTQJ65x8eLFady4cR599NE0bty42rnWrVt/4nEBAAAAAKAojdbchfpu6623TtOmTauFHm+//Xaef/75qte77LJLVqxYkenTp6/VmGvqP2PGjOy555454YQT0q9fv2yzzTZ58cUXV+r3xBNP5P333696/eCDD6Z169bp0aPHSn379euX5cuX5/XXX88222xT7ejateta1Q0AAAAAAOuT4KUBaN26dY466qiMGTMmf/zjH/P0009nxIgR1Z6h0rNnzwwfPjzf/OY3M3ny5FRWVmbatGm56aabVjnmmvpvu+22mTVrVu655548//zz+e53v5tHHnlkpXGWLVuWo446Ks8880zuuuuujBs3LqNGjVrp+S5Jst122+WII47IsGHDcuutt6aysjIPP/xwJkyYkDvvvLOg1QIAAAAAgE/OrcYK1HbcuLouoUbnn39+Fi9enMGDB2eTTTbJt7/97SxcuLBan8svvzxnnnlmTjjhhLz11lvZYostcuaZZ9Y45ur6//d//3cef/zxHH744SkrK8vQoUNzwgkn5O677642xv77759tt902n//857N06dIMHTo055xzTo1zXnvttfn+97+fb3/723n11VfTsWPHfO5zn8uXvvSlT744AAAAAABQkLJSqVSq6yI2NIsWLUrbtm2zcOHCtGnTptq5Dz74IJWVlenVq1eaN29eRxWytvx5AQAAALChWDh+fK3OtyH/RfH/y9rUrLbXJqlf61NbVpcb/F9uNQYAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETw0oDtt99+OeWUU+q6DAAAAAAA2Gg0qesCNiaPfeMbtTbXbr/8Za3NBQAAAAAArB3BCwAAAAAAbKBenDOn1ufcrdZn3Li41VgDsWTJkgwbNiytW7dOt27dcsEFF6zUZ+nSpTn99NPTo0ePlJeXZ5tttsnVV19d45hvv/12hg0blk033TQtW7bMgQcemBdeeKHq/EsvvZTBgwdn0003TatWrbLTTjvlrrvuqnrvEUcckU6dOqVFixbZdtttc+211xZ/4QAAAAAAUIvseGkgxowZk+nTp+f2229P586dc+aZZ+axxx5L3759q/oMGzYsM2fOzKWXXpo+ffqksrIyb775Zo1jjhgxIi+88EJ+//vfp02bNjn99NNz0EEH5ZlnnknTpk1z4oknZtmyZbn//vvTqlWrPPPMM2ndunWS5Lvf/W6eeeaZ3H333enYsWPmzJmT999/f30vAwAAAAAArFd1Grzcf//9Of/88/Poo49m3rx5ue222zJkyJAa+48YMSLXX3/9Su077rhj/vrXvyZJzjnnnIwfP77a+d69e+dvf/tbobXXJ4sXL87VV1+dX/3qV9l///2TJNdff30233zzqj7PP/98brrpptx3332pqKhIkmy11VY1jvlx4DJjxozsueeeSZJf//rX6dGjRyZPnpzDDjssc+fOzaGHHppddtllpfHmzp2bfv36ZY899kiS9OzZs9BrBgAAAACAulCntxpbsmRJ+vTpk4kTJ65V/0suuSTz5s2rOl5++eW0b98+hx12WLV+O+20U7V+DzzwwPoov9548cUXs2zZsvTv37+qrX379undu3fV69mzZ6dx48bZd99912rMZ599Nk2aNKk2ZocOHdK7d+88++yzSZKTTjop3//+97PXXntl3LhxefLJJ6v6Hn/88Zk0aVL69u2b0047LX/5y18+7WUCAAAAAECdq9Pg5cADD8z3v//9fPnLX16r/m3btk3Xrl2rjlmzZuXtt9/OyJEjq/Vr0qRJtX4dO3ZcH+VvVFq0aFH4mEcffXT+/ve/5xvf+Eaeeuqp7LHHHvnpT3+a5F9/9i+99FK+9a1v5bXXXsv++++fU089tfAaAAAAAACgNtXrZ7xcffXVqaioyJZbblmt/YUXXkj37t3TvHnzDBgwIBMmTMgWW2xR4zhLly7N0qVLq14vWrRovdVcF7beeus0bdo0Dz30UNU6vP3223n++eerdrjssssuWbFiRaZPn151q7HV2WGHHfLRRx/loYceqrrV2FtvvZXnnnsuO+64Y1W/Hj165Ljjjstxxx2XsWPH5sorr8z//M//JEk6deqU4cOHZ/jw4dlnn30yZsyY/OQnPyn68gEAAACADdyLc+bU6ny71epsNDR1uuPl03jttddy99135+ijj67W3r9//1x33XWZMmVKLr/88lRWVmafffbJu+++W+NYEyZMSNu2bauOHj16rO/ya1Xr1q1z1FFHZcyYMfnjH/+Yp59+OiNGjEijRv/7x9+zZ88MHz483/zmNzN58uRUVlZm2rRpuemmm1Y55rbbbptDDjkkxxxzTB544IE88cQTOfLII7PZZpvlkEMOSZKccsopueeee1JZWZnHHnssf/rTn7LDDjskSc4+++zcfvvtmTNnTv7617/mjjvuqDoHAAAAAAD1Vb0NXq6//vq0a9cuQ4YMqdZ+4IEH5rDDDsuuu+6agQMH5q677so777xTY4CQJGPHjs3ChQurjpdffnk9V1/7zj///Oyzzz4ZPHhwKioqsvfee2f33Xev1ufyyy/Pf/3Xf+WEE07I9ttvn2OOOSZLliypccxrr702u+++e770pS9lwIABKZVKueuuu9K0adMkyfLly3PiiSdmhx12yKBBg7LddtvlsssuS5I0a9YsY8eOza677prPf/7zady4cSZNmrT+FgAAAAAAAGpBvbzVWKlUyjXXXJNvfOMbadas2Wr7tmvXLtttt13mrGarWnl5ecrLyz91Xbv98pefeoz1pXXr1vnlL3+ZX/5bjWPGjKnWp3nz5rnwwgtz4YUXrtWYm266aW644YYaz3/8PJdVOeuss3LWWWet1TwAAAAAAFBf1MsdL9OnT8+cOXNy1FFHrbHv4sWL8+KLL6Zbt261UBkAAAAAANCQ1Wnwsnjx4syePTuzZ89OklRWVmb27NmZO3dukn/dAmzYsGErve/qq69O//79s/POO6907tRTT8306dPzj3/8I3/5y1/y5S9/OY0bN87QoUPX67UAAAAAAADU6a3GZs2alS984QtVr0ePHp0kGT58eK677rrMmzevKoT52MKFC3PLLbfkkksuWeWYr7zySoYOHZq33nornTp1yt57750HH3wwnTp1Wn8XAgAAAACwBi+u5nEI68NutTob8LE6DV7222+/lEqlGs9fd911K7W1bds27733Xo3v8YB2AAAAAACgrtTLZ7wAAAAAAABsiAQvn9Dqduqw4fDnBAAAAABAbRK8rKOmTZsmyWpvd8aGY9myZUmSxo0b13ElAAAAAAA0BHX6jJf6qHHjxmnXrl1ef/31JEnLli1TVlZWx1WxKitWrMgbb7yRli1bpkkTH3UAAAAAANY/v43+BLp27ZokVeELG65GjRpliy22EI4BAAAAAFArBC+fQFlZWbp165bOnTvnww8/rOtyWI1mzZqlUSN31AMAAAAAoHYIXj6Fxo0be3YIAAAAAABQxVYAAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKUqfBy/3335/Bgwene/fuKSsry+TJk1fbf9q0aSkrK1vpmD9/frV+EydOTM+ePdO8efP0798/Dz/88Hq8CgAAAAAAgH+p0+BlyZIl6dOnTyZOnLhO73vuuecyb968qqNz585V52688caMHj0648aNy2OPPZY+ffpk4MCBef3114suHwAAAAAAoJomdTn5gQcemAMPPHCd39e5c+e0a9dulecuvPDCHHPMMRk5cmSS5Iorrsidd96Za665JmecccanKRcAAAAAAGC16uUzXvr27Ztu3brli1/8YmbMmFHVvmzZsjz66KOpqKioamvUqFEqKioyc+bMGsdbunRpFi1aVO0AAAAAAABYV/UqeOnWrVuuuOKK3HLLLbnlllvSo0eP7LfffnnssceSJG+++WaWL1+eLl26VHtfly5dVnoOzL+bMGFC2rZtW3X06NFjvV4HAAAAAACwcarTW42tq969e6d3795Vr/fcc8+8+OKLueiii/LLX/7yE487duzYjB49uur1okWLhC8AAAAAAMA6q1fBy6p89rOfzQMPPJAk6dixYxo3bpwFCxZU67NgwYJ07dq1xjHKy8tTXl6+XusEAAAAAAA2fvXqVmOrMnv27HTr1i1J0qxZs+y+++6ZOnVq1fkVK1Zk6tSpGTBgQF2VCAAAAAAANBB1uuNl8eLFmTNnTtXrysrKzJ49O+3bt88WW2yRsWPH5tVXX80NN9yQJLn44ovTq1ev7LTTTvnggw9y1VVX5Y9//GPuvffeqjFGjx6d4cOHZ4899shnP/vZXHzxxVmyZElGjhxZ69cHAAAAAAA0LHUavMyaNStf+MIXql5//JyV4cOH57rrrsu8efMyd+7cqvPLli3Lt7/97bz66qtp2bJldt111/zhD3+oNsbhhx+eN954I2effXbmz5+fvn37ZsqUKenSpUvtXRgAAAAAANAglZVKpVJdF7GhWbRoUdq2bZuFCxemTZs2dV0OAAAAALAReOwb36jV+Xb75S9rdb5Pw9rUrLbXJqlf61Nb1iU3qPfPeAEAAAAAANhQCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAArSpK4LAAAAAAA2HgvHj6/V+dqOG1er8wGsiR0vAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQZrUdQEAAAAAAFBf3D6jslbn61Grs1EEO14AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKEiTui4AAAAAAIANx+0zKmt9zh61PiOsP3a8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQZrUdQEAAAAAwMbjxTlzanW+3Wp1NoA1s+MFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICC1Gnwcv/992fw4MHp3r17ysrKMnny5NX2v/XWW/PFL34xnTp1Sps2bTJgwIDcc8891fqcc845KSsrq3Zsv/326/EqAAAAAAAA/qVOg5clS5akT58+mThx4lr1v//++/PFL34xd911Vx599NF84QtfyODBg/P4449X67fTTjtl3rx5VccDDzywPsoHAAAAAACopkldTn7ggQfmwAMPXOv+F198cbXXP/zhD3P77bfn//2//5d+/fpVtTdp0iRdu3YtqkwAAAAAAIC1Uq+f8bJixYq8++67ad++fbX2F154Id27d89WW22VI444InPnzl3tOEuXLs2iRYuqHQAAAAAAAOuqXgcvP/nJT7J48eJ89atfrWrr379/rrvuukyZMiWXX355Kisrs88+++Tdd9+tcZwJEyakbdu2VUePHj1qo3wAAAAAAGAjU2+Dl9/85jcZP358brrppnTu3Lmq/cADD8xhhx2WXXfdNQMHDsxdd92Vd955JzfddFONY40dOzYLFy6sOl5++eXauAQAAAAAAGAjU6fPePmkJk2alKOPPjo333xzKioqVtu3Xbt22W677TJnzpwa+5SXl6e8vLzoMgEAAAAAgAam3u14+e1vf5uRI0fmt7/9bQ4++OA19l+8eHFefPHFdOvWrRaqAwAAAAAAGrI63fGyePHiajtRKisrM3v27LRv3z5bbLFFxo4dm1dffTU33HBDkn/dXmz48OG55JJL0r9//8yfPz9J0qJFi7Rt2zZJcuqpp2bw4MHZcsst89prr2XcuHFp3Lhxhg4dWvsXCAAAAAAANCh1uuNl1qxZ6devX/r165ckGT16dPr165ezzz47STJv3rzMnTu3qv8vfvGLfPTRRznxxBPTrVu3quPkk0+u6vPKK69k6NCh6d27d7761a+mQ4cOefDBB9OpU6favTgAAAAAAKDBqdMdL/vtt19KpVKN56+77rpqr6dNm7bGMSdNmvQpqwIAAAAAAPhk6t0zXgAAAAAAADZUghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCBN6roAAAAAAIDadvuMylqfs0etzwjUBTteAAAAAAAACiJ4AQAAAAAAKIhbjQEAAADARsrttABqnx0vAAAAAAAABVmnHS/PPvtsJk2alD//+c956aWX8t5776VTp07p169fBg4cmEMPPTTl5eXrq1YAAAAAAIAN2lrteHnsscdSUVGRfv365YEHHkj//v1zyimn5Hvf+16OPPLIlEqlfOc730n37t1z3nnnZenSpeu7bgAAAAAAgA3OWu14OfTQQzNmzJj87ne/S7t27WrsN3PmzFxyySW54IILcuaZZxZVIwAAAAAAQL2wVsHL888/n6ZNm66x34ABAzJgwIB8+OGHn7owAAAAAACA+matbjW2NqHLp+kPAAAAAACwMVirHS+r84c//CF//vOfs8cee2Tw4MFF1AQAAAAAAFAvrdWOl4+dcMIJ+e53v1v1+pZbbsmgQYNy55135vDDD8+FF15YeIEAAAAAAAD1xToFL3/605/y+c9/vur1hRdemB/+8IeZNWtWfvWrX+Wyyy4rvEAAAAAAAID6Yq1uNTZ+/Pgkydy5c3P77bdn5syZKZVKeeSRR9KnT5+ce+65+eCDDzJ37tyce+65SZKzzz57/VUNAAAAAACwAVqr4GXEiBFJkiuuuCJf/OIX07dv3/z5z39O165dc8YZZ6RUKmXJkiW59NJLM2LEiJRKpfVZMwAAAAAAwAZprYKXLbfcMknyuc99Lueff35OPPHE/PSnP82Xv/zlbLHFFkmSRx55JL169ap6DQAAAAAA0NCs0zNeLrroopSVleXYY49N+/btM27cuKpzP//5zzN48ODCCwQAAAAAAKgv1mrHy8d69uyZP//5z6s8d9VVVxVSEAAAAAAAQH21TjteAAAAAAAAqNlaBS8/+tGP8v7776/VgA899FDuvPPOT1UUAAAAAABAfbRWwcszzzyTLbbYIieccELuvvvuvPHGG1XnPvroozz55JO57LLLsueee+bwww/PJptsst4KBgAAAAAA2FCt1TNebrjhhjzxxBP52c9+lq9//etZtGhRGjdunPLy8rz33ntJkn79+uXoo4/OiBEj0rx58/VaNAAAAAAAwIZorYKXJOnTp0+uvPLK/PznP8+TTz6Zl156Ke+//346duyYvn37pmPHjuuzTgAAAAAAgA3eWgcvH2vUqFH69u2bvn37rodyAAAAAAAA6q+1esYLAAAAAAAAayZ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIKsc/DyzW9+M+++++5K7UuWLMk3v/nNQooCAAAAAACoj9Y5eLn++uvz/vvvr9T+/vvv54YbbiikKAAAAAAAgPqoydp2XLRoUUqlUkqlUt599900b9686tzy5ctz1113pXPnzuulSAAAAAAAgPpgrYOXdu3apaysLGVlZdluu+1WOl9WVpbx48cXWhwAAAAAAEB9stbBy5/+9KeUSqX8x3/8R2655Za0b9++6lyzZs2y5ZZbpnv37uulSAAAAAAAgPpgrYOXfffdN0lSWVmZLbbYImVlZeutKAAAAAAAgPqo0bq+4dlnn82MGTOqXk+cODF9+/bN17/+9bz99tuFFgcAAAAAAFCfrHPwMmbMmCxatChJ8tRTT2X06NE56KCDUllZmdGjRxdeIAAAAAAAQH2x1rca+1hlZWV23HHHJMktt9ySwYMH54c//GEee+yxHHTQQYUXCAAAAAAAUF+s846XZs2a5b333kuS/OEPf8gBBxyQJGnfvn3VThgAAAAAAICGaJ13vOy9994ZPXp09tprrzz88MO58cYbkyTPP/98Nt9888ILBAAAAAAAqC/WecfLz372szRp0iS/+93vcvnll2ezzTZLktx9990ZNGhQ4QUCAAAAAADUF+u842WLLbbIHXfcsVL7RRddVEhBAAAAAAAA9dU6By9Jsnz58kyePDnPPvtskmSnnXbKf/7nf6Zx48aFFgcAAAAAAFCfrHPwMmfOnBx00EF59dVX07t37yTJhAkT0qNHj9x5553ZeuutCy8SAAAAAACgPljnZ7ycdNJJ2XrrrfPyyy/nsccey2OPPZa5c+emV69eOemkk9ZHjQAAAAAAAPXCOu94mT59eh588MG0b9++qq1Dhw750Y9+lL322qvQ4gAAAAAAAOqTdd7xUl5ennfffXel9sWLF6dZs2aFFAUAAAAAAFAfrXPw8qUvfSnHHntsHnrooZRKpZRKpTz44IM57rjj8p//+Z/ro0YAAAAAAIB6YZ2Dl0svvTRbb711BgwYkObNm6d58+bZa6+9ss022+SSSy5ZHzUCAAAAAADUC+v8jJd27drl9ttvz5w5c/Lss88mSXbYYYdss802hRcHAAAAAABQn6xT8LJo0aK0bt06jRo1yjbbbFMVtqxYsSKLFi1KmzZt1kuRAAAAAAAA9cFa32rstttuyx577JEPPvhgpXPvv/9+PvOZz+T//b//V2hxAAAAAAAA9claBy+XX355TjvttLRs2XKlc61atcrpp5+en/3sZ4UWBwAAAAAAUJ+sdfDy9NNPZ7/99qvx/Oc///k89dRTRdQEAAAAAABQL6118PL222/no48+qvH8hx9+mLfffruQogAAAAAAAOqjtQ5eevbsmVmzZtV4ftasWdlyyy0LKQoAAAAAAKA+Wuvg5Stf+Uq+853vZMGCBSudmz9/fs4666wceuihhRYHAAAAAABQn6x18HLGGWdkk002ybbbbpsTTjghl1xySS655JIcf/zx2W677dK6deucccYZ6zT5/fffn8GDB6d79+4pKyvL5MmT1/ieadOmZbfddkt5eXm22WabXHfddSv1mThxYnr27JnmzZunf//+efjhh9epLgAAAAAAgE9irYOXTTbZJDNmzMiRRx6ZG2+8Md/61rfyrW99KzfeeGOOPPLIPPDAA9lkk03WafIlS5akT58+mThx4lr1r6yszMEHH5wvfOELmT17dk455ZQcffTRueeee6r63HjjjRk9enTGjRuXxx57LH369MnAgQPz+uuvr1NtAAAAAAAA66rJunRu27ZtLrvsskycODFvvvlmSqVSOnXqlLKysk80+YEHHpgDDzxwrftfccUV6dWrVy644IIkyQ477JAHHnggF110UQYOHJgkufDCC3PMMcdk5MiRVe+58847c80116zzjhwAAAAAAIB1sdY7Xv5dWVlZOnXqlM6dO3/i0OWTmDlzZioqKqq1DRw4MDNnzkySLFu2LI8++mi1Po0aNUpFRUVVn1VZunRpFi1aVO0AAAAAAABYV58oeKkr8+fPT5cuXaq1denSJYsWLcr777+fN998M8uXL19ln/nz59c47oQJE9K2bduqo0ePHuulfgAAAAAAYONWr4KX9WXs2LFZuHBh1fHyyy/XdUkAAAAAAEA9tE7PeKlrXbt2zYIFC6q1LViwIG3atEmLFi3SuHHjNG7ceJV9unbtWuO45eXlKS8vXy81AwAAAAAADcc6By833HBDDj/88JWCimXLlmXSpEkZNmxYYcX9XwMGDMhdd91Vre2+++7LgAEDkiTNmjXL7rvvnqlTp2bIkCFJkhUrVmTq1KkZNWrUeqsLAAAAAICG4Y4n2tbqfMfX6mwUYZ1vNTZy5MgsXLhwpfZ33303I0eOXKexFi9enNmzZ2f27NlJksrKysyePTtz585N8q9bgP17kHPcccfl73//e0477bT87W9/y2WXXZabbrop3/rWt6r6jB49OldeeWWuv/76PPvsszn++OOzZMmSda4NAAAAAABgXa3zjpdSqZSysrKV2l955ZW0bbtuSd+sWbPyhS98oer16NGjkyTDhw/Pddddl3nz5lWFMEnSq1ev3HnnnfnWt76VSy65JJtvvnmuuuqqDBw4sKrP4YcfnjfeeCNnn3125s+fn759+2bKlCnp0qXLul4qAAAAAADAOlnr4KVfv34pKytLWVlZ9t9//zRp8r9vXb58eSorKzNo0KB1mny//fZLqVSq8fx11123yvc8/vjjqx131KhRbi0GAAAAAADUurUOXj5+Zsrs2bMzcODAtG7duupcs2bN0rNnzxx66KGFFwgAAAAAAFBfrHXwMm7cuCRJz54987WvfS3l5eXrrSgAAAAAAID6qNG6vmHHHXfM7NmzV2p/6KGHMmvWrCJqAgAAAAAAqJfWOXg58cQT8/LLL6/U/uqrr+bEE08spCgAAAAAAID6aK1vNfaxZ555JrvttttK7f369cszzzxTSFEAAAAAANSNO55oW+tzHl/rM8L6s847XsrLy7NgwYKV2ufNm5cmTdY5xwEAAAAAANhorHPwcsABB2Ts2LFZuHBhVds777yTM888M1/84hcLLQ4AAAAAAKA+WectKj/5yU/y+c9/PltuuWX69euXJJk9e3a6dOmSX/7yl4UXCAAAAAAAUF+sc/Cy2Wab5cknn8yvf/3rPPHEE2nRokVGjhyZoUOHpmnTpuujRgAAAAAAgHrhEz2UpVWrVjn22GOLrgUAAAAAAKBeW+dnvCTJL3/5y+y9997p3r17XnrppSTJRRddlNtvv73Q4gAAAAAAAOqTdQ5eLr/88owePToHHnhg3n777SxfvjxJsummm+biiy8uuj4AAAAAAIB6Y52Dl5/+9Ke58sor853vfCdNmvzvncr22GOPPPXUU4UWBwAAAAAAUJ+sc/BSWVmZfv36rdReXl6eJUuWFFIUAAAAAABAfbTOwUuvXr0ye/bsldqnTJmSHXbYoYiaAAAAAAAA6qUma+5S3ejRo3PiiSfmgw8+SKlUysMPP5zf/va3mTBhQq666qr1USMAAAAAbDAWjh9f63O2HTeu1ucE4JNZ5+Dl6KOPTosWLXLWWWflvffey9e//vV07949l1xySb72ta+tjxoBAAAAAADqhXUOXpLkiCOOyBFHHJH33nsvixcvTufOnYuuCwAAAAAAoN75RMHLx1q2bJmWLVsWVQsAAAAAAEC9tlbBy2677ZapU6dm0003Tb9+/VJWVlZj39atW2ennXbKmWeemR49ehRWKAAAAAC1x3NMAOCTWavg5ZBDDkl5eXmSZMiQIavtu3Tp0kydOjVHHnlkpk+f/qkLBAAAAAAAqC/WKngZ929/22DcWvzNgxdffDE77bTTJ68KAAAAAACgHvrEz3h544038txzzyVJevfunU6dOlWd23rrrbNgwYJPXx0AAAAAAEA9ss7By5IlS/I///M/+eUvf5nly5cnSRo3bpxhw4blpz/9aVq2bJkkadu2bbGVAgAAABTMc0wAgKI1Wtc3jB49OtOnT8/vf//7vPPOO3nnnXdy++23Z/r06fn2t7+9PmoEAAAAAACoF9Z5x8stt9yS3/3ud9lvv/2q2g466KC0aNEiX/3qV3P55ZcXWR8AAAAAAEC9sc47Xt5777106dJlpfbOnTvnvffeK6QoAAAAAACA+midd7wMGDAg48aNyw033JDmzZsnSd5///2MHz8+AwYMKLxAAAAA4NOp7eeYeIYJANCQrXPwcvHFF2fQoEHZfPPN06dPnyTJE088kebNm+eee+4pvEAAAAAAAID6Yp2Dl1122SUvvPBCfv3rX+dvf/tbkmTo0KE54ogj0qJFi8ILBAAAAAAAqC/WKXj58MMPs/322+eOO+7IMcccs75qAgAAAABYr+54om2tz3l8rc8I1IV1Cl6aNm2aDz74YH3VAgAAAJ+Y55gAALAhaLSubzjxxBNz3nnn5aOPPlof9QAAAAAAANRb6/yMl0ceeSRTp07Nvffem1122SWtWrWqdv7WW28trDgAAAAA4JNzOy2A2rfOwUu7du1y6KGHro9aAAAAAAAA6rV1Dl6uvfba9VEHAAAAa8FzTAAAYMO21s94WbFiRc4777zstdde+cxnPpMzzjgj77///vqsDQAAAAAAoF5Z6x0vP/jBD3LOOeekoqIiLVq0yCWXXJLXX38911xzzfqsDwAAAABW6/YZlbU63361OhsA9c1aBy833HBDLrvssvz3f/93kuQPf/hDDj744Fx11VVp1GitN84AAACsVm3fSitxOy0AAKA4a52YzJ07NwcddFDV64qKipSVleW1115bL4UBAAAAAADUN2sdvHz00Udp3rx5tbamTZvmww8/LLwoAAAAAACA+mitbzVWKpUyYsSIlJeXV7V98MEHOe6449KqVauqtltvvbXYCgEAAAAAAOqJtQ5ehg8fvlLbkUceWWgxAADQUHiOCQAAwMZprYOXa6+9dn3WAQAAAAAAUO+t9TNeAAAAAAAAWD3BCwAAAAAAQEEELwAAAAAAAAVZ62e8AAAAAADJi3Pm1Pqcu9X6jAB8Una8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEE84wUAAACAlXiOCQB8Mna8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEE84wUAAABosDzHBAAomh0vAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDPeAEAAICNXG0/x8QzTACAhsyOFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiIZ7wAAACwUfAcEwAANgR2vAAAAAAAABRkgwheJk6cmJ49e6Z58+bp379/Hn744Rr77rfffikrK1vpOPjgg6v6jBgxYqXzgwYNqo1LAQAAAAAAGrA6v9XYjTfemNGjR+eKK65I//79c/HFF2fgwIF57rnn0rlz55X633rrrVm2bFnV67feeit9+vTJYYcdVq3foEGDcu2111a9Li8vX38XAQAAAAAAkA0geLnwwgtzzDHHZOTIkUmSK664InfeeWeuueaanHHGGSv1b9++fbXXkyZNSsuWLVcKXsrLy9O1a9f1VzgAAEAd8BwTAADYsNXprcaWLVuWRx99NBUVFVVtjRo1SkVFRWbOnLlWY1x99dX52te+llatWlVrnzZtWjp37pzevXvn+OOPz1tvvVXjGEuXLs2iRYuqHQAAAAAAAOuqToOXN998M8uXL0+XLl2qtXfp0iXz589f4/sffvjhPP300zn66KOrtQ8aNCg33HBDpk6dmvPOOy/Tp0/PgQcemOXLl69ynAkTJqRt27ZVR48ePT75RQEAAAAAAA1Wnd9q7NO4+uqrs8suu+Szn/1stfavfe1rVf+8yy67ZNddd83WW2+dadOmZf/9919pnLFjx2b06NFVrxctWiR8AQCAOlLbt9JK3E4LAAAoTp3ueOnYsWMaN26cBQsWVGtfsGDBGp/PsmTJkkyaNClHHXXUGufZaqut0rFjx8yp4T/gysvL06ZNm2oHAAAAAADAuqrTHS/NmjXL7rvvnqlTp2bIkCFJkhUrVmTq1KkZNWrUat978803Z+nSpTnyyCPXOM8rr7ySt956K926dSuibAAAAIBad/uMylqdz71AAOCTqdMdL0kyevToXHnllbn++uvz7LPP5vjjj8+SJUsycuTIJMmwYcMyduzYld539dVXZ8iQIenQoUO19sWLF2fMmDF58MEH849//CNTp07NIYcckm222SYDBw6slWsCAAAAAAAapjp/xsvhhx+eN954I2effXbmz5+fvn37ZsqUKenSpUuSZO7cuWnUqHo+9Nxzz+WBBx7Ivffeu9J4jRs3zpNPPpnrr78+77zzTrp3754DDjgg3/ve91JeXl4r1wQAAGviOSYAAAAbpzoPXpJk1KhRNd5abNq0aSu19e7dO6VSaZX9W7RokXvuuafI8gAAAIBa4nZaAEB9V+e3GgMAAAAAANhYCF4AAAAAAAAKIngBAAAAAAAoyAbxjBcAAABoKGr7GSaJ55gAANQmO14AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAArSpK4LAAAAYONz+4zKWp+zR63PCAAAK7PjBQAAAAAAoCCCFwAAAAAAgIK41RgAAMAn5HZaAADA/2XHCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABTEM14AAIDVqu3nmHiGCQAAUJ/Z8QIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFCQJnVdAAAAAAB8Gnc80bZW5zu+VmcDoL6x4wUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAgmwQwcvEiRPTs2fPNG/ePP3798/DDz9cY9/rrrsuZWVl1Y7mzZtX61MqlXL22WenW7duadGiRSoqKvLCCy+s78sAAAAAAAAauDoPXm688caMHj0648aNy2OPPZY+ffpk4MCBef3112t8T5s2bTJv3ryq46WXXqp2/sc//nEuvfTSXHHFFXnooYfSqlWrDBw4MB988MH6vhwAAAAAAKABq/Pg5cILL8wxxxyTkSNHZscdd8wVV1yRli1b5pprrqnxPWVlZenatWvV0aVLl6pzpVIpF198cc4666wccsgh2XXXXXPDDTfktddey+TJk2vhigAAAAAAgIaqToOXZcuW5dFHH01FRUVVW6NGjVJRUZGZM2fW+L7Fixdnyy23TI8ePXLIIYfkr3/9a9W5ysrKzJ8/v9qYbdu2Tf/+/Wscc+nSpVm0aFG1AwAAAAAAYF3VafDy5ptvZvny5dV2rCRJly5dMn/+/FW+p3fv3rnmmmty++2351e/+lVWrFiRPffcM6+88kqSVL1vXcacMGFC2rZtW3X06NHj014aAAAAAADQANX5rcbW1YABAzJs2LD07ds3++67b2699dZ06tQpP//5zz/xmGPHjs3ChQurjpdffrnAigEAAAAAgIaiToOXjh07pnHjxlmwYEG19gULFqRr165rNUbTpk3Tr1+/zJkzJ0mq3rcuY5aXl6dNmzbVDgAAAAAAgHVVp8FLs2bNsvvuu2fq1KlVbStWrMjUqVMzYMCAtRpj+fLleeqpp9KtW7ckSa9evdK1a9dqYy5atCgPPfTQWo8JAAAAAADwSTSp6wJGjx6d4cOHZ4899shnP/vZXHzxxVmyZElGjhyZJBk2bFg222yzTJgwIUly7rnn5nOf+1y22WabvPPOOzn//PPz0ksv5eijj06SlJWV5ZRTTsn3v//9bLvttunVq1e++93vpnv37hkyZEhdXSYAAAAAANAA1Hnwcvjhh+eNN97I2Wefnfnz56dv376ZMmVKunTpkiSZO3duGjX63405b7/9do455pjMnz8/m266aXbffff85S9/yY477ljV57TTTsuSJUty7LHH5p133snee++dKVOmpHnz5rV+fQAAAAAAQMNR58FLkowaNSqjRo1a5blp06ZVe33RRRfloosuWu14ZWVlOffcc3PuuecWVSIAAAAAAMAa1ekzXgAAAAAAADYmG8SOFwAAAABW744n2tbqfMfX6mwAsPGw4wUAAAAAAKAgdrwAAECS22dU1up8PWp1NgAAAGqLHS8AAAAAAAAFseMFAAAA2GB4jgkAUN/Z8QIAAAAAAFAQwQsAAAAAAEBB3GoMAAAAalFt30orcTstAIDaZMcLAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEGa1HUBAAAAbHzueKJtrc95fK3PCAAAK7PjBQAAAAAAoCCCFwAAAAAAgIK41RgAAMAn5HZaAADA/2XHCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABTEM14AAIDVqu3nmHiGCQAAUJ/Z8QIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQEMELAAAAAABAQQQvAAAAAAAABRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEELwAAAAAAAAURvAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFEbwAAAAAAAAURPACAAAAAABQkCZ1XQAAAGwI7niiba3Od3ytzgYAAEBtseMFAAAAAACgIIIXAAAAAACAggheAAAAAAAACuIZLwAADcjtMyprdb5D9upVq/MBAABAXbPjBQAAAAAAoCB2vAAAG5Xa3tGR2NUBAAAA/C87XgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgghcAAAAAAICCCF4AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIBtE8DJx4sT07NkzzZs3T//+/fPwww/X2PfKK6/MPvvsk0033TSbbrppKioqVuo/YsSIlJWVVTsGDRq0vi8DAAAAAABo4JrUdQE33nhjRo8enSuuuCL9+/fPxRdfnIEDB+a5555L586dV+o/bdq0DB06NHvuuWeaN2+e8847LwcccED++te/ZrPNNqvqN2jQoFx77bVVr8vLy2vlegAA+F8Lx4+v9TnbjhtX63MCAADAx+p8x8uFF16YY445JiNHjsyOO+6YK664Ii1btsw111yzyv6//vWvc8IJJ6Rv377Zfvvtc9VVV2XFihWZOnVqtX7l5eXp2rVr1bHpppvWxuUAAAAAAAANWJ3ueFm2bFkeffTRjB07tqqtUaNGqaioyMyZM9dqjPfeey8ffvhh2rdvX6192rRp6dy5czbddNP8x3/8R77//e+nQ4cOqxxj6dKlWbp0adXrRYsWfYKrAQAaqtre1WFHBwAAAGy46nTHy5tvvpnly5enS5cu1dq7dOmS+fPnr9UYp59+erp3756KioqqtkGDBuWGG27I1KlTc95552X69Ok58MADs3z58lWOMWHChLRt27bq6NGjxye/KAAAAAAAoMGq82e8fBo/+tGPMmnSpEybNi3Nmzevav/a175W9c+77LJLdt1112y99daZNm1a9t9//5XGGTt2bEaPHl31etGiRcIXAPg/7OoAAAAAWLM63fHSsWPHNG7cOAsWLKjWvmDBgnTt2nW17/3JT36SH/3oR7n33nuz6667rrbvVlttlY4dO2bOnDmrPF9eXp42bdpUOwAAAAAAANZVne54adasWXbfffdMnTo1Q4YMSZKsWLEiU6dOzahRo2p8349//OP84Ac/yD333JM99thjjfO88soreeutt9KtW7eiSgdgI2VXBwAAAACfRp3ueEmS0aNH58orr8z111+fZ599Nscff3yWLFmSkSNHJkmGDRuWsWPHVvU/77zz8t3vfjfXXHNNevbsmfnz52f+/PlZvHhxkmTx4sUZM2ZMHnzwwfzjH//I1KlTc8ghh2SbbbbJwIED6+QaAQAAAACAhqHOn/Fy+OGH54033sjZZ5+d+fPnp2/fvpkyZUq6dOmSJJk7d24aNfrffOjyyy/PsmXL8l//9V/Vxhk3blzOOeecNG7cOE8++WSuv/76vPPOO+nevXsOOOCAfO9730t5eXmtXhvAhqi2d3QkdnUAAAAA0HDUefCSJKNGjarx1mLTpk2r9vof//jHasdq0aJF7rnnnoIqAwAAAAAAWHsbRPACUDS7OgAAAACAulDnz3gBAAAAAADYWNjxAvWYXR0AAAAAABsWO14AAAAAAAAKYscLG7za3tVhRwcAAAAAAJ+UHS8AAAAAAAAFseMFAID15sU5c2p9zt1qfUYAAAD4X4IXAKiHbp9RWetz7lfrMwIAAADUP4IXADZYwgXqi9re1WFHBwAAAGy4POMFAAAAAACgIHa8ANSx2t7VsV+tzsbGxK4OAAAAgDWz4wUAAAAAAKAgdrwAwL+xqwMAAACAT8OOFwAAAAAAgILY8QLQwNT2jo7Erg4AAAAAGg47XgAAAAAAAApixwuwUbKrAwAAAACoC3a8AAAAAAAAFMSOF6jH7OoAAAAAANiw2PECAAAAAABQEDte2ODV9q4OOzoAAAAAAPik7HgBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgII0qesCAACoPXc80bZW5zu+VmcDAACAumfHCwAAAAAAQEHseAEANiq1vaMjsasDAAAA+F92vAAAAAAAABRE8AIAAAAAAFAQwQsAAAAAAEBBBC8AAAAAAAAFaVLXBQANw+0zKmt1vh61OhsAAAAAwL/Y8QIAAAAAAFAQO16gQHZ1AAAAAAA0bHa8AAAAAAAAFMSOF9ZJbe/oSOzqAFiVO55oW+tzHl/rMwIAAADUP3a8AAAAAAAAFMSOFwA2WHZ1AAAAAFDf2PECAAAAAABQEDteAOpYbe/qsKMDAAAAANYfO14AAAAAAAAKIngBAAAAAAAoiOAFAAAAAACgIIIXAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgII0qesCgIbhjifa1up8x9fqbAAAAAAA/2LHCwAAAAAAQEHseIEC2dUBAAAAANCw2fECAAAAAABQEDteWCe1vaMjsasDAAAAAID6w44XAAAAAACAggheAAAAAAAACiJ4AQAAAAAAKIjgBQAAAAAAoCCCFwAAAAAAgIIIXgAAAAAAAAoieAEAAAAAACiI4AUAAAAAAKAgG0TwMnHixPTs2TPNmzdP//798/DDD6+2/80335ztt98+zZs3zy677JK77rqr2vlSqZSzzz473bp1S4sWLVJRUZEXXnhhfV4CAAAAAABA3QcvN954Y0aPHp1x48blscceS58+fTJw4MC8/vrrq+z/l7/8JUOHDs1RRx2Vxx9/PEOGDMmQIUPy9NNPV/X58Y9/nEsvvTRXXHFFHnroobRq1SoDBw7MBx98UFuXBQAAAAAANEB1HrxceOGFOeaYYzJy5MjsuOOOueKKK9KyZctcc801q+x/ySWXZNCgQRkzZkx22GGHfO9738tuu+2Wn/3sZ0n+tdvl4osvzllnnZVDDjkku+66a2644Ya89tprmTx5ci1eGQAAAAAA0NA0qcvJly1blkcffTRjx46tamvUqFEqKioyc+bMVb5n5syZGT16dLW2gQMHVoUqlZWVmT9/fioqKqrOt23bNv3798/MmTPzta99baUxly5dmqVLl1a9XrhwYZJk0aJFn/jaNlbL3q/9NVm8bFmtzvdp/txre31qe22ST74+1qZm1qZmvnNqZm1qZm1Wz3dOzaxNzaxNzXzn1Mza1MzarJ7vnJpZm5pZm5r5zqmZtamZtVk93zkN08drUiqV1ty5VIdeffXVUpLSX/7yl2rtY8aMKX32s59d5XuaNm1a+s1vflOtbeLEiaXOnTuXSqVSacaMGaUkpddee61an8MOO6z01a9+dZVjjhs3rpTE4XA4HA6Hw+FwOBwOh8PhcDgcDoejxuPll19eY/ZRpzteNhRjx46ttotmxYoV+ec//5kOHTqkrKysDivbeCxatCg9evTIyy+/nDZt2tR1ORsUa1Mza1Mza1Mza7N61qdm1qZm1qZm1qZm1qZm1mb1rE/NrE3NrE3NrE3NrE3NrM3qWZ+aWZuaWZv6r1Qq5d1330337t3X2LdOg5eOHTumcePGWbBgQbX2BQsWpGvXrqt8T9euXVfb/+P/XbBgQbp161atT9++fVc5Znl5ecrLy6u1tWvXbl0uhbXUpk0bXyw1sDY1szY1szY1szarZ31qZm1qZm1qZm1qZm1qZm1Wz/rUzNrUzNrUzNrUzNrUzNqsnvWpmbWpmbWp39q2bbtW/Rqt5zpWq1mzZtl9990zderUqrYVK1Zk6tSpGTBgwCrfM2DAgGr9k+S+++6r6t+rV6907dq1Wp9FixbloYceqnFMAAAAAACAItT5rcZGjx6d4cOHZ4899shnP/vZXHzxxVmyZElGjhyZJBk2bFg222yzTJgwIUly8sknZ999980FF1yQgw8+OJMmTcqsWbPyi1/8IklSVlaWU045Jd///vez7bbbplevXvnud7+b7t27Z8iQIXV1mQAAAAAAQANQ58HL4YcfnjfeeCNnn3125s+fn759+2bKlCnp0qVLkmTu3Llp1Oh/N+bsueee+c1vfpOzzjorZ555ZrbddttMnjw5O++8c1Wf0047LUuWLMmxxx6bd955J3vvvXemTJmS5s2b1/r18S/l5eUZN27cSrd0w9qsjrWpmbWpmbVZPetTM2tTM2tTM2tTM2tTM2uzetanZtamZtamZtamZtamZtZm9axPzaxNzaxNw1JWKpVKdV0EAAAAAADAxqBOn/ECAAAAAACwMRG8AAAAAAAAFETwAgAAAAAAUBDBCwAAAAAAQEEEL3xi999/fwYPHpzu3bunrKwskydPrna+VCrl7LPPTrdu3dKiRYtUVFTkhRdeqNbnn//8Z4444oi0adMm7dq1y1FHHZXFixfX4lWsHxMmTMhnPvOZbLLJJuncuXOGDBmS5557rlqfDz74ICeeeGI6dOiQ1q1b59BDD82CBQuq9Zk7d24OPvjgtGzZMp07d86YMWPy0Ucf1ealFO7yyy/PrrvumjZt2qRNmzYZMGBA7r777qrzDXVdVuVHP/pRysrKcsopp1S1NdT1Oeecc1JWVlbt2H777avON9R1+dirr76aI488Mh06dEiLFi2yyy67ZNasWVXnG/L3cc+ePVf67JSVleXEE09M0rA/O8uXL893v/vd9OrVKy1atMjWW2+d733veymVSlV9GvJn5913380pp5ySLbfcMi1atMiee+6ZRx55pOp8Q1mb2vp578knn8w+++yT5s2bp0ePHvnxj3+8vi/tU1vT2tx666054IAD0qFDh5SVlWX27NkrjbExfwetbn0+/PDDnH766dlll13SqlWrdO/ePcOGDctrr71WbYyG+tk555xzsv3226dVq1bZdNNNU1FRkYceeqhan4a6Nv/uuOOOS1lZWS6++OJq7Q11bUaMGLHSzzuDBg2q1qehrk2SPPvss/nP//zPtG3bNq1atcpnPvOZzJ07t+r8xvp9vKa1WdXPyWVlZTn//POr+jTUz83ixYszatSobL755mnRokV23HHHXHHFFdX6bKyfm2TN67NgwYKMGDEi3bt3T8uWLTNo0KCVfgbcGNenNn/fN23atOy2224pLy/PNttsk+uuu259Xx5FK8EndNddd5W+853vlG699dZSktJtt91W7fyPfvSjUtu2bUuTJ08uPfHEE6X//M//LPXq1av0/vvvV/UZNGhQqU+fPqUHH3yw9Oc//7m0zTbblIYOHVrLV1K8gQMHlq699trS008/XZo9e3bpoIMOKm2xxRalxYsXV/U57rjjSj169ChNnTq1NGvWrNLnPve50p577ll1/qOPPirtvPPOpYqKitLjjz9euuuuu0odO3YsjR07ti4uqTC///3vS3feeWfp+eefLz333HOlM888s9S0adPS008/XSqVGu66/F8PP/xwqWfPnqVdd921dPLJJ1e1N9T1GTduXGmnnXYqzZs3r+p44403qs431HUplUqlf/7zn6Utt9yyNGLEiNJDDz1U+vvf/1665557SnPmzKnq05C/j19//fVqn5v77ruvlKT0pz/9qVQqNezPzg9+8INShw4dSnfccUepsrKydPPNN5dat25duuSSS6r6NOTPzle/+tXSjjvuWJo+fXrphRdeKI0bN67Upk2b0iuvvFIqlRrO2tTGz3sLFy4sdenSpXTEEUeUnn766dJvf/vbUosWLUo///nPa+syP5E1rc0NN9xQGj9+fOnKK68sJSk9/vjjK42xMX8HrW593nnnnVJFRUXpxhtvLP3tb38rzZw5s/TZz362tPvuu1cbo6F+dn7961+X7rvvvtKLL75Yevrpp0tHHXVUqU2bNqXXX3+9qk9DXZuP3XrrraU+ffqUunfvXrrooouqnWuoazN8+PDSoEGDqv3c889//rNan4a6NnPmzCm1b9++NGbMmNJjjz1WmjNnTun2228vLViwoKrPxvp9vKa1+ffPy7x580rXXHNNqaysrPTiiy9W9Wmon5tjjjmmtPXWW5f+9Kc/lSorK0s///nPS40bNy7dfvvtVX021s9NqbT69VmxYkXpc5/7XGmfffYpPfzww6W//e1vpWOPPbZB/N6rtn7f9/e//73UsmXL0ujRo0vPPPNM6ac//WmpcePGpSlTptTq9fLpCF4oxKq+hLt27Vo6//zzq9reeeedUnl5eem3v/1tqVQqlZ555plSktIjjzxS1efuu+8ulZWVlV599dVaq702vP7666UkpenTp5dKpX+tRdOmTUs333xzVZ9nn322lKQ0c+bMUqn0r/+Ta9SoUWn+/PlVfS6//PJSmzZtSkuXLq3dC1jPNt1009JVV11lXf5/7777bmnbbbct3XfffaV99923KnhpyOszbty4Up8+fVZ5riGvS6lUKp1++umlvffeu8bzvo+rO/nkk0tbb711acWKFQ3+s3PwwQeXvvnNb1Zr+8pXvlI64ogjSqVSw/7svPfee6XGjRuX7rjjjmrtu+22W+k73/lOg12b9fXz3mWXXVbadNNNq/07dfrpp5d69+69nq+oOKv7BXFlZeUqg5eG9B20uvX52MMPP1xKUnrppZdKpZLPzr9buHBhKUnpD3/4Q6lUsjavvPJKabPNNis9/fTTpS233LJa8NKQ12b48OGlQw45pMb3NOS1Ofzww0tHHnlkje9pKN/Ha/N9c8ghh5T+4z/+o+p1Q/7c7LTTTqVzzz23WtvHPwuWSg3nc1Mqrbw+zz33XClJ1V+gLZVKpeXLl5c6depUuvLKK0ulUsNZn/X1+77TTjuttNNOO1Wb6/DDDy8NHDhwfV8SBXKrMdaLysrKzJ8/PxUVFVVtbdu2Tf/+/TNz5swkycyZM9OuXbvsscceVX0qKirSqFGjlbbS13cLFy5MkrRv3z5J8uijj+bDDz+stj7bb799tthii2rrs8suu6RLly5VfQYOHJhFixblr3/9ay1Wv/4sX748kyZNypIlSzJgwADr8v878cQTc/DBB1dbh8Tn5oUXXkj37t2z1VZb5Ygjjqi6NUBDX5ff//732WOPPXLYYYelc+fO6devX6688sqq876P/9eyZcvyq1/9Kt/85jdTVlbW4D87e+65Z6ZOnZrnn38+SfLEE0/kgQceyIEHHpikYX92PvrooyxfvjzNmzev1t6iRYs88MADDXpt/l1R6zBz5sx8/vOfT7Nmzar6DBw4MM8991zefvvtWrqa2tfQv4P+r4ULF6asrCzt2rVL4rPzsWXLluUXv/hF2rZtmz59+iRp2GuzYsWKfOMb38iYMWOy0047rXS+Ia9N8q/b0nTu3Dm9e/fO8ccfn7feeqvqXENdmxUrVuTOO+/Mdtttl4EDB6Zz587p379/tdsm+T7+lwULFuTOO+/MUUcdVdXWUD83yb9+Vv7973+fV199NaVSKX/605/y/PPP54ADDkjSsD83S5cuTZJqPys3atQo5eXleeCBB5I0nPVZX7/vmzlz5kq/Exo4cGDVGNQPghfWi/nz5ydJtS+Rj19/fG7+/Pnp3LlztfNNmjRJ+/btq/psDFasWJFTTjkle+21V3beeeck/7r2Zs2aVf2H5cf+7/qsav0+PlefPfXUU2ndunXKy8tz3HHH5bbbbsuOO+7Y4NclSSZNmpTHHnssEyZMWOlcQ16f/v3757rrrsuUKVNy+eWXp7KyMvvss0/efffdBr0uSfL3v/89l19+ebbddtvcc889Of7443PSSSfl+uuvT+L7+N9Nnjw577zzTkaMGJGkYf87lSRnnHFGvva1r2X77bdP06ZN069fv5xyyik54ogjkjTsz84mm2ySAQMG5Hvf+15ee+21LF++PL/61a8yc+bMzJs3r0Gvzb8rah025n/PVqehfwf9uw8++CCnn356hg4dmjZt2iTx2bnjjjvSunXrNG/ePBdddFHuu+++dOzYMUnDXpvzzjsvTZo0yUknnbTK8w15bQYNGpQbbrghU6dOzXnnnZfp06fnwAMPzPLly5M03LV5/fXXs3jx4vzoRz/KoEGDcu+99+bLX/5yvvKVr2T69OlJfB9/7Prrr88mm2ySr3zlK1VtDfVzkyQ//elPs+OOO2bzzTdPs2bNMmjQoEycODGf//znkzTsz83HQcLYsWPz9ttvZ9myZTnvvPPyyiuvZN68eUkaxvqsz9/31dRn0aJFef/999fH5bAeNKnrAmBjd+KJJ+bpp5+uSv1JevfundmzZ2fhwoX53e9+l+HDh1f90NuQvfzy/9fe3QdVVed/AH9feX5QxEAvDwLylMZTPJhSOwHiitYiY9tGmAyKOq3kDriI4rY722iZ6UIrjo87SGa2La5kriUoCoqEkMTVMBdRHmrtFhtKQaBgfH5/+OPkjQtqi5Dc92uGGe75fu/3fM5nvpw53M/9nvM5kpOTceTIkV7fsjZ0Pd/ABwB/f39MmTIFrq6uyM3NhYWFxRBGNvS6u7sREhKCtWvXAgACAwNRXV2Nbdu2ISEhYYij+3nJzs7GrFmz4OjoONSh/Czk5uZiz549ePvtt+Hj4wONRoOUlBQ4Ojpy7gDYvXs3EhMT4eTkBCMjIwQFBSEuLg6VlZVDHRrRsNLV1YVnnnkGIoKtW7cOdTg/GxEREdBoNPj666/xt7/9Dc888wzKy8t7fQBqSCorK7Fx40Z8/PHHUKlUQx3Oz86zzz6r/O7n5wd/f394eHiguLgYkZGRQxjZ0Oru7gYAxMTEYNmyZQCAhx9+GB9++CG2bduGsLCwoQzvZ2Xnzp147rnn+L/o/9u0aRNOnTqFAwcOwNXVFSdOnMALL7wAR0fHXisRDI2JiQny8vKwcOFCjBkzBkZGRpg+fTpmzZoFERnq8AYNP++j2+GKF7on1Go1gJtLVW/11VdfKW1qtRpNTU067Tdu3MCVK1eUPve7pUuX4uDBgygqKoKzs7OyXa1Wo7OzEy0tLTr9f5wfffnrabufmZqawtPTE8HBwXj11VcREBCAjRs3GnxeKisr0dTUhKCgIBgbG8PY2BjHjx9HVlYWjI2NMW7cOIPOz61Gjx4Nb29vXLx40eDnjYODAx566CGdbZMmTVJuxcbz8U2NjY0oLCzEokWLlG2GPnfS0tKUVS9+fn6Ij4/HsmXLlBV3hj53PDw8cPz4cbS1teHzzz9HRUUFurq64O7ubvC56TFQeRjOf2f9MfRzEPBD0aWxsRFHjhxRVrsAnDtWVlbw9PTE1KlTkZ2dDWNjY2RnZwMw3NyUlJSgqakJLi4uyrVyY2MjUlNT4ebmBsBwc6OPu7s77OzscPHiRQCGmxs7OzsYGxvf9nrZ0M/HJSUlqKmp0blWBgx33nR0dOAPf/gDMjMzER0dDX9/fyxduhSxsbH4y1/+AoDzJjg4GBqNBi0tLdBqtcjPz0dzczPc3d0BDP/83OvP+/rqM2rUKIP/8un9hIUXuicmTJgAtVqNo0ePKtu+/fZblJeXIzQ0FAAQGhqKlpYWnW+OHjt2DN3d3ZgyZcqgxzyQRARLly7Fu+++i2PHjmHChAk67cHBwTAxMdHJT01NDT777DOd/HzyySc6Fzk9/5D++KLxftfd3Y3r168bfF4iIyPxySefQKPRKD8hISF47rnnlN8NOT+3amtrw6VLl+Dg4GDw8+axxx5DTU2NzrYLFy7A1dUVAM/HPXJycjB27Fg8+eSTyjZDnzvt7e0YMUL3UtDIyEj5Zijnzk1WVlZwcHDA1atXUVBQgJiYGObm/w1UHkJDQ3HixAl0dXUpfY4cOYIHH3wQtra2g3Q0g8/Qz0E9RZfa2loUFhbigQce0Gnn3NHVc70MGG5u4uPjcfbsWZ1rZUdHR6SlpaGgoACA4eZGn//85z9obm6Gg4MDAMPNjampKSZPntzv9bKhn4+BmyvDg4ODlWdJ9TDUedPV1YWurq5+r5U5b26ysbGBvb09amtrcfr0acTExAAYvvkZrM/7QkNDdcbo6dMzBt0nhOgnam1tlaqqKqmqqhIAkpmZKVVVVdLY2CgiIuvWrZPRo0fLe++9J2fPnpWYmBiZMGGCdHR0KGPMnDlTAgMDpby8XE6ePCleXl4SFxc3VIc0YJYsWSI2NjZSXFwsWq1W+Wlvb1f6/Pa3vxUXFxc5duyYnD59WkJDQyU0NFRpv3Hjhvj6+sqMGTNEo9FIfn6+2Nvby6pVq4bikAZMenq6HD9+XOrr6+Xs2bOSnp4uKpVKDh8+LCKGm5e+hIWFSXJysvLaUPOTmpoqxcXFUl9fL6WlpTJ9+nSxs7OTpqYmETHcvIiIVFRUiLGxsbzyyitSW1sre/bsEUtLS3nrrbeUPoZ8PhYR+f7778XFxUVWrlzZq82Q505CQoI4OTnJwYMHpb6+XvLy8sTOzk5WrFih9DHkuZOfny+HDh2Suro6OXz4sAQEBMiUKVOks7NTRAwnN4NxvdfS0iLjxo2T+Ph4qa6ulnfeeUcsLS1l+/btg368d+N2uWlubpaqqip5//33BYC88847UlVVJVqtVhljOJ+D+stPZ2enzJ49W5ydnUWj0ehcL1+/fl0ZwxDnTltbm6xatUrKysqkoaFBTp8+LQsWLBAzMzOprq5WxjDE3Ojj6uoqr7/+us42Q8xNa2urLF++XMrKyqS+vl4KCwslKChIvLy85Nq1a8oYhpgbEZG8vDwxMTGRHTt2SG1trWzatEmMjIykpKREGWO4no/v5G/qm2++EUtLS9m6daveMQx13oSFhYmPj48UFRVJXV2d5OTkiLm5uWzZskUZY7jOG5Hb5yc3N1eKiork0qVLsn//fnF1dZWnnnpKZ4zhmJ/B+ryvrq5OLC0tJS0tTc6fPy+bN28WIyMjyc/PH9Tjpf8NCy/0kxUVFQmAXj8JCQkiItLd3S1/+tOfZNy4cWJmZiaRkZFSU1OjM0Zzc7PExcWJtbW1jBo1ShYsWCCtra1DcDQDS19eAEhOTo7Sp6OjQ5KSksTW1lYsLS1lzpw5Ov+Ii4g0NDTIrFmzxMLCQuzs7CQ1NVW6uroG+WgGVmJiori6uoqpqanY29tLZGSkUnQRMdy89OXHhRdDzU9sbKw4ODiIqampODk5SWxsrFy8eFFpN9S89PjXv/4lvr6+YmZmJhMnTpQdO3botBvy+VhEpKCgQAD0OmYRw5473377rSQnJ4uLi4uYm5uLu7u7vPjiizofehry3PnHP/4h7u7uYmpqKmq1Wl544QVpaWlR2g0lN4N1vXfmzBn5xS9+IWZmZuLk5CTr1q0brEP8yW6Xm5ycHL3tf/7zn5UxhvM5qL/81NfX93m9XFRUpIxhiHOno6ND5syZI46OjmJqaioODg4ye/Zsqaio0BnDEHOjj77CiyHmpr29XWbMmCH29vZiYmIirq6usnjxYvnyyy91xjDE3PTIzs4WT09PMTc3l4CAANm/f7/OGMP1fHwnudm+fbtYWFjoXOfcylDnjVarlfnz54ujo6OYm5vLgw8+KBkZGdLd3a2MMVznjcjt87Nx40ZxdnYWExMTcXFxkT/+8Y86/0eIDM/8DObnfUVFRfLwww+LqampuLu76+yD7g8qEQN66hEREREREREREREREdE9xGe8EBERERERERERERERDRAWXoiIiIiIiIiIiIiIiAYICy9EREREREREREREREQDhIUXIiIiIiIiIiIiIiKiAcLCCxERERERERERERER0QBh4YWIiIiIiIiIiIiIiGiAsPBCREREREREREREREQ0QFh4ISIiIiKiO/LGG29g9OjRQx3GfSE8PBwpKSn3ZOzm5maMHTsWDQ0N92T8vmzbtg3R0dGDuk8iIiIiovsRCy9ERERERAQAmD9/PlQqFVQqFUxNTeHp6YnVq1fjxo0b92yfDQ0NUKlU0Gg0d9R/3759CA8Ph42NDaytreHv74/Vq1fjypUr9yzGnyIvLw9r1qxRXru5ueGvf/3rgIz9yiuvICYmBm5ubgB+yKGRkREuX76s01er1cLY2BgqlUop1Dg4OGDdunU6/dLT06FSqVBcXKyzPTw8HPHx8QCAxMREfPzxxygpKRmQ4yAiIiIiGq5YeCEiIiIiIsXMmTOh1WpRW1uL1NRUvPTSS9iwYcNQhwUAePHFFxEbG4vJkyfj0KFDqK6uRkZGBs6cOYPdu3cPdXg6xowZg5EjRw74uO3t7cjOzsbChQt7tTk5OeHNN9/U2bZr1y44OTnpbAsPD+9VYCkqKsL48eN1tl+7dg2nTp3CtGnTAACmpqaYO3cusrKyBuZgiIiIiIiGKRZeiIiIiIhIYWZmBrVaDVdXVyxZsgTTp0/HgQMH9Pa9dOkSYmJiMG7cOFhbW2Py5MkoLCzU6ePm5oa1a9ciMTERI0eOhIuLC3bs2KG0T5gwAQAQGBgIlUqF8PBwvfuqqKjA2rVrkZGRgQ0bNuDRRx+Fm5sbfvnLX2Lfvn1ISEi4q5jWrFmDuLg4WFlZwcnJCZs3b9bpk5mZCT8/P1hZWWH8+PFISkpCW1ubTp/S0lKEh4fD0tIStra2iIqKwtWrVwHo3mosPDwcjY2NWLZsmbKi6LvvvsOoUaPwz3/+U2fM/fv3w8rKCq2trXrz8MEHH8DMzAxTp07t1ZaQkICcnBydbTk5OUpuekRERKC0tFRZydTa2oqqqiqsXLlSp/BSVlaG69evIyIiQtkWHR2NAwcOoKOjQ298RERERETEwgsREREREfXDwsICnZ2detva2trwxBNP4OjRo6iqqsLMmTMRHR2Nzz77TKdfRkYGQkJCUFVVhaSkJCxZsgQ1NTUAbhZUAKCwsBBarRZ5eXl697Vnzx5YW1sjKSlJb3vPs2fuNKYNGzYgICAAVVVVSE9PR3JyMo4cOaK0jxgxAllZWTh37hx27dqFY8eOYcWKFUq7RqNBZGQkHnroIZSVleHkyZOIjo7G999/3yu2vLw8ODs7Y/Xq1dBqtdBqtbCyssKzzz6rt1Dy9NNP97lapqSkBMHBwXrbZs+ejatXr+LkyZMAgJMnT+Lq1au9nssSERGBtrY2fPTRR8qY3t7e+PWvf43y8nJcu3YNwM1VMG5ubsotzQAgJCQEN27cQHl5ud4YiIiIiIiIhRciIiIiItJDRFBYWIiCggLlVlM/FhAQgOeffx6+vr7w8vLCmjVr4OHh0WuFzBNPPIGkpCR4enpi5cqVsLOzQ1FREQDA3t4eAPDAAw9ArVZjzJgxevdVW1sLd3d3mJiY9Bv3ncb02GOPIT09Hd7e3vjd736Hp59+Gq+//rrSnpKSgoiICLi5uWHatGl4+eWXkZubq7SvX78eISEh2LJlCwICAuDj44OlS5fCzs6uV0xjxoyBkZERRo4cCbVaDbVaDQBYtGgRCgoKoNVqAQBNTU344IMPkJiY2OfxNTY2wtHRUW+biYkJ5s2bh507dwIAdu7ciXnz5vXKmZeXF5ycnJTVLcXFxQgLC4NarYaLiwvKysqU7beudgEAS0tL2NjYoLGxsc8YiYiIiIgMHQsvRERERESkOHjwIKytrWFubo5Zs2YhNjYWL730kt6+bW1tWL58OSZNmoTRo0fD2toa58+f77W6xN/fX/ldpVJBrVajqanpruISkTvqd6cxhYaG9np9/vx55XVhYSEiIyPh5OSEkSNHIj4+Hs3NzWhvbwfww4qX/8UjjzwCHx8f7Nq1CwDw1ltvwdXVFY8//nif7+no6IC5uXmf7YmJidi7dy++/PJL7N27t88izq3PeSkuLlZu8RYWFobi4mJ0dHSgvLy8V+EFuLkKqicPRERERETUGwsvRERERESkiIiIgEajQW1tLTo6OrBr1y5YWVnp7bt8+XK8++67WLt2LUpKSqDRaODn59fr1mQ/XnGhUqnQ3d19V3F5e3ujrq4OXV1d/fa705j609DQgF/96lfw9/fHvn37UFlZqTwDpmccCwuLu4q/L4sWLcIbb7wB4OZtxhYsWACVStVnfzs7O+U5Mvr4+flh4sSJiIuLw6RJk+Dr66u3X89zXpqbm1FVVYWwsDAANwsvRUVF+PDDD9HZ2al3tdOVK1eUlUpERERERNQbCy9ERERERKSwsrKCp6cnXFxcYGxs3G/f0tJSzJ8/H3PmzIGfnx/UajUaGhruan+mpqYAoPfZKLeaO3cu2trasGXLFr3tLS0tdxXTqVOner2eNGkSAKCyshLd3d3IyMjA1KlT4e3tjS+++EKnv7+/P44ePXonhwjg5nHqO8Z58+ahsbERWVlZ+PTTT5GQkNDvOIGBgfj000/77ZOYmIji4uJ+b1kWERGB7777DpmZmfDy8sLYsWMBAI8//jgqKipw6NAh5ZZkt7p06RKuXbuGwMDAfmMgIiIiIjJkLLwQEREREdFP4uXlhby8PGg0Gpw5cwZz586965UsY8eOhYWFBfLz8/HVV1/hm2++0dtvypQpWLFiBVJTU7FixQqUlZWhsbERR48exW9+8xvldl13GlNpaSnWr1+PCxcuYPPmzdi7dy+Sk5MBAJ6enujq6sKmTZtQV1eH3bt3Y9u2bTrvX7VqFT766CMkJSXh7Nmz+Pe//42tW7fi66+/1hu/m5sbTpw4gcuXL+v0sbW1xVNPPYW0tDTMmDEDzs7O/eYrKioK586d63fVy+LFi/Hf//4XixYt6rOPu7s7XFxcsGnTJmW1CwCMHz8ejo6O2LFjh97bjJWUlMDd3R0eHh79xklEREREZMhYeCEiIiIiop8kMzMTtra2ePTRRxEdHY2oqCgEBQXd1RjGxsbIysrC9u3b4ejoiJiYmD77vvbaa3j77bdRXl6OqKgo+Pj44Pe//z38/f2VlSJ3GlNqaipOnz6NwMBAvPzyy8jMzERUVBQAICAgAJmZmXjttdfg6+uLPXv24NVXX9V5v7e3Nw4fPowzZ87gkUceQWhoKN57770+VwmtXr0aDQ0N8PDw6HWbroULF6Kzs7PfFSo9/Pz8EBQUhNzc3D77GBsbw87O7rYrliIiItDa2qo836VHWFgYWltb9RZe/v73v2Px4sW3jZOIiIiIyJCp5E6fUklERERERDQMuLm5ISUlBSkpKUMdCgBg9+7dWLZsGb744gvl1mv9ef/995GWlobq6mqMGDF436U7d+4cpk2bhgsXLsDGxmbQ9ktEREREdL/p/ytQREREREREdE+0t7dDq9Vi3bp1eP755++o6AIATz75JGpra3H58mWMHz/+Hkf5A61WizfffJNFFyIiIiKi2+CtxoiIiIiIiIbA+vXrMXHiRKjVaqxatequ3puSkjKoRRcAmD59unI7NiIiIiIi6htvNUZERERERERERERERDRAuOKFiIiIiIiIiIiIiIhogLDwQkRERERERERERERENEBYeCEiIiIiIiIiIiIiIhogLLwQERERERERERERERENEBZeiIiIiIiIiIiIiIiIBggLL0RERERERERERERERAOEhRciIiIiIiIiIiIiIqIBwsILERERERERERERERHRAGHhhYiIiIiIiIiIiIiIaID8H5y+KfSB/P77AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] diff --git a/library/cables/XLPE_630mm_33kV.yaml b/library/cables/XLPE_630mm_33kV.yaml index 27839b82..0ffd37cd 100644 --- a/library/cables/XLPE_630mm_33kV.yaml +++ b/library/cables/XLPE_630mm_33kV.yaml @@ -5,5 +5,8 @@ cost_per_km: 450000 current_capacity: 700 inductance: 0.35 linear_density: 42.5 +cable_type: HVAC name: XLPE_630mm_33kV rated_voltage: 33 + + diff --git a/osw_project_details.xlsx b/osw_project_details.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..266227052b890fddfb21c984b61c8c240a0bee52 GIT binary patch literal 10551 zcmeHtg;yNe_I2X~cM0wejXMN)4<6jzouC1Ny9bvfI0ScTJP_R7o!}0?o_X`WnaRBG zFL+G}7J@+WfK|x~yU;*#|0Duf&e3E6U4*>wgK?4Ao0C-4UF$a5B zGkaHqw_c8BE_%$KcDAJX(2%sb07&rl|2zJRXP_);Sg{9)CUGPED7M8UyHxWAp7S`U zAA?>+s1uafS7M@@ZDsY69sYnOnul%8U5)W$$%pN1#InZTu0H5vUyCYIWZ*!jx;_Cn zOK<-XRR=D9g0qhHX)YGQ8&-S+gJ|w2$eDp6inPi|N$$ge^-1Uo;$+Xnyj8&VQ?^EU4 zU1%HGrwvUYSAd~$Z79p5tFSHY+{6kTuWP`F$Yk#iLAvbXS4tD9wdxiAV2)Gn{@esY8{ghv`S#woE;lys)$E!$GBG1 zpDnJ$%S|8T_jzEjk*8DX*o4s6zIYsN3tHm#1?w7pzxkq56m77RjPiZh@!G&Xzt7Rw zwr=prS<1dY+cPWx@bUr$Q2rY&>(qf1mtbF$2eS?lOiKf2Gg}uH=HJHu(eb~SgMWGS zvIGUC9w1Wasq|ymz|Hh>9Ga+{hlq3w*;~H=nI+V^=mJWD=&7AkB%R9ELFn$&SJT(&QnFsO?rpL3rHxWiYrcMkSwt9$BbXkj)2E=lVtiWxF)gZgTpn80z@2-L_#@MQHl=tU zS@axVi@+s+H|%nr;aUna#*1FGa4 z7`JRcr246Hul#jtInIW&yg=NqdP)a=4hBV%d|3f2)IUk`HP5it3JL%)1WOqzcxF6p zSv(w^ZHyfpY<|qIk-w|PcjJ_oCE0Gtia1a zzaSz}A=|DUN7NXxbE3iQrqT86WF+B1`X!SP2Sex=uGbJY_?47ZUOD23*Gumnj$FHJ z+_|-8^Gl~S7xv_*>(wU}733Yc)NARHAN9-`RZ#u24!cMNuJwfSj=QMFMhOS>F_127}*eHQHLRyYDXmNSu%(cR_{z(Bc0+T)f=(3?P$(c zYULSFCiJE|uO`U97^9$db&3)cZ541wrr0H-a`A)YoYXBpdn^}Hdqp_a%$;eg%Qk)* zhfBpOvm~f7)(nU}9EFa7cbDP|vYRsdERTA<@h0~6R-l`LWc@2HsW5R9?X@7T*)u2$ zcHEUs0V<2+{WHx=Kb_^f>?0w@3^R$M3>h89br;tj9J=F9-{G3F> zJJSy;8KFW5)J?eJrU?pACdGkeDIK?4_*ncqR+8$dS6}5OqcE3u7U!R~jML_J_Qj5= zxG~#K7eD)Bdmt_f-6XR}?fK^aA6XeF zl$3e_W@9s0x?Tg|A;7HsmwNq`oBvia2ykKvw({S7l&LDnfq-ajh|gg_k4$%L^m$hn z@+0*_RQSPKxtr5R~ho#4eC>bu8O+pC+jM-Q`JGZn{_+bUbi26QLZ|qd+${ zYnL&iA#fxguH6c_|DbkM9#q@VK$<~kzWvf9ws;Mj6XZoQeu4i=MgZ9hFupfM#&Fvu zaSeao`e?4;HEPpUaF4W2SSm+c!YSw*>Pi|mAVuO&m*BFUpWdQ=y6!6aFhtj}c+NO{ zd1}5j*gw4re$)R9U`ddW*lsFhu07MHt zr5NGYYKLM)tD!BNmf<@{*#Tx;9i@?12eF#)%h^nw3YiT|s4}Og00@i! zuYofus&EVS>59WR^wj$)I~zBtS#@c2e>b_6J2GPrAQTa`b7^*} zz?X{0CQx1qZ4P|>lC(g3@^iY3Vi9jmf}pU3_T;KY+DUsd2FP^-bk&xHKxA@9u$~n` zdb?!w>`p=8Q%vWCs_67>nKN*#Lvt3^ZV7 zUl}C-?7!LHrRGo_73|3+9h8JTVF*&iiAssQV?6nWuPe|tzF!#E*t3Gos=RXF6-N0QM+^ zrid_^RhN(ov>>JYLg9cpkH@(fIPFFS#Z9BMYfKypQ<0{*&)F^hZZmKU2D)?X9whR8|y?|`Ss*4zdO+HLz4Ef{UQ*_ zH<=u@N~pcONOt`9#$tWj_)63 z>o?@ID`UbAt3b0x(dd#f1lqzey+%(?0%es!mW1k{@7= zvj;f?o#-IWkA>q#YKJn;`KVG;#s{ASBJZ=D+E{y{NxmICxg%PcgaxB1*;W8WY*zry zCN8h`^x@w2Kgr^y$l+ml4$-4o4aKil1Q6NG+r!s11-ZE6)WZ4nUt{Pm90nZR?tCz+ z`#=^*6UyHRl??nar&G@_aAI50>5JnUh%|41tqithff0Iz5el7+cM`a+j4l*2nkubA z=qWpI%cU}gf-zV99@V2@7G0gS@WY1rD+x#?tg|)F%^0|CUDD99nX{*@nODZD%^PqRQ;|wy;1cs!Z9BMdmR*xZ ze;AKZI)JTIVL%c1YRg5VK8B6+wwmHbzyGa;cc0%Y8Az#wG1W{#l4+t9$!aklv(mhQ z9l;a=ksj=0Hvx55YPe}^IXsj-Y4j2!v6Z~7q++{|JtB&V#@rmeF--^Ee3I0ARR?pt zYQ>}#=5Mj`DAX+bqFpE^hdyaJX%(+SV9D4v$j`^jwtT)a(Q;b~NZKba+N`Z{96KX8 zkFf)}#;*apm8Vc5Ai8Fi`B@;fVn^k<)E%bzST~eD8*dj_hArzm8=&^*XHZdPH zzVTrcUx$#^&H)u6yl?&*Sr|L13gzP=rauF#b-TFMmB8RWoUD1y-=mI&Ia5ekMPG2f zM2^mpyIG%)M1DF@=dR^NgX*_nnl$#I|C|BEVMvuc)H&5H{9xld$a)D775Eef*i4kA6Rr49i6YuGMG~`sVE^h}F{PPS&Nfdt~?aKt@dm zoh9EJ(kAaMvrBO(RyZ``fr@TtD$VtmDNg-)wmBgCCWIAdv)}Da&@XE;CGIp?>uo65 zn6YjmOjVU561P_3S97c@*d>G*!%6Q#>tKx3oay*@+U9I+%SQHEI0NvjGZFEBeu3w6 zGBi6$Y#jQYnl_tZnO%ZI;;H&t$0qk+1RpzWKgYP?t;EAxXCb0PXIEFJu{FTD$yKwC zHsf=NL_9YXX*yt9a^ztNo>lmT(LI=kyNun0Vp>&^a zqk6OAJC9|z$qUx+_r00#YEZ|Vv0LJXj?>i_$y~xTyVi9`&jvSbuQm9+9TcDW>{;%+ zGjAEVu5ve~(=$3h9>{alXZAsTF}| znyR!z@;?Hq<<1d1^NVE>WbUY_?wWx5lGetu*61HC$_nFBatt6h_ZH{(Qg?C9a4iap zQ|5lltp2ICUASoNir_!&BmJ%9_q*D*|kGG}ze^S_v>Asd%qcX$y-|MI8i_Cf-0Hw_V1*qO9E~8K)VU zqbT2|%(Ru&aYv4ndT#st`6k=X`@;2XqAkr^Dh;taA;q9w`CRZ*)La_nWQxBH4=snU zl5|oOy4frHJ4D7uxy2kmXLP$k`2IPlJ8|2*6cQQUMS7fG_|W*qPII2XRqCjI>28V~ zoPI*0;FUBSh9cE+Jc@){{UBpypZ9EJ6i3L(vi?3_Tb0&X<3*99Xje5$s;Tm-H+yPC zKZfk7o)D2OoEv4c@)K|POx)07VE9?yQ9bSAHn8A~Yfy`C!)lA!=f1Et$s77=jk}!h zcUe!6!Uya46d6E$dDnk+_@vWOKk*sDk|QX&xPFfBFxfuN2wC}lIaMu?%#3X626cl^ZT?l*MJ78$+2x z>a0DQ7O+jb_hK+tkb*_p66k)Y#37d+sjA6qk#leBM4hk+0RkXZDP=YWdy$mJ;A5ygBZ!3iYpNlCX>Va&9$$Ez2S_G=sp2na-`T9qO+-Yu7 zmTW2G z!>JuFXM9&x8%x+M?eEXe_Y-kf-(T%2#S$$n5)!5TBnz+pS+Q<%N*!qwi1Kg-A)EyQ zih>f}pzpbVIT;>+)Ym0F=yt0*?p`F+>Vs(&=&+e@COK=Oj7hJQtcF=KiE_vD;9D!n z82!T`vR8ihaUtCa(P`QS6so_<9_meq! zBg~d{MiR}(d$UoZ>ei_AHWFOdpsGl-1%djxx{+{pe!h#Z$qOxbYOYazcs>n6E?Q$o z?8CcFQ|o(Am zjqhuXPkP;OJ%XlU6C_|13Xgzm~FLe5@uCGL_(_4K5hp11__rUAt>TPziq?2Ko-WE}h_t355QE}DP1X>j zf(Ok_bM)SNJB*97}>ZF*}|1;S{$q<13w z*K`PFV-|MOSXZ_AW+yLeH>;91i9#ldDA#Y%zzJXw?m8p?NXmnDUvqlc6q{0$aT9?v z`$04+x{U-mO=BQ6wb~en-~O)78oq&^g2Uzxa}Td)))TggVoDb`U#-y{UnblB*25?T zAGanm zGM-AdB1z!7T7~0tN$)CA8Ra}-cNZ zr>b`cZuF>YhVd%zP$m!WA>J8{Nw`~8_Rlh(Y;H4+grG-8${T#gty{m}Xn!~F>vW1v zn)OgOl&fv$ZXIG?CrAt3rdR;34e^EOm+PJ)doNdw6AJunqd-Pkn6_6w2e~LQIrS#c4sQ%;uGDxqTv-oE+bRqB;YOt$ zbh2Qlcb_1g%=_onV7i(|&Z z4|=$^cINGv&@$#9Dzz9gv~9E zx(@=aj!tVu?uu5;2O7bnA>qq?3^6=hWb88K5SHd^{5TZ0SuINR+BPQzo<(c(N^EhU zpY2E>Cx^Ai4Rr95Zh?(gt*zh9h5Hn2E2L}R9qr6aoVYSpsC9Zb-N8(z$tw|=FRLkp zgijaOiirgz9}3{?H-X{xvb$p}Vktgq7*0BP@CM(OSDp#fyH7Rnp*WMpc`5j*UNyY3 z7SX@LSU}}t>N7{pnn3I|RkX?I_vEsptyk2)9_I~CGE2JPkGwADIctDX!IdT!r~l4G z+6`TGekCWZ(O}ElKtRxgSKdq9r8pWS;pWu+f=Nem+a`{1^kgGGlt5zFyQpLDQ7Tz) zW_SJV^G-FpKdW1h%Zib~^V84}fFV8wub=h3KlwMEEZMBz`*o#XP0! z#2D(#xBUZZ`5yF}pWnxio7z|Xpc(HRtm7twUu!f=h<~ z%vWc>Nh*bde*uCCgY^etERCGaOx0YSt?Vs+=gkK&Zx-I5y|0||*SgD-Eu>T=zskq? z*!cz{IR*anI_v8r2#2$i<`$DLFYP8l^aq^#1S{+}F6Mhnj~Y#Lxo#7C_Kt2&`0!KV zGDZ4s!6dPp7fOMS(0n0FmPfGI&1=Os*9!f-7)Pag+yfsYei-c~AYnHms^yxST9rX= zD77Hy8KJADk|hlF91aho=0SdiiceEjkoMKqf&|2G9mn=G2O3x5B8| zk+!`_Xd_{^$^xkG7cFM?DyQ3L4TbTNE$2xDm1bv{2`S+^I2taB4=F6rHSe_7EJXSQvY7Eo8!nIdMwgb}`3uE-$O>J=|>=}7{SbI7j@b4St4 zsXI3Dd0`9DCJMLY2h=wV&>#-)4u8y@1hBx>o7$Z}HSk;#pusL2xpX=t+DjDnV-?R?-GJrv=hVggsm=S!AE4mxni|Bl80W(Jr@!q# z{nK?3=5Znvz$)Mdc3*UGE!@<>MA_NF(S^mt!P)GO-irT~z`;`&m0+OM4aDkQRd_^^ z%UNy~Rko~;&s~?nz%=J*=RAhNnGv=s4R&y7=mM<;#~$dFgh9M@nYiE)oa-t?)55s;nqVeDe>66j$9azUYI#RZ{CUsxTYkn)7SrldUu z%D_LLc~?z5@s82qDr(;qyvkB^Vwn%R*;o^5v<7l1BywyrOAaXgd^qr0R*zfwkB#`JKakZ7M z8Y_LVO4}IN1+L=8q8qLn32?H-Nm0TJXdOF?V^1Lh5_fR%^1}g{-}gSeL;Ddx-lIuU zbo(D$35;Z3p@oBe5FMOzp#9YcjT{~S=YnA0`{VeOAmRW{y+Tf*?n#iA33!*4kpjz% zr8O_Bj35%~Efk7P@@gnQmc<{<#@3Hd&3hk2Z~1uMi_0t%@)=yljrS^tZ|7sdKoi*D zUMG9bE$jJV!z8?_J7axA6%()_Y2d4xNr-9c8~`H)T_!GZL!X^kct91SX$GX;z$b5IhDGPMOzF~S0X_!FCe=8>Et1gR5sm^)cP&-Hs${F zH(q1gFSmYGYssG?BlhbJ4QdJsn3F#>SldL0al#$;c|udI!X6NRud0o9!mm59nhq{X zLv;1`wA0MLwL^pbBzsBCkNL40c5y1IPDxr@xc4!N36Pgyn-*%qdoyZtBf%mCg}d8F zW(aAtPUy5d0QGFmMLo$68sgghna!1h39x|~rJc0Ya50Tg)NyzIF;_g3*^zSFZ{r&@ik zc}Dzq2!()T0xSK0Zc+R9>-zWkKQyc<%l+NJ->e2LSZR0Dym}>aXy> ihrqwWHz@uB|05tO%fW!(E&zZ4{se%9JCFLeZ~q58h^zhp literal 0 HcmV?d00001 diff --git a/param_model.ipynb b/param_model.ipynb new file mode 100644 index 00000000..c68466b3 --- /dev/null +++ b/param_model.ipynb @@ -0,0 +1,1001 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "85c306d1-3bb1-46ac-a752-0aa5ccc7b48f", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" + ] + }, + { + "cell_type": "markdown", + "id": "179873b1-f957-4c87-b46b-ef5fc7723a4a", + "metadata": {}, + "source": [ + "# Cable Cost" + ] + }, + { + "cell_type": "markdown", + "id": "a420ca9c-7f7f-40a3-a456-c7f0bceb8e2c", + "metadata": { + "tags": [] + }, + "source": [ + "## Distance to Shore" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d088b5f9-6c52-4513-9915-4deb32b59d5f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + "# 'distance_to_landfall': 60\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10,\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': 'XLPE_500mm_220kV',\n", + " }\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7c32e7c8-bb3b-4c7b-b7fb-e0e34e1d3005", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + " 'site.distance_to_landfall': np.arange(50,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(300,2100,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "834f7c24-26ee-4121-9acf-0ce49edba906", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6e244129-a23c-455b-a754-2ba4133b618f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" + ] + }, + { + "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", + "
site.distance_to_landfallplant.capacitycable_costoss_cost
0503007.051660e+076.281680e+07
1504007.051660e+076.951580e+07
2505001.057749e+089.003345e+07
3506001.057749e+089.673245e+07
4507001.057749e+081.034314e+08
...............
31930516001.433833e+096.780425e+08
32030517001.433833e+097.009405e+08
32130518001.638666e+097.856789e+08
32230519001.638666e+097.901449e+08
32330520001.843500e+098.782329e+08
\n", + "

324 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " site.distance_to_landfall plant.capacity cable_cost oss_cost\n", + "0 50 300 7.051660e+07 6.281680e+07\n", + "1 50 400 7.051660e+07 6.951580e+07\n", + "2 50 500 1.057749e+08 9.003345e+07\n", + "3 50 600 1.057749e+08 9.673245e+07\n", + "4 50 700 1.057749e+08 1.034314e+08\n", + ".. ... ... ... ...\n", + "319 305 1600 1.433833e+09 6.780425e+08\n", + "320 305 1700 1.433833e+09 7.009405e+08\n", + "321 305 1800 1.638666e+09 7.856789e+08\n", + "322 305 1900 1.638666e+09 7.901449e+08\n", + "323 305 2000 1.843500e+09 8.782329e+08\n", + "\n", + "[324 rows x 4 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric.run()\n", + "parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7244d57c-7cc4-4c77-9572-bfdf89c62eb8", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "FutureWarning: C:\\Users\\sbredenk\\.conda\\envs\\orbit-sophie\\lib\\site-packages\\statsmodels\\tsa\\tsatools.py:142\n", + "In a future version of pandas all arguments of concat except for the argument 'objs' will be keyword-only" + ] + }, + { + "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", + "
OLS Regression Results
Dep. Variable: cable_cost R-squared: 0.913
Model: OLS Adj. R-squared: 0.912
Method: Least Squares F-statistic: 1680.
Date: Fri, 29 Oct 2021 Prob (F-statistic): 8.77e-171
Time: 14:39:52 Log-Likelihood: -6469.5
No. Observations: 324 AIC: 1.294e+04
Df Residuals: 321 BIC: 1.296e+04
Df Model: 2
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
const -5.423e+08 2.11e+07 -25.642 0.000 -5.84e+08 -5.01e+08
plant.capacity 4.807e+05 1.22e+04 39.314 0.000 4.57e+05 5.05e+05
site.distance_to_landfall 3.473e+06 8.15e+04 42.605 0.000 3.31e+06 3.63e+06
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 2.305 Durbin-Watson: 0.813
Prob(Omnibus): 0.316 Jarque-Bera (JB): 2.033
Skew: 0.142 Prob(JB): 0.362
Kurtosis: 3.265 Cond. No. 4.24e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 4.24e+03. This might indicate that there are
strong multicollinearity or other numerical problems." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: cable_cost R-squared: 0.913\n", + "Model: OLS Adj. R-squared: 0.912\n", + "Method: Least Squares F-statistic: 1680.\n", + "Date: Fri, 29 Oct 2021 Prob (F-statistic): 8.77e-171\n", + "Time: 14:39:52 Log-Likelihood: -6469.5\n", + "No. Observations: 324 AIC: 1.294e+04\n", + "Df Residuals: 321 BIC: 1.296e+04\n", + "Df Model: 2 \n", + "Covariance Type: nonrobust \n", + "=============================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "---------------------------------------------------------------------------------------------\n", + "const -5.423e+08 2.11e+07 -25.642 0.000 -5.84e+08 -5.01e+08\n", + "plant.capacity 4.807e+05 1.22e+04 39.314 0.000 4.57e+05 5.05e+05\n", + "site.distance_to_landfall 3.473e+06 8.15e+04 42.605 0.000 3.31e+06 3.63e+06\n", + "==============================================================================\n", + "Omnibus: 2.305 Durbin-Watson: 0.813\n", + "Prob(Omnibus): 0.316 Jarque-Bera (JB): 2.033\n", + "Skew: 0.142 Prob(JB): 0.362\n", + "Kurtosis: 3.265 Cond. No. 4.24e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 4.24e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\"\"\"" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = parametric.create_model([\"plant.capacity\",\"site.distance_to_landfall\"],'cable_cost')\n", + "model.sm.summary()\n", + "# model.predict(parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e4b7c985-4e62-4717-86d1-bfd37d158dd7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 4.182942\n", + "1 3.501289\n", + "2 2.213090\n", + "3 1.758655\n", + "4 1.304219\n", + " ... \n", + "319 0.103110\n", + "320 0.069586\n", + "321 0.156554\n", + "322 0.127221\n", + "323 0.198122\n", + "Name: cable_cost, Length: 324, dtype: float64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.perc_diff" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "18672b9d-0854-4e44-8753-43a768775ca0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAGdCAYAAACyzRGfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAXrUlEQVR4nO3df2xV9f348VcRW1TaYhHbEehg0YjGwCKKdi6bw05CiJGIi0uWDJnZMlOI2GWTJptEswWyJf7a8Ec2h1kiwfgHGiXqTKfwh4BYQoIayUw0NGMtWwwt9hsKoff7x7LmU0FHy+3rci+PR3L+6Lmn57562tBnDrfvW1UoFAoBAJBkQqkHAADOLeIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEg1sdQDfN7Q0FAcPHgwamtro6qqqtTjAACnoVAoxJEjR2L69OkxYcKX39s46+Lj4MGDMXPmzFKPAQCMQXd3d8yYMeNLjznr4qO2tjYi/jN8XV1diacBAE5Hf39/zJw5c/j3+Jc56+Ljv//VUldXJz4AoMyczksmvOAUAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVBNLPQDlZ9aarSft+2T9khJMAkA5cucDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEh1RvGxfv36qKqqitWrVw/vO3r0aLS1tcXUqVNj8uTJsWzZsujt7T3TOQGACjHm+Ni9e3c8/fTTMXfu3BH777vvvnj55ZfjhRdeiG3btsXBgwfj9ttvP+NBAYDKMKb4+Oyzz+IHP/hB/PGPf4yLL754eH9fX18888wz8fDDD8fChQtj/vz5sXHjxnj77bdj586dRRsaAChfY4qPtra2WLJkSbS2to7Y39XVFcePHx+xf86cOdHc3Bw7duw45bkGBwejv79/xAYAVK6Jo/2EzZs3x549e2L37t0nPdbT0xPV1dUxZcqUEfsbGxujp6fnlOdbt25dPPjgg6MdAwAoU6O689Hd3R333ntvPPfcczFp0qSiDNDR0RF9fX3DW3d3d1HOCwCcnUYVH11dXXHo0KG45pprYuLEiTFx4sTYtm1bPP744zFx4sRobGyMY8eOxeHDh0d8Xm9vbzQ1NZ3ynDU1NVFXVzdiAwAq16j+2+Xmm2+Offv2jdi3YsWKmDNnTtx///0xc+bMOP/886OzszOWLVsWERH79++PAwcOREtLS/GmBgDK1qjio7a2Nq6++uoR+y666KKYOnXq8P6777472tvbo6GhIerq6mLVqlXR0tISN9xwQ/GmBgDK1qhfcPq/PPLIIzFhwoRYtmxZDA4OxqJFi+KJJ54o9tMAAGWqqlAoFEo9xP/V398f9fX10dfX5/UfZ6lZa7aetO+T9UtKMAkAZ4vR/P723i4AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQKqJpR6As8usNVtP2vfJ+iUlmASASuXOBwCQSnwAAKnEBwCQSnwAAKnEBwCQSnwAAKnEBwCQyjofFMXn1wexNggAX8SdDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAg1cRSD8DZb9aaraUeAYAK4s4HAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBKfAAAqcQHAJBqVPHx5JNPxty5c6Ouri7q6uqipaUlXn311eHHjx49Gm1tbTF16tSYPHlyLFu2LHp7e4s+NABQvkYVHzNmzIj169dHV1dXvPvuu7Fw4cK47bbb4v3334+IiPvuuy9efvnleOGFF2Lbtm1x8ODBuP3228dlcACgPFUVCoXCmZygoaEhfve738Udd9wR06ZNi02bNsUdd9wREREffvhhXHnllbFjx4644YYbTut8/f39UV9fH319fVFXV3cmozEGs9ZsLcp5Plm/pCjnAaA8jOb395hf83HixInYvHlzDAwMREtLS3R1dcXx48ejtbV1+Jg5c+ZEc3Nz7Nix4wvPMzg4GP39/SM2AKByjTo+9u3bF5MnT46ampr46U9/Glu2bImrrroqenp6orq6OqZMmTLi+MbGxujp6fnC861bty7q6+uHt5kzZ476iwAAyseo4+OKK66IvXv3xq5du+Kee+6J5cuXxwcffDDmATo6OqKvr2946+7uHvO5AICz38TRfkJ1dXVcdtllERExf/782L17dzz22GNx5513xrFjx+Lw4cMj7n709vZGU1PTF56vpqYmampqRj85AFCWznidj6GhoRgcHIz58+fH+eefH52dncOP7d+/Pw4cOBAtLS1n+jQAQIUY1Z2Pjo6OWLx4cTQ3N8eRI0di06ZN8dZbb8Xrr78e9fX1cffdd0d7e3s0NDREXV1drFq1KlpaWk77L10AgMo3qvg4dOhQ/PCHP4x//vOfUV9fH3Pnzo3XX389vvvd70ZExCOPPBITJkyIZcuWxeDgYCxatCieeOKJcRkcAChPZ7zOR7FZ56O0rPMBwFikrPMBADAW4gMASCU+AIBU4gMASCU+AIBU4gMASCU+AIBU4gMASCU+AIBUo35XWzgdp1op1aqnAES48wEAJBMfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBpVfKxbty6uu+66qK2tjUsvvTSWLl0a+/fvH3HM0aNHo62tLaZOnRqTJ0+OZcuWRW9vb1GHBgDK16jiY9u2bdHW1hY7d+6MN954I44fPx633HJLDAwMDB9z3333xcsvvxwvvPBCbNu2LQ4ePBi333570QcHAMrTxNEc/Nprr434+Nlnn41LL700urq64lvf+lb09fXFM888E5s2bYqFCxdGRMTGjRvjyiuvjJ07d8YNN9xQvMkBgLJ0Rq/56Ovri4iIhoaGiIjo6uqK48ePR2tr6/Axc+bMiebm5tixY8cpzzE4OBj9/f0jNgCgco05PoaGhmL16tVx4403xtVXXx0RET09PVFdXR1TpkwZcWxjY2P09PSc8jzr1q2L+vr64W3mzJljHQkAKANjjo+2trZ47733YvPmzWc0QEdHR/T19Q1v3d3dZ3Q+AODsNqrXfPzXypUr45VXXont27fHjBkzhvc3NTXFsWPH4vDhwyPufvT29kZTU9Mpz1VTUxM1NTVjGQMAKEOjuvNRKBRi5cqVsWXLlvjb3/4Ws2fPHvH4/Pnz4/zzz4/Ozs7hffv3748DBw5ES0tLcSYGAMraqO58tLW1xaZNm+Kll16K2tra4ddx1NfXxwUXXBD19fVx9913R3t7ezQ0NERdXV2sWrUqWlpa/KULABARo4yPJ598MiIibrrpphH7N27cGHfddVdERDzyyCMxYcKEWLZsWQwODsaiRYviiSeeKMqwAED5G1V8FAqF/3nMpEmTYsOGDbFhw4YxDwUAVC7v7QIApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBIfAEAq8QEApBrTu9pSOWat2VrqEQA4x7jzAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkEh8AQCrxAQCkmljqAcgza83WUo8AAO58AAC5xAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACpJpZ6AM4ds9ZsHfHxJ+uXlGgSAErJnQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AIJX4AABSiQ8AINWo42P79u1x6623xvTp06OqqipefPHFEY8XCoV44IEH4itf+UpccMEF0draGn//+9+LNS8AUOZGHR8DAwMxb9682LBhwykf/+1vfxuPP/54PPXUU7Fr16646KKLYtGiRXH06NEzHhYAKH8TR/sJixcvjsWLF5/ysUKhEI8++mj88pe/jNtuuy0iIv7yl79EY2NjvPjii/H973//zKYFAMpeUV/z8fHHH0dPT0+0trYO76uvr4/rr78+duzYccrPGRwcjP7+/hEbAFC5Rn3n48v09PRERERjY+OI/Y2NjcOPfd66deviwQcfLOYY56RZa7aetO+T9UtKMAkAfLmS/7VLR0dH9PX1DW/d3d2lHgkAGEdFjY+mpqaIiOjt7R2xv7e3d/ixz6upqYm6uroRGwBQuYoaH7Nnz46mpqbo7Owc3tff3x+7du2KlpaWYj4VAFCmRv2aj88++yw++uij4Y8//vjj2Lt3bzQ0NERzc3OsXr06fv3rX8fll18es2fPjl/96lcxffr0WLp0aTHnBgDK1Kjj4913343vfOc7wx+3t7dHRMTy5cvj2WefjV/84hcxMDAQP/nJT+Lw4cPxzW9+M1577bWYNGlS8aYGAMrWqOPjpptuikKh8IWPV1VVxUMPPRQPPfTQGQ0GAFSmkv+1CwBwbinqOh+cXU619gcAlJo7HwBAKvEBAKQSHwBAKvEBAKQSHwBAKvEBAKQSHwBAKvEBAKQSHwBAKvEBAKQSHwBAKvEBAKQSHwBAKvEBAKQSHwBAqomlHoCRZq3ZetK+T9YvKcEkADA+3PkAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFJZ56MMnWotEAAoF+58AACpxAcAkEp8AACpxAcAkEp8AACpxAcAkEp8AACprPMxjj6/Hscn65eUaJLy4ZoBVD53PgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVNb5KAOfX/uiUoz167IWCEB5c+cDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEhlnY8Sq9Q1PM42p7rOn18f5HSOKdZzAZzL3PkAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFJZ5+M0jHWNCM7cWK9r5vejlN97a4oA5cidDwAglfgAAFKJDwAglfgAAFKJDwAglfgAAFKJDwAgVVWhUCiUeoj/q7+/P+rr66Ovry/q6uqKfn7rcTAap7Nmxlh+psa6Fkexnuvz5xnPeU5nTZyxHDOeTuf6jOUalvrrKpZK/TrK8Ws4HVnfr9H8/nbnAwBIJT4AgFTiAwBINW7xsWHDhpg1a1ZMmjQprr/++njnnXfG66kAgDIyLvHx/PPPR3t7e6xduzb27NkT8+bNi0WLFsWhQ4fG4+kAgDIyLvHx8MMPx49//ONYsWJFXHXVVfHUU0/FhRdeGH/+85/H4+kAgDIysdgnPHbsWHR1dUVHR8fwvgkTJkRra2vs2LHjpOMHBwdjcHBw+OO+vr6I+M+f7IyHocH/Ny7npTKdzs/hWH6mxvrzXazn+vx5xnOez5/7VJ8zlmPG0+lcn7Fcw1J/XcVSqV9HOX4NpyPr+/Xfc57WCh6FIvvHP/5RiIjC22+/PWL/z3/+88KCBQtOOn7t2rWFiLDZbDabzVYBW3d39/9shaLf+Ritjo6OaG9vH/54aGgoPv3005g6dWpUVVWN6Zz9/f0xc+bM6O7uHpeFys51ru/4cn3Hl+s7vlzf8Xe2XuNCoRBHjhyJ6dOn/89jix4fl1xySZx33nnR29s7Yn9vb280NTWddHxNTU3U1NSM2DdlypSizFJXV3dWfWMqjes7vlzf8eX6ji/Xd/ydjde4vr7+tI4r+gtOq6urY/78+dHZ2Tm8b2hoKDo7O6OlpaXYTwcAlJlx+W+X9vb2WL58eVx77bWxYMGCePTRR2NgYCBWrFgxHk8HAJSRcYmPO++8M/71r3/FAw88ED09PfH1r389XnvttWhsbByPpztJTU1NrF279qT/zqE4XN/x5fqOL9d3fLm+468SrvFZ9662AEBl894uAEAq8QEApBIfAEAq8QEApKr4+PjNb34T3/jGN+LCCy8s2uJl57INGzbErFmzYtKkSXH99dfHO++8U+qRKsb27dvj1ltvjenTp0dVVVW8+OKLpR6poqxbty6uu+66qK2tjUsvvTSWLl0a+/fvL/VYFePJJ5+MuXPnDi981dLSEq+++mqpx6pY69evj6qqqli9enWpRxmTio+PY8eOxfe+97245557Sj1K2Xv++eejvb091q5dG3v27Il58+bFokWL4tChQ6UerSIMDAzEvHnzYsOGDaUepSJt27Yt2traYufOnfHGG2/E8ePH45ZbbomBgYFSj1YRZsyYEevXr4+urq549913Y+HChXHbbbfF+++/X+rRKs7u3bvj6aefjrlz55Z6lLErztvJnf02btxYqK+vL/UYZW3BggWFtra24Y9PnDhRmD59emHdunUlnKoyRURhy5YtpR6joh06dKgQEYVt27aVepSKdfHFFxf+9Kc/lXqMinLkyJHC5ZdfXnjjjTcK3/72twv33ntvqUcak4q/80FxHDt2LLq6uqK1tXV434QJE6K1tTV27NhRwslgbPr6+iIioqGhocSTVJ4TJ07E5s2bY2BgwNtqFFlbW1ssWbJkxL/F5ajk72pLefj3v/8dJ06cOGmV2sbGxvjwww9LNBWMzdDQUKxevTpuvPHGuPrqq0s9TsXYt29ftLS0xNGjR2Py5MmxZcuWuOqqq0o9VsXYvHlz7NmzJ3bv3l3qUc5YWd75WLNmTVRVVX3p5hci8EXa2trivffei82bN5d6lIpyxRVXxN69e2PXrl1xzz33xPLly+ODDz4o9VgVobu7O+6999547rnnYtKkSaUe54yV5Z2Pn/3sZ3HXXXd96TFf+9rXcoY5R1xyySVx3nnnRW9v74j9vb290dTUVKKpYPRWrlwZr7zySmzfvj1mzJhR6nEqSnV1dVx22WURETF//vzYvXt3PPbYY/H000+XeLLy19XVFYcOHYprrrlmeN+JEydi+/bt8Yc//CEGBwfjvPPOK+GEo1OW8TFt2rSYNm1aqcc4p1RXV8f8+fOjs7Mzli5dGhH/uXXd2dkZK1euLO1wcBoKhUKsWrUqtmzZEm+99VbMnj271CNVvKGhoRgcHCz1GBXh5ptvjn379o3Yt2LFipgzZ07cf//9ZRUeEWUaH6Nx4MCB+PTTT+PAgQNx4sSJ2Lt3b0REXHbZZTF58uTSDldm2tvbY/ny5XHttdfGggUL4tFHH42BgYFYsWJFqUerCJ999ll89NFHwx9//PHHsXfv3mhoaIjm5uYSTlYZ2traYtOmTfHSSy9FbW1t9PT0REREfX19XHDBBSWervx1dHTE4sWLo7m5OY4cORKbNm2Kt956K15//fVSj1YRamtrT3p90kUXXRRTp04tz9ctlfrPbcbb8uXLCxFx0vbmm2+WerSy9Pvf/77Q3NxcqK6uLixYsKCwc+fOUo9UMd58881T/qwuX7681KNVhFNd24gobNy4sdSjVYQf/ehHha9+9auF6urqwrRp0wo333xz4a9//Wupx6po5fyntlWFQqGQnzwAwLmqLP/aBQAoX+IDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEglPgCAVOIDAEj1/wHJin/juovkagAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(model.perc_diff,bins = 100)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7830989-75d8-4641-9a9c-42d436540be1", + "metadata": {}, + "outputs": [], + "source": [ + "# dist = np.arange(50,315,15)\n", + "# cap = np.arange(300,2100,100)\n", + "# cablecost = np.zeros(len(dist))\n", + "# # print(len(cap))\n", + "# for i in np.arange(0,len(dist)):\n", + "# cablecost[i] = parametric.results.cable_cost[19*i]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3085fb7f-e958-4294-9cab-fb27d6e81a72", + "metadata": {}, + "outputs": [], + "source": [ + "# print(cablecost)\n", + "\n", + "# ax = plt.axes(projection = '3d')\n", + "# ax.plot3D(dist,cap,model.predict(parameters))\n", + "# ax.plot3D(dist,cap,cablecost)\n", + "# plt.legend([\"predict\",\"orbit\"])\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f3d24be3-426f-47ec-ae71-fcf846d4d5f6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# dist = np.arange(50,315,15)\n", + "cap = np.arange(300,2100,100)\n", + "\n", + "plt.plot(cap,parametric.results.cable_cost[0:18])\n", + "plt.plot(cap,model.predict(parameters)[0:18])\n", + "plt.legend([\"orbit\",\"predict\"])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f52c8961-6f5a-434e-889b-2db674676991", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "18" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(model.predict(parameters))" + ] + }, + { + "cell_type": "markdown", + "id": "c816316c-280c-4074-b655-92e6376c63eb", + "metadata": { + "tags": [] + }, + "source": [ + "## Plant Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9a698314-0788-467d-88ac-fc8c9f89de77", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config1 = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + "# 'distance_to_landfall': 60\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10,\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': 'XLPE_500mm_220kV',\n", + " }\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6f86ae09-caa4-4816-92d3-fa565adb12e7", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + " 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4142db72-839f-4ec3-9a9b-645d16ed61ef", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "28f880f4-d092-4441-8712-2277a495401c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parametric1 = ParametricManager(base_config1, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric1.run()\n", + "# parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "eb10e3d3-32fa-4fd1-9536-4cbb5ce98d10", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "FutureWarning: C:\\Users\\sbredenk\\.conda\\envs\\orbit-sophie\\lib\\site-packages\\statsmodels\\tsa\\tsatools.py:142\n", + "In a future version of pandas all arguments of concat except for the argument 'objs' will be keyword-only" + ] + } + ], + "source": [ + "model1 = parametric1.create_model([\"plant.capacity\"],'cable_cost')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cac13d3e-7082-4f91-b967-9e149123bc76", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 -7.398858\n", + "1 -11.015592\n", + "2 -6.816162\n", + "3 -8.624529\n", + "4 -6.621931\n", + " ... \n", + "395 0.467762\n", + "396 0.437037\n", + "397 0.480522\n", + "398 0.453637\n", + "399 0.490446\n", + "Name: cable_cost, Length: 400, dtype: float64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model1.perc_diff" + ] + }, + { + "cell_type": "markdown", + "id": "2a476432-58aa-430f-8e99-fb044d375575", + "metadata": {}, + "source": [ + "# OSS Cost" + ] + }, + { + "cell_type": "markdown", + "id": "d4d4ae03-d237-40f3-a6f3-2d2073fa8f79", + "metadata": {}, + "source": [ + "## Distance to Shore" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "3b6340b5-f891-4139-ad9f-531d474895cd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + "# 'distance_to_landfall': 60\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10,\n", + "# 'num_turbines': 50, \n", + " 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': 'XLPE_500mm_220kV',\n", + " }\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d60ec7bb-5bc4-48eb-8595-af5253bbe826", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + " 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + "# 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c78c3ba5-705c-41ab-a7c0-e207aeb62e8f", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + " 'num_substations': lambda run: run.num_substations\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7d2b40ac-6aef-4f69-8fb9-99b39339347e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric.run()\n", + "# parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ee606b9c-4766-49ad-883f-5cceb9d06bbc", + "metadata": {}, + "outputs": [], + "source": [ + "model = parametric.create_model([\"site.distance_to_landfall\"],'oss_cost')" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8f70f822-3a2c-4d45-965f-1e9673ebf2fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 8.172125e-16\n", + "1 5.956174e-16\n", + "2 8.634491e-16\n", + "3 7.639807e-16\n", + "4 5.480498e-16\n", + "5 4.967373e-16\n", + "6 5.677634e-16\n", + "7 6.275873e-16\n", + "8 5.817131e-16\n", + "9 3.613924e-16\n", + "10 5.075180e-16\n", + "11 4.770924e-16\n", + "12 4.501086e-16\n", + "13 5.680182e-16\n", + "14 5.391564e-16\n", + "15 3.848143e-16\n", + "16 4.894202e-16\n", + "17 4.678414e-16\n", + "18 3.360638e-16\n", + "19 2.149649e-16\n", + "Name: oss_cost, dtype: float64" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.perc_diff" + ] + }, + { + "cell_type": "markdown", + "id": "044ac8ba-1370-43cf-9d76-7626bdf4023e", + "metadata": {}, + "source": [ + "## Plant Capacity" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "cb09d47b-fd37-4fc1-aee7-de88472147d8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "base_config1 = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100, \n", + " 'depth': 20, \n", + " 'distance_to_landfall': 60\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10,\n", + "# 'num_turbines': 50, \n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'export_system_design': {\n", + " 'cables': 'XLPE_500mm_220kV',\n", + " }\n", + " \n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "64d77593-7243-4d62-a4e8-5a600e42004e", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", + "# 'site.distance_to_landfall': np.arange(15,315,15),\n", + "# 'plant.num_turbines': np.arange(50,250,50), \n", + " 'plant.capacity': np.arange(100,900,100)\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "04b06ada-3ca9-43ad-87a4-c7b259abecb6", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d415d492-3a39-44ee-a6d6-9eec06560e8e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "parametric1 = ParametricManager(base_config1, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric1.run()\n", + "# parametric.results\n", + "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", + "# parametric.preview()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "b53acae3-0f91-4dda-aae0-bbd89fe8608d", + "metadata": {}, + "outputs": [], + "source": [ + "model1 = parametric1.create_model([\"plant.capacity\"],'oss_cost')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7783b713-e5ea-4f14-8d87-0d9b912a49c6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3.67371173e+07, 5.02341251e+07, 6.37311329e+07, 7.72281408e+07,\n", + " 9.07251486e+07, 1.04222156e+08, 1.17719164e+08, 1.31216172e+08])" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model1.predict(parameters)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "8e32cf5b-f494-4b16-8ec1-7b612d1a8d06", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.035688\n", + "1 -0.121405\n", + "2 0.060151\n", + "3 -0.036495\n", + "4 0.069707\n", + "5 0.000000\n", + "6 -0.061287\n", + "7 0.020302\n", + "Name: oss_cost, dtype: float64" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model1.perc_diff" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "30495cfc-cd76-4def-bed4-7a18010737c1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGsCAYAAAAPJKchAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUG0lEQVR4nO3dd3RU5drG4d/MpEMSSkggJPROSAggiIiKgoiIIC1BVBQ95+hBqpVjQSxgF1CP2LuEIk1pIkpRURASem8JJYEA6aTN7O+PQfJxKBJIZieZ+1ora212fSZCcrv3u5/XYhiGgYiIiIhJrGYXICIiIu5NYURERERMpTAiIiIiplIYEREREVMpjIiIiIipFEZERETEVAojIiIiYiqFERERETGVwoiIiIiYSmFERERETFWuwsjKlSvp1asXoaGhWCwW5s6dW+xzLFmyhKuvvhp/f39q1KhBv3792L9/f4nXKiIiIpemXIWR7OxsoqKiePfddy/r+H379tG7d29uvPFGEhISWLJkCampqfTt27eEKxUREZFLZSmvE+VZLBbmzJlDnz59zqzLy8vjqaeeYtq0aaSlpREREcErr7zCDTfcAMCsWbMYNGgQeXl5WK3OHPbdd9/Ru3dv8vLy8PT0NOGTiIiIuLdydWfk7zz88MOsXr2auLg4Nm7cyIABA7jlllvYtWsXAG3btsVqtfLpp59it9tJT0/nyy+/pGvXrgoiIiIiJqkwd0YSExNp0KABiYmJhIaGntmva9eutG/fngkTJgCwYsUKBg4cyPHjx7Hb7XTs2JGFCxdSpUoVEz6FiIiIVJg7I5s2bcJut9OkSRMqV6585mvFihXs2bMHgOTkZP7xj38wZMgQ1q5dy4oVK/Dy8qJ///6U00wmIiJS7nmYXUBJycrKwmazsW7dOmw221nbKleuDMC7775LYGAgr7766pltX331FeHh4fzxxx9cffXVLq1ZREREKlAYiY6Oxm63c/ToUTp37nzefXJycs4MXP3LX8HF4XCUeo0iIiJyrnL1mCYrK4uEhAQSEhIA56u6CQkJJCYm0qRJEwYPHsw999zD7Nmz2bdvH2vWrGHixIksWLAAgJ49e7J27Vqef/55du3axfr167nvvvuoW7cu0dHRJn4yERER91WuBrAuX76cLl26nLN+yJAhfPbZZxQUFPDiiy/yxRdfcOjQIYKCgrj66qsZP348rVq1AiAuLo5XX32VnTt34ufnR8eOHXnllVdo1qyZqz+OiIiIUM7CiIiIiFQ85eoxjYiIiFQ8CiMiIiJiqnLxNo3D4eDw4cP4+/tjsVjMLkdEREQugWEYZGZmEhoaes7brP9fuQgjhw8fJjw83OwyRERE5DIkJSURFhZ2we3lIoz4+/sDzg8TEBBgcjUiIiJyKTIyMggPDz/ze/xCykUY+evRTEBAgMKIiIhIOfN3Qyw0gFVERERMpTAiIiIiplIYEREREVMpjIiIiIipFEZERETEVAojIiIiYiqFERERETGVwoiIiIiYSmFERERETKUwIiIiIqZSGBERERFTKYyIiIiIqRRGRERE3Fn81zB/BBTmm1ZCuZi1V0RERErBwT/h+1Fgz4fabaHtEFPK0J0RERERd5RxBOIGO4NIs9sg+m7TSlEYERERcTeFeTDjbshKhhrN4Y6pYDUvEiiMiIiIuBPDgAVj4OBa8AmE2K/B29/UkhRGRERE3MmaDyH+K7BYof+nUL2h2RUpjIiIiLiNfSth8ZPO5W7PQ6ObzK3nNIURERERd3DyAMwYAoYdImOg48NmV3SGwoiIiEhFl5/tfHPm1Amo1Rp6TQaLxeyqzlAYERERqcgMA+b+G1I2QaUazgGrnr5nNmfkFvDj1hQTC1QYERERqdh+eRO2zgWrJwz8EgLDzmxan3iSnlNW8eBX60hISjOtRHVgFRERqah2LoFlLziXb30V6nYEwO4wmLpiD28u3YndYRBW1fciJyl9CiMiIiIVUeou+PYBwIB2Q51fQHJ6LqOnJ7B673EAekWF8tIdEQT4eJpWqsKIiIhIRZObDtMGQV4G1OkIt7wCwNKtKTw+awMncwrw87Ix/vaW9G8bhsXkwawKIyIiIhWJww7f/gOO74KA2jDwC3INGxPmbeaL1QcAiKgdwJTYaBrUqGxysU4KIyIiIhXJzy/BriXg4QOxX7Mr25fhH/3K9uRMAP7RuT6Pdm+Kt4fN5EKLKIyIiIhUFJtnw6o3ADB6TeHrxGq88P0v5BU6CKrsxesDorihabDJRZ5LYURERKQiSN4E84YBkHvVMEZubMiSLZsBuK5JDd4YEEUNf28zK7wghREREZHyLvs4TLsTCnJIq9WZnhtu4FBGCp42C0/c0oyhnepjtZadjqv/S2FERESkPLMXwMwhkJ5Imk8YN+y/mzSjgPpBlZgSG02rsECzK/xbCiMiIiLl2ZKnYP8qTll8GZA+gjSjMgPahvHc7S2p5F0+fs2XjypFRETkXPFfwZr3ARiR9xDJXvWY0rcVt0eFmlxY8SiMiIiIlEO5+1bjMX8UHsBbBf1IDevKwthowqv5mV1asSmMiIiIlDPbd+4gaNoggowCFtuvwt75MWZ0a4qnrXzOf6swIiIiUk4YhsHnK3fQetlggqwn2WMJp8rgj3i0WT2zS7si5TNCiYiIuJnUrDyGfroGv6WP09q6m2yrP9Xv/5ary3kQAd0ZERERKfNW7TrG6Okb6HlqPgM9V+DAit+dX2AJa2p2aSVCYURERKSMyi908MYPO3h/5V46WrfwrNeXAFhvfgEa3WhydSVHYURERKQM2peazci4eDYeTCfMcpSPfN/BZndAZAx0HGZ2eSVKYURERKQMMQyD2esP8ey8zWTn26npY2dR4HtUSk+H0GjoNRksZbe1++VQGBERESkjMnMLeHruZuYlHAagQ72qfOb/X3x37YBKwRDzNXj6mlxlyVMYERERKQPiE08yMi6BxBM52KwWRt3UmGEe87D+/B1YPSHmSwisbXaZpUJhRERExEQOh8HUlXt484edFDoMalfxZcqg1rTNWwvfvOjc6dbXoM7V5hZaihRGRERETJKSkcvo6Qn8tuc4ALdF1uKlO1oRmLUPvnkAMKDdUGh3n7mFljKFERERERP8uDWFx2Zt4GROAb6eNsbf3pIB7cKw5KZD3CDIy4A618Atr5hdaqlTGBEREXGh3AI7Ly/azme/7QegRa0A3r4zmoY1KoPDDrP/Acd3Q0AYDPwCPLzMLdgFFEZERERcZFdKJsOnxbM9OROA+6+tz+O3NMXbw+bc4acXYdcP4OEDsV9B5RomVus6CiMiIiKlzDAMpq1J4vnvt5Bb4KB6JS9eHxhFl6bBRTttng2/vOlcvv0dZ08RN6EwIiIiUorScvJ58ttNLN6SDEDnxkG8MTCKYH+fop2ObIR5p7uqXjMCIgeYUKl5FEZERERKyR97jzNqegJH0nPxtFl4rHtTHri2AVbr/+ugmp0KcYOhIAca3gRdnzOtXrMojIiIiJSwQruDKT/t5p2fduEwoF51P94e1IZWYYFn72gvgJn3QnoiVGsA/T8Gq82Ums2kMCIiIlKCDp7MYVRcAn8eOAlAvzZhjO/dksre5/mVu+Qp2L8KvCpD7DTwreriassGhREREZESsmDjEZ6cvZHM3EIqe3vw0h0R9G59gRbu67+ENe87l/t+AMHNXFdoGaMwIiIicoVy8gt5/rutxK1NAqB1eBWmxEZTp7rf+Q9IWgsLxjiXb/gPNOvpokrLJoURERGRK7D1cAbDp61nz7FsLBZ46PqGjO7WBE+b9fwHZByB6XeBPR+a3QbXPebagssghREREZHLYBgGn/66n5cXbSff7iAkwJu3BrbmmkZBFz6oINcZRLKSIbgF3DEVrBcILW6k2N+BlStX0qtXL0JDQ7FYLMydO/ei+8+ePZtu3bpRo0YNAgIC6NixI0uWLLncekVEREx3PCuP+z//k+e/30q+3UHX5sEsGnndxYOIYTgfzRz6E3yqQOzX4O3vsprLsmKHkezsbKKionj33Xcvaf+VK1fSrVs3Fi5cyLp16+jSpQu9evUiPj6+2MWKiIiYbdWuY9wyeRU/bT+Kl4eV53u35MN72lGt0t/MIfPH+5DwNVisMOAz56u8AoDFMAzjsg+2WJgzZw59+vQp1nEtW7YkJiaGZ5999pL2z8jIIDAwkPT0dAICAi6jUhERkSuTX+jgjaU7eH/FXgAaB1dmyqBomte6hN9Le1fAl3eAYYebX4JrHi7lasuGS/397fIxIw6Hg8zMTKpVq3bBffLy8sjLyzvz54yMDFeUJiIicl4HjmczYlo8Gw6mAzC4Qx2e7tkCX69LaFB2cr+zsZlhh8hY6DisVGstj1weRl5//XWysrIYOHDgBfeZOHEi48ePd2FVIiIi5zd7/UGembuZ7Hw7gb6evNKvFbdE1Lq0g/Ozna3eT51wTnzXaxJYLH97mLtx6RDeb775hvHjxzNjxgyCg4MvuN/YsWNJT08/85WUlOTCKkVERCAzt4DR0xMYM2MD2fl22tevxqKRnS89iBgGzP03pGyGSsEQ8zV4+pZu0eWUy+6MxMXF8cADDzBz5ky6du160X29vb3x9vZ2UWUiIiJnS0hKY8S0eBJP5GC1wKiuTRjWpRE2azHuaqx6A7bOBasnxHwJgRfoxCquCSPTpk1j6NChxMXF0bOne3eZExGRssvhMHh/5V7e+GEHhQ6D2lV8mRzbmnb1LjzO8bx2LIafXnQu93wd6lxd8sVWIMUOI1lZWezevfvMn/ft20dCQgLVqlWjTp06jB07lkOHDvHFF18AzkczQ4YMYfLkyXTo0IHk5GQAfH19CQwMPO81REREXC0lI5cxMxL4dfdxAHq2qsWEvq0I9PUs3omO7YRvHwAMaHc/tL23xGutaIr9au/y5cvp0qXLOeuHDBnCZ599xr333sv+/ftZvnw5ADfccAMrVqy44P6XQq/2iohIaVq2LYXHZm3kRHY+vp42nru9BQPbhWMp7mDTU2nw0U1wfDfUuQbumQcef9N/pAK71N/fV9RnxFUURkREpDTkFth5edF2PvttPwAtagUwZVA0jYIrF/9kDjtMi4VdP0BAGPxzOVSuUaL1ljdlts+IiIhIWbD7aCYPfxPP9uRMAIZ2qs8TPZri7XEJvUPO56cXnEHEw9fZ6t3Ng0hxKIyIiIhbMQyDuLVJjP9uC7kFDqpX8uL1AVF0aXbhlhN/a/O38MtbzuXe70Bo6xKp1V0ojIiIiNtIzylg7JyNLNzkfJni2kZBvDkwiuAAn8s/6ZGNMPd0V9VrRkCr/iVQqXtRGBEREbewdv8JRk6L53B6Lh5WC491b8o/OjfAWpzeIf8rO9XZYbXwFDTqCl2fK7F63YnCiIiIVGiFdgfv/LybKct24TCgbnU/psRGExVe5cpObC+AGUMgPdE5A2+/j8B6meNN3JzCiIiIVFiH0k4xKi6etftPAtC3TW2e7x1BZe8S+PW35D9w4Bfwqgyx08C36pWf000pjIiISIW0cNMRnvx2Ixm5hVT29uDFPhH0iS6hluzrv4A1HziX+34Iwc1K5rxuSmFEREQqlFP5dp7/fgvT1jgnWY0Kr8KU2NbUrV6pZC6QtAa+H+Nc7vIUNLu1ZM7rxhRGRESkwth6OIMRcfHsPpqFxQIPXt+QMd2a4GkroUnqMw7D9LvAUQDNe0HnR0vmvG5OYURERMo9wzD4/Lf9TFi0nfxCB8H+3rwV05pOjYJK7iIFuc4gkpUCwS2gz1SwllDIcXMKIyIiUq4dz8rj8VkbWbb9KAA3NQvmtQFRVKtUgnPCGAZ8PxoOrXMOVI39Brwvo2W8nJfCiIiIlFu/7k5l9PQEjmbm4eVh5albm3NPx7rFn+Du7/wxFTZ8AxYr9P8UqtUv2fO7OYUREREpdwrsDt74YSfvr9yDYUCj4Mq8PSia5rVKYTLVvcthyVPO5ZtfhIbnzlwvV0ZhREREypUDx7MZEZfAhqQ0AAa1r8Ozt7XA16sUGo6d3A8z7wXDDpGxcPW/S/4aojAiIiLlx9z4Qzw9dzNZeYUE+HjwSr9IerSqVToXy8tytno/dRJC20CvSVDSj38EUBgREZFyICuvkGfnbmZ2/CEA2terxluxraldxbd0LmgYMO/fkLIZKgVDzFfgWUrXEoUREREp2zYkpTEiLp4Dx3OwWmDkTU0Y1qUhHiXVO+R8Vr0OW+eB1dMZRAJLqHOrnJfCiIiIlEkOh8GHq/by2pIdFDoMalfxZVJsa66qV610L7xjEfz0knO55+tQp0PpXk8URkREpOw5mpHLIzM3sGpXKgC3tqrJxDsiCfTzLN0LH9sB3/4DMOCqB6DtvaV7PQEURkREpIz5eftRHpm5gRPZ+fh4WnmuV0tirgov+d4h/+tUGkwbBPmZULcT3PJy6V5PzlAYERGRMiGv0M7Li7bz6a/7AWheK4C3B7WmUbB/6V/cYYdvH4ATeyAgDAZ8DrZSvgsjZyiMiIiI6XYfzWL4tHi2HckA4N5r6vFkj2b4eJZC75Dz+ekF2L0UPHwh9muoXMM11xVAYURERExkGAbT1yYx/rutnCqwU62SF68PiOTGZiGuK2LTLPjlLedy73cgtLXrri2AwoiIiJgk/VQB/5m9iQWbjgBwbaMg3hwYRXCAT+lf3GGH/atg4wxnGAHoNBJa9S/9a8s5FEZERMTl/tx/gpFxCRxKO4WH1cKj3Zvyz84NsFpLcZCqYTibmG2c7gwgmUeKtjXtCTeNK71ry0UpjIiIiMvYHQbv/LSbyct24jCgbnU/JsdG0zq8SuldNP0gbJrpvAtydGvRep8q0PIOiIyB8A5gLcUmanJRCiMiIuISh9NOMWp6Amv2nQDgjujaPN+7Jf4+pfDWyqk02DbfGUD2/wIYzvU2L2hyizOANO4GHt4lf20pNoUREREpdYs3H+GJbzeRfqqASl42Xrwjgjuiw0r2IoX5zjdiNk6HHYvBnle0re61EDkQWvQG3yole125YgojIiJSak7l23lhwVa++SMRgKiwQCbHRlMvqFLJXMAwIOkPZwDZMsc5w+5fajRz3gFpNQCqhJfM9aRUKIyIiEip2HYkgxHT4tl1NAuAB69vyJhuTfDyKIGxGam7nAFk4wxIO1C0vnJN5xsxkTFQsxWUdtdWKREKIyIiUqIMw+CL1Qd4aeE28gsd1PD35q2Brbm2cdCVnTjrKGz+1hlCDscXrfeqDM1vdz6GqX8dWF3UKE1KjMKIiIiUmBPZ+Tw+awM/bjsKwI3NgnmtfyTVK1/mQNH8bNi+0BlA9vwEht253mKDRl2dAaTpreDlV0KfQMygMCIiIiXit92pjJqewNHMPLxsVsbe2ox7r6lX/Anu7IWwb4XzEcy276Agu2hb7bYQGet8JVct2ysMhREREbkiBXYHby3dyXsr9mAY0LBGJd4e1IYWoQGXfhLDgCMbnAFk8yzISinaVrXe6YGoAyGoUYnXL+ZTGBERkcuWeDyHEXHxJCSlATCofTjP3NYCP69L/PVy8kBRQ7LUHUXrfatBRF9nCAm7SgNRKziFERERuSzzEg7x1JzNZOUVEuDjwcv9Irm1Va2/P/DUSdgy1xlAEn8rWu/hA017OB/DNLwRPLxKrXYpWxRGRESkWLLyCnl23mZmrz8EwFX1qjIpNpraVXwvfFBhHuxc4hyIuusHsOef3mCB+p2dd0Ca9wKfwNL/AFLmKIyIiMgl23gwjRHT4tl/PAerBYbf2JjhNzbCw3ae3iEOBySudgaQrXMhN71oW0iE802YiP4QWNtl9UvZpDAiIiJ/y+Ew+HDVXl7/YQcFdoPQQB8mxUbTvn61c3c+uv30zLgzIT2paL1/KEQOcA5ErRnhuuKlzFMYERGRizqamcsjMzawalcqAD0iavJy30gC/f7fBHeZybBpljOEJG8sWu8dAC1udz6GqdtJDcnkvBRGRETkgn7ecZRHZ2zgeHY+Pp5WxvVqSexV4c7eIXmZsO17ZwDZtwIMh/Mgqwc0vtn5GKbJLeB5kbEkIiiMiIjIeeQV2nll0Q4++XUfAM1q+vP2oGgaB/nArtMz425fAIWnig4K73B6Ztw7oFJ1kyqX8khhREREzrLnWBbDv4ln65EMAO7tWJexUTl4r3vBOTdMTmrRztUbnW5I1h+qNTCpYinvFEZERARwTnA3488knpu/lVMFdlr5HmdSi100PPAMxO8p2tEv6PTMuAMhtI0akskVUxgRERHSTxXwnzmb+HXjTvrZfueegN9pkr8NtpzewcMXmt/mvAvS4AaweV7sdCLFojAiIuLm1u85zOy4j+mT+zOTvBPwtNghH7BYncEjMgaa9QRvf7NLlQpKYURExB05HNj3rWL7Dx/ROHkpL1pOwV9v3daMLBoH4l/T1DLFPSiMiIi4k5QtsHE69g0zsWUdpiWABU54hFDpqkF4R8dCcHOzqxQ3ozAiIlLRpR+CzbOcE9OlbAacN0EyDD+W0JHga+7m+m69wXqelu4iLqAwIiJSEeVmwLb5pxuSrQIMAAotHvxYGM0ceydSa13PG4M6UC+okrm1ittTGBERqSgK82HPMmcA2bEICnPPbMqp1Z4P0trx6cnWpFOZf13fgLe7NcXLQ3dDxHwKIyIi5ZlhwMG1zgCyeTacOlG0LagJRmQMsws7MvanDPILHdTw9+bLgVF0blzDvJpF/ofCiIhIeXR8jzOAbJwBJ/cVra8UDK0GQORATgQ05/FvN/HjthQAujStwWsDogiq7G1S0SLnpzAiIlJeZKc6735snA6H/ixa71kJmvdydkStfz3YPPhtTyqjP1tFSkYeXjYrT/Zoxn2d6jknuBMpYxRGRETKsvwc2LHQeQdk949g2J3rLTZoeOPphmS3gpdzEGqB3cGkJdv57/I9GAY0qFGJtwdF0zI00MQPIXJxCiMiImWNww77VjoDyLb5kJ9VtC20jTOARPSFysFnHZZ0Iofh0+JJSEoDIPaqcJ7t1QI/L/2ol7JNf0NFRMoCw4DkTc5HMJtmQVZy0bYqdZ0BJHIgBDU+7+HzEg7x9JzNZOYV4u/jwct9I+kZWctFxYtcGYUREREzpSXBppnOuyDHthWt960KLfs6Q0h4+wvOjJudV8i4+VuYte4gAG3rVmVybGvCqvq5onqRElHsF8xXrlxJr169CA0NxWKxMHfu3L89Zvny5bRp0wZvb28aNWrEZ599dhmliohUEKfSYN3n8GlPmBQBy8Y7g4jNG1r0gdhp8MhOuO1NqNPhgkFk08F0bnv7F2atO4jVAiNuasz0f16tICLlTrHvjGRnZxMVFcXQoUPp27fv3+6/b98+evbsyYMPPsjXX3/NsmXLeOCBB6hVqxbdu3e/rKJFRMqdwjzYtdT5GGbnErDnnd5ggXrXOu+AtLgdfP5+oKnDYfDxL/t4dcl2CuwGtQJ9mBTTmg4NqpfuZxApJcUOIz169KBHjx6XvP/UqVOpX78+b7zxBgDNmzfnl19+4a233lIYEZGKzTAg6Q/YEAdb5kBuWtG2Gs0hKsbZEyQw7JJPeTQzl0dmbGDVrlQAbmlZk5f7taKKn1cJFy/iOqU+ZmT16tV07dr1rHXdu3dn1KhRFzwmLy+PvLy8M3/OyMgorfJEREresZ2waYbzLkhaYtF6/1rQqr/zLkhIxAUfv1zI8h1HeXTmBlKz8vH2sPJsrxbc2b6OeodIuVfqYSQ5OZmQkJCz1oWEhJCRkcGpU6fw9fU955iJEycyfvz40i5NRKTkZB2Fzd86A8jh+KL1Xv7Oxy+RA6FeZ7Dain3qvEI7ry3ewUe/ODutNqvpz5RB0TQJ8S+p6kVMVSbfphk7dixjxow58+eMjAzCw8NNrEhE5Dzys2H7AmcA2fNzUUMyqwc06uoMIE16gNflDyjdeyyL4dPi2XLYeYd4SMe6jL21OT6exQ81ImVVqYeRmjVrkpKScta6lJQUAgICzntXBMDb2xtvb82dICJlkL0Q9i0/3ZDseyjILtoWdpXzEUzLO6BS0BVdxjAMZq47yHPzt5CTb6eqnyev9o+iW4uQvz9YpJwp9TDSsWNHFi5ceNa6pUuX0rFjx9K+tIhIyTAMOJLgDCCbZkH20aJt1Ro4A0irAVC9YYlcLiO3gKfmbOa7DYcB6NigOm/FtKZmoE+JnF+krCl2GMnKymL37t1n/rxv3z4SEhKoVq0aderUYezYsRw6dIgvvvgCgAcffJB33nmHxx9/nKFDh/LTTz8xY8YMFixYUHKfQkSkNJw8cHog6gxI3Vm03q86RPRzhpDabYs9EPVi1h04yci4eA6ePIXNamFMtyY8eH1DbFYNUpWKq9hh5M8//6RLly5n/vzX2I4hQ4bw2WefceTIERITi0aP169fnwULFjB69GgmT55MWFgYH330kV7rFZGyKecEbJ3rDCCJq4vWe/hAs57OANLwRrB5luhl7Q6D95bv5q0fd2F3GIRX82VybDRt6lQt0euIlEUWwzAMs4v4OxkZGQQGBpKenk5AQIDZ5YhIRVOQC7t+KGpI5ig4vcECDa4/PTPubeBTOj9/jqSfYvT0BH7fewKA26NCefGOCAJ8SjbwiLjapf7+LpNv04iIuITDDj8+B+s/h9z0ovU1W52eGbcfBISWaglLtiTzxLcbScspwM/LxvO9I+jXprZ6h4hbURgREfe1bDz8NsW5HBAGkQOg1UAIaVHql84tsPPigq189bvzsXar2oFMGRRN/aBKpX5tkbJGYURE3NOmWfDrZOfy7e9A68FgLfbcoZdlR3Imw6etZ2dKFgD/vK4Bj97cFC8P11xfpKxRGBER93M4AeY97Fy+djS0udsllzUMg6/+SOTF77eSV+ggqLI3bw6M4romNVxyfZGySmFERNxL1jGIGwyFp6DxzXDjMy657MnsfJ74diM/bHU2gby+SQ3eGBhFUGU1eBRRGBER92EvgJlDIOMgVG8E/T66rLliimv1nuOMnp5AckYunjYLT9zSjKGd6mNV7xARQGFERNzJ4ifhwK/gHQCx08AnsFQvV2B3MPnHXby7fDeGAQ2CKjFlUDQRtUv3uiLljcKIiLiHdZ/B2o8AC/T9EGo0KdXLJZ3IYWRcPOsT0wAY2C6Mcb1aUslbP3ZF/pf+VYhIxZf4Oyx41Ll849PQ9JZSvdz8DYd5avYmMvMK8ff2YELfVvSKKt1+JSLlmcKIiFRs6Ydg+t3Orqot+kDnR0rtUtl5hTw3fwsz1x0EoE2dKkyOjSa8ml+pXVOkIlAYEZGKq+AUTB/snGU3JAL6/LdEJ7X7/zYfSmfEtHj2pmZjscDwLo0YcVNjPGzqHSLydxRGRKRiMgz4bhQcjgffahD7NXiVfHdTh8Pgk1/38cri7RTYDWoG+PBWTGs6Nqxe4tcSqagURkSkYvr9v7AxDiw2GPAZVK1X4pc4lpnHozM3sGLnMQBubhHCK/0iqVrJq8SvJVKRKYyISMWz52f44WnncvcJzpl3S9iKncd4ZMYGUrPy8Paw8sxtLRjcoY4muBO5DAojIlKxnNgLM+8Fw+Gcb6bDv0r09PmFDl5bsp0PV+0DoGmIP1MGRdO0pn+JXkfEnSiMiEjFkZflbPWemwa120LPN0t0wOreY1mMiItn86EMAO7pWJf/3NocH8/S7+IqUpEpjIhIxeBwwNwH4ehWqFwTYr4GT58SObVhGMxad5Bx87eQk2+nip8nr/aL5OaWNUvk/CLuTmFERCqGVa/Dtu/A5gUxX0FArRI5bUZuAU/N2cx3Gw4DcHWDakyKiaZmYMkEHRFRGBGRimD7Avj5Jedyzzch/KoSOe36xJOMmBbPwZOnsFktjOnWhAevb4hNE9yJlCiFEREp345uh9n/dC63/xe0ufuKT2l3GExdsYc3l+7E7jAIq+rLlEHRtKlT9YrPLSLnUhgRkfLr1EmIGwT5WVCvM3R/6YpPmZyey+jpCazeexyAXlGhvHRHBAE+nld8bhE5P4URESmfHHaYdb/zVd7AOjDgc7BdWWBYujWFx2ZtIC2nAD8vG+Nvb0n/tmHqHSJSyhRGRKR8+vE52LMMPHydrd4rXX779dwCOxMWbuOL1QcAiKgdwJTYaBrUqFxCxYrIxSiMiEj5s3Em/DbFudznv1Ar8rJPtTMlk+HfxLMjJROAf3Suz6Pdm+Ltod4hIq6iMCIi5cvheJj/sHP52jEQ0feyTmMYBl//kcgL328lr9BBUGUv3hjYmuub1CjBYkXkUiiMiEj5kXUM4u6CwlxofDPc+PRlnSYtJ5/HZ23kh60pAFzXpAZvDIiihr93SVYrIpdIYUREyofCfJhxD2QchOqNoN9HYC3+o5Tf9x5n9PQEjqTn4mmz8MQtzRjaqT5W9Q4RMY3CiIiUD4ufhMTfwDsAYqeBT2CxDi+0O5iybBfv/LwbhwH1gyrx9qBoImoX7zwiUvIURkSk7PvzU/jzY8DivCNSo0mxDk86kcOo6QmsO3ASgAFtw3ju9pZU8taPQJGyQP8SRaRsS/wdFj7mXL7xaWjSvViHf7/xMGNnbyIztxB/bw9e6tuK26NCS6FQEblcCiMiUnalH4Lpd4OjAFr0gc6PXPKhOfmFPDd/CzP+PAhAdJ0qTImNJryaXykVKyKXS2FERMqmglMwfTBkH4WQVs5+IpfYCXXzoXRGxMWz91g2FgsMu6ERI7s2xtNmLeWiReRyKIyISNljGPDdSGdPEd9qzg6rXpUu4TCDT37dzyuLtpNvd1AzwIc3Y6K4pmGQC4oWkculMCIiZc/qd2HjdLDYYODnULXu3x6SmpXHozM3sHzHMQC6tQjh1X6RVK3kVdrVisgVUhgRkbJlz0+w9Bnn8i0Tof51f3vIyp3HGDNjA6lZeXh5WHmmZ3PuurquJrgTKScURkSk7DixF2beB4YDWt8F7f950d3zCx288cMO3l+5F4AmIZWZMiiaZjUDXFGtiJQQhRERKRvyMmHanZCbBrXbwW1vXnTA6r7UbEbGxbPxYDoAd11dh6d7tsDHUxPciZQ3CiMiYj6HA+Y8CMe2QeWaEPMVeJx/nhjDMJi9/hDPzNtMTr6dKn6evNIvku4ta7q4aBEpKQojImK+la/B9u/B5uUMIgG1zrtbZm4BT8/dzLyEwwB0qF+NSbGtqRXo68pqRaSEKYyIiLm2fQ/LJziXb3sLwq86727xiScZERdP0olT2KwWRt3UmH93aYRNE9yJlHsKIyJinqPbYM6/nMvt/wXRd52zi8NhMHXlHt78YSeFDoPaVXyZMiiatnWrurhYESktCiMiYo6cEzBtEORnQb3O0P2lc3ZJychl9PQEfttzHIDbImvx0h2tCPT1dHW1IlKKFEZExPXshfDt/XByHwTWgQGfg+3sgPHj1hQem7WBkzkF+HraGH97Swa0C1PvEJEKSGFERFxv2XPO5maefjDoG6hU/cym3AI7Exdu4/PVBwBoGRrAlEHRNKxR2aRiRaS0KYyIiGttnAG/ve1c7v0u1Gx1ZtOulEyGT4tne3ImAPdfW5/Hb2mKt4d6h4hUZAojIuI6h+Nh/nDncudHIKIv4Owd8s2aRF74fiu5BQ6CKnvx+oAobmgabGKxIuIqCiMi4hpZRyFuMBTmQuPu0OVpANJy8nny200s3pIMQOfGQbwxMIpgfx8zqxURF1IYEZHSV5gPM+6BjENQvTH0+xCsVv7Ye5xR0xM4kp6Lp83C492bcf+19bGqd4iIW1EYEZHSt/gJSFwN3gEwaBqFnv5MWbqTd37ahcOAetX9eHtQG1qFBZpdqYiYQGFERErXn584v7BAv484aKvNqA9+588DJwHo1yaM8b1bUtlbP45E3JX+9YtI6TmwGhY+5ly+6RkW5Eby5ORVZOYWUtnbg5fuiKB369rm1igiplMYEZHSkX4QZtwNjkIKm/fh6ZSuxC1YD0Dr8CpMiY2mTnU/k4sUkbJAYURESl7BKeebM9nHOFW9Bf2TBrEl9SAWC/z7hoaM6toET5vV7CpFpIxQGBGRkmUYMH8EHEkg17MKtyY/yD67nZAAb94a2JprGgWZXaGIlDEKIyJSsla/A5tmYMfKvdkPs88RRNfmIbzaP5JqlbzMrk5EyiCFEREpObuXYSx9FgvwfMHdrLdG8Hyv5tx9dV1NcCciF6QwIiIlIv/obuzThuBrOJhReD2/VevLvDvb0LxWgNmliUgZpzAiIlfswOEULB/fQR17JusdjdgcPY75vVrj66UJ7kTk713WcPZ3332XevXq4ePjQ4cOHVizZs1F9580aRJNmzbF19eX8PBwRo8eTW5u7mUVLCJly+x1iex6fzB17IkcpSrpvT7m+X5tFURE5JIVO4xMnz6dMWPGMG7cONavX09UVBTdu3fn6NGj593/m2++4cknn2TcuHFs27aNjz/+mOnTp/Of//zniosXEfNk5hYwKi6exDnj6GpZSwGeWGK+pstVrc0uTUTKmWKHkTfffJN//OMf3HfffbRo0YKpU6fi5+fHJ598ct79f/vtNzp16sSdd95JvXr1uPnmmxk0aNDf3k0RkbIrISmNnlN+4dTGeYzymA2A7fa3qNG8k8mViUh5VKwwkp+fz7p16+jatWvRCaxWunbtyurVq897zDXXXMO6devOhI+9e/eycOFCbr311gteJy8vj4yMjLO+RMR8DofBe8v30P+93/A+uZO3vN5zbujwINY2d5tbnIiUW8UawJqamordbickJOSs9SEhIWzfvv28x9x5552kpqZy7bXXYhgGhYWFPPjggxd9TDNx4kTGjx9fnNJEpJSlZOQyZkYCv+4+TiBZfOM/Cb+CXKjXGW5+0ezyRKQcK/V+zMuXL2fChAn897//Zf369cyePZsFCxbwwgsvXPCYsWPHkp6efuYrKSmptMsUkYtYti2FHpNX8evu41T2hCVhn1Kj4DBUqQMDPgebp9klikg5Vqw7I0FBQdhsNlJSUs5an5KSQs2aNc97zDPPPMPdd9/NAw88AECrVq3Izs7mn//8J0899RRW67l5yNvbG29v7+KUJiKlILfAzsuLtvPZb/sBaFErgK/rfEfVDavB0w9iv4FK1c0tUkTKvWLdGfHy8qJt27YsW7bszDqHw8GyZcvo2LHjeY/Jyck5J3DYbM5X/gzDKG69IuIiu49m0ufdX88EkaGd6jPvuoNU3fC+c4c+/4WarcwrUEQqjGI3PRszZgxDhgyhXbt2tG/fnkmTJpGdnc19990HwD333EPt2rWZOHEiAL169eLNN98kOjqaDh06sHv3bp555hl69ep1JpSISNlhGAZxa5MY/90WcgscVK/kxesDoujifxA+GencqfMj0PIOcwsVkQqj2GEkJiaGY8eO8eyzz5KcnEzr1q1ZvHjxmUGtiYmJZ90Jefrpp7FYLDz99NMcOnSIGjVq0KtXL1566aWS+xQiUiLScwp4cvZGFm1OBqBz4yDeGBBFsDUDPrgL7HnQuDt0edrkSkWkIrEY5eBZSUZGBoGBgaSnpxMQoHkuRErD2v0nGDktnsPpuXhYLTx+S1MeuLYBVkcBfN4Lkn6H6o3hH8vAJ9DsckWkHLjU39+am0bEzRXaHbzz826mLNuFw4C61f2YEhtNVHgV5w4LHncGEe8AGDRNQURESpzCiIgbO5R2ilFx8azdfxKAvm1q83zvCCp7n/7RsPZjWPcpYIF+H0NQY/OKFZEKS2FExE0t3HSEJ7/dSEZuIZW9PXixTwR9omsX7XDgN1j0uHP5pmegyc3mFCoiFZ7CiIibOZVv5/nvtzBtjbOZYFR4FabEtqZu9UpFO6UlwfS7wVEILfvCtWNMqlZE3IHCiIgb2Xo4gxFx8ew+moXFAg9e35Ax3Zrgaft/vYDyc2D6YMhJhZBW0PsdsFjMK1pEKjyFERE3YBgGn/+2nwkLt5NvdxDs781bMa3p1Cjof3eE70bAkQ3gVx1ivwavSuc/qYhICVEYEangjmfl8fisjSzbfhSAm5oF89qAKKpV8jp359/ehk0zwWJzzjlTta6LqxURd6QwIlKB/bo7ldHTEziamYeXh5Wnbm3OPR3rYjnfY5fdP8KP45zLt7wM9Tu7tlgRcVsKIyIVUIHdwRs/7OT9lXswDGgUXJm3B0XTvNYFmg4d3wOzhoLhgOi7oP0/XFuwiLg1hRGRCubA8WxGxCWwISkNgEHt6/DsbS3w9brAXFB5mRB3J+SmQ9hV0PNNDVgVEZdSGBGpQObGH+LpuZvJyiskwMeDV/pF0qNVrQsf4HDA7H/Bse3gXwtivgIPb9cVLCKCwohIhZCVV8izczczO/4QAO3rVeOt2NbUruJ7/gNO7ncOVN04A1J3gs3LGUT8a7quaBGR0xRGRMq5DUlpjIiL58DxHKwWGHlTE4Z1aYjH/+8dApBzArbOdQaQxNVF6z18nb1Ewtq5tG4Rkb8ojIiUUw6HwYer9vLakh0UOgxqV/FlUmxrrqpXrWinglzYtcQZQHYuAUfB6Q0WqH8dRMZA817go9mwRcQ8CiMi5dDRjFwembmBVbtSAbi1VU0m3hFJoJ+ncxxI4m+wcTpsmQd56UUHhrSCyIHQqj8EhJpUvYjI2RRGRMqZn7cf5ZGZGziRnY+Pp5XnerUk5qpwLMe2w2/TYeNMyDhYdIB/KEQOcN4FCWlpXuEiIhegMCJSTuQV2nl50XY+/XU/AM1rBfDf22tS/8h8eD8OkjcV7ewdAC16O++C1L0WrNbzn1REpAxQGBEpB3YfzWL4tHi2HcmgEqd4sek+breuwvbFKmejMgCrJzS+2RlAmnQHzwu8SSMiUsYojIiUYYZhMH1tEi99t5F29gRG+v5GN+s6bAdyi3YK7+AMIC37gl+1C59MRKSMUhgRKaPSc/J5f9pMauybx8+21QTZMsAA7ED1Rs4xIK0GQLX6ZpcqInJFFEZEypoTezm08gvsG+J43Dhy5l+p4ReEpVV/512Q0DZq2S4iFYbCiEhZkH0ctszG2DgDy8E11D69Ohcvchr2oNrVd2NpcAPYPM2sUkSkVCiMiJil4BTsWORsSLZ7KTgKsQB2w8KvjgiSwnvRO/afVAuoanalIiKlSmFExJUcdtj/izOAbJ0H+ZlnNm2lPt8WdOJH27WM6tuZwdFhJhYqIuI6CiMirpC82dkRddMsyDx8ZrUjIIwVPl14KakVu40wosIC+Tw2mnpBlUwsVkTEtRRGREpL+qGimXGPbila7xMILe9gf+3b+OfPHuxMzAHgwesbMqZbE7w81KBMRNyLwohIScpNh63znXdB9v+C811cwOblbEQWGYPRqBtfrE3mpdnbyC/Mp4a/N28NbM21jYNMLV1ExCwKIyJXqjAf9iyDDXHOAan2vKJtdTs5X8Vt0Rt8q3IiO5/Hv9nAj9uOAnBjs2Be6x9J9creJhUvImI+hRGRy2EYkLTm9My4c+DUiaJtQU0h6nRDsip1zqz+bXcqo6YncDQzDy+blbG3NuPea+phUb8QEXFzCiMixZG6+/RA1Blwcn/R+sohEHG6IVmtqLMakhXYHby1dCfvrdiDYUDDGpV4e1AbWoQGuL5+EZEySGFE5O9kHYMts52PYQ6vL1rvWQma93IGkPrXg+3cf06Jx3MYERdPQlIaAIPah/PMbS3w89I/PRGRv+gnosj55OfAjoXOuyC7l4Fhd6632KDhjc55YZrdCl4XfgV3XsIhnpqzmay8QgJ8PHi5XyS3tqrlog8gIlJ+KIyI/MVhh30rnK/ibvsO8rOKtoW2cQaQiL5QOfiip8nKK+TZeZuZvf4QAFfVq8qk2GhqV/EtzepFRMothRFxb4YByRudAWTTLMhKLtpWpa4zgEQOhKDGl3S6jQfTGDEtnv3Hc7BaYPiNjRl+YyM8bOodIiJyIQoj4r4K8yBusHNemL/4VoWWfZ0hJLz9Jc+M63AYfLhqL6//sIMCu0FooA+TYqNpX79aKRUvIlJxKIyIezIMWPiYM4jYvKDprc4A0qgreHgV61RHM3N5ZMYGVu1KBaBHRE1e7htJoJ9m2BURuRQKI+Ke/vwY1n8OWCDma2hy82Wd5ucdR3l0xgaOZ+fj42llXK+WxF4Vrt4hIiLFoDAi7mf/r7DoCefyTc9eVhDJK7TzyqIdfPLrPgCa1fTn7UHRNA7xL8lKRUTcgsKIuJe0JJhxDzgKnWNDrh1d7FPsOZbF8G/i2XokA4B7r6nHkz2a4eNpK+lqRUTcgsKIuI/8HIi7E3JSoWYr6P3uJQ9QBTAMgxl/JvHc/K2cKrBT1c+T1/pH0bVFSCkWLSJS8SmMiHswDJg/3Pkar191iP0GvPwu+fD0UwX8Z84mFmw8AkCnRtV5c2BrQgJ8SqtiERG3oTAi7uG3KbB5Flg9YOAXZ01g93fWHTjBiGkJHEo7hYfVwiM3N+Vf1zXAatUgVRGRkqAwIhXfrh/hx+ecy7e8DPWuvaTD7A6Dd3/ezeRlu7A7DOpU82PKoGhah1cptVJFRNyRwohUbMf3wKyhYDgg+m646oFLOuxw2ilGT0/gj30nAOjTOpQX+kTg76PeISIiJU1hRCqu3AyYNgjy0iGsPfR845IGrC7enMwT324k/VQBlbxsvNAngr5twlxQsIiIe1IYkYrJ4YA5/4LUHeBfC2K+BA/vix6SW2Dnhe+38vUfiQBEhgUyJTaaekEXnplXRESunMKIVEzLJ8KOhWDzdnZY9a950d23J2cwYlo8O1OcM/X+6/oGPNKtKV4emuBORKS0KYxIxbN1Pqx81bncaxKEtb3groZh8OXvB3hxwTbyCx3U8PfmzYFRdG5cwzW1ioiIwohUMClbYM6DzuUOD0HrOy+464nsfJ74diNLt6YA0KVpDV4bEEVQ5Ys/zhERkZKlMCIVR84J54DVgmyofx3c/OIFd/1tTyqjpyeQkpGHl83Kkz2acV+neprgTkTEBAojUjHYC2HmvZB2AKrUhQGfg+3cv94FdgeTftzJf5fvwTCgQY1KvD0ompahga6vWUREAIURqSiWPgv7VoCnn7PVu1+1c3ZJOpHD8GnxJCSlARB7VTjP9mqBn5f+GYiImEk/haX8S5gGv7/rXL5jKtSMOGeXeQmHeHrOZjLzCvH38eDlvpH0jKzl4kJFROR8FEakfDu0Dr4b6Vy+7jFo0fuszdl5hYybv4VZ6w4C0LZuVSbHtias6qVPkiciIqVLYUTKr8wUiLsL7HnQpAfc8J+zNm86mM6IuHj2pWZjtcDDNzZmxI2N8LCpd4iISFmiMCLlU2EezLgbMg9DUBPo+wFYnSHD4TD4+Jd9vLpkOwV2g1qBPkyKaU2HBtVNLlpERM5HYUTKH8OAhY9B0h/gHQix08AnAICjmbk8MmMDq3alAnBLy5q83K8VVfy8zKxYREQuQmFEyp8/P4b1nwMW6P8JBDUCYPmOozw6cwOpWfl4e1h5tlcL7mxfR71DRETKuMt6eP7uu+9Sr149fHx86NChA2vWrLno/mlpaQwbNoxatWrh7e1NkyZNWLhw4WUVLG5u/6+w6Annctdx0LgreYV2Xvx+K/d+upbUrHya1fTnu+HXMrhDXQUREZFyoNh3RqZPn86YMWOYOnUqHTp0YNKkSXTv3p0dO3YQHBx8zv75+fl069aN4OBgZs2aRe3atTlw4ABVqlQpifrFnaQlwYx7wFEIEf2g0yj2HMtixLR4thzOAGBIx7qMvbU5Pp42k4sVEZFLZTEMwyjOAR06dOCqq67inXfeAcDhcBAeHs7w4cN58sknz9l/6tSpvPbaa2zfvh1PT8/LKjIjI4PAwEDS09MJCAi4rHNIOZefA590h+SNUDMSY+hiZm48wbh5WzhVYKeqnyev9o+iW4sQsysVEZHTLvX3d7Ee0+Tn57Nu3Tq6du1adAKrla5du7J69erzHjN//nw6duzIsGHDCAkJISIiggkTJmC32y94nby8PDIyMs76EjdmGDD/YWcQ8atORp/PGT5rB4/P2sipAjsdG1Rn0cjrFERERMqpYj2mSU1NxW63ExJy9g/9kJAQtm/fft5j9u7dy08//cTgwYNZuHAhu3fv5t///jcFBQWMGzfuvMdMnDiR8ePHF6c0qch+nQybvwWrBzuuf4ehn+3nUNopbFYLY7o14cHrG2KzamyIiEh5VerdnxwOB8HBwXzwwQe0bduWmJgYnnrqKaZOnXrBY8aOHUt6evqZr6SkpNIuU8qqXT/Cj88BsLz+I9w6Dw6lnSK8mi+zHuzIsC6NFERERMq5Yt0ZCQoKwmazkZKSctb6lJQUatased5jatWqhaenJzZb0YDC5s2bk5ycTH5+Pl5e5/Z/8Pb2xtvbuzilSUWUuhtmDQUMlvnewv1bIgGD3q1DeaFPBAE+lzcGSUREypZi3Rnx8vKibdu2LFu27Mw6h8PBsmXL6Nix43mP6dSpE7t378bhcJxZt3PnTmrVqnXeICICQG4GxN0JeelsoAkPnRyEn5cHbwyIYlJMawUREZEKpNiPacaMGcOHH37I559/zrZt23jooYfIzs7mvvvuA+Cee+5h7NixZ/Z/6KGHOHHiBCNHjmTnzp0sWLCACRMmMGzYsJL7FFKxOBzYv/0HpO7giFGNB3JH0rR2EAtGdKZf2zD1DhERqWCK3WckJiaGY8eO8eyzz5KcnEzr1q1ZvHjxmUGtiYmJWK1FGSc8PJwlS5YwevRoIiMjqV27NiNHjuSJJ54ouU8hFUrqgucI2rWYPMOTf+WPpu91bXnk5qZ4eWiCOxGRiqjYfUbMoD4j7sEwDFbO/ZjrNzwCwDjrcG6KHcl1TWqYXJmIiFyOS/39rblppEw4mZ3P5GlzeSzpP2CBJf59Gf6vZwiqrIHMIiIVncKImG71nuOMi1vFR3n/oZI1j0PVOtDt3x9g9dAgVRERd6AwIqYpsDuY/OMupi7fwWcer1LHdox8/3BqPxAHCiIiIm5DYURMkXQihxFx8cQnpvG0xzdca9uC4VkJr7umg181s8sTEREXUhgRl5u/4TBPzd5EZl4hd/r8ygMsAsByx3sQ0tLk6kRExNUURsRlsvMKGTd/C7PWHQRgYK0UXsr4COzAdY9Di97mFigiIqZQGBGX2HwoneHT4tmXmo3VAk90qsI/dzyCxZ4HTW+FG8b+/UlERKRCUhiRUuVwGHzy6z5eWbydArtBrUAfJvVvTocVQyDzCAQ1hTveB6samomIuCuFESk1xzLzeGTmBlbuPAZA95YhvNK3FVWWPQoH14BPIAyaBj5qZCci4s4URqRUrNh5jEdmJJCalY+3h5Vne7XgzvZ1sKz9CNZ/ARYr9PsEqjc0u1QRETGZwoiUqLxCO68t3sFHv+wDoGmIP2/fGU2TEH/Y/wssftK5403joHFXEysVEZGyQmFESszeY1mMiItn86EMAO7pWJf/3NocH08bpCXCjHvAUQgR/aHTSJOrFRGRskJhRK6YYRjMWneQcfO3kJNvp4qfJ6/2i+TmljWdO+TnQNxgyDkONSPh9rfBYjG3aBERKTMURuSKZOQW8NSczXy34TAAHRtU562Y1tQM9HHuYBgw/2FI3gh+QRD7DXj5mVixiIiUNQojctnWJ55kxLR4Dp48hc1qYUy3Jjx4fUNs1v931+PXybD5W7B6wMAvoEq4eQWLiEiZpDAixWZ3GLy3fDdv/bgLu8MgvJovk2OjaVOn6tk77loKPz7nXO7xCtTr5PJaRUSk7FMYkWJJTs9l1PR4ft97AoDbo0J58Y4IAnz+Z5bd1N0w637AgDZDoN39ri9WRETKBYURuWQ/bEnm8W83kpZTgJ+Xjed7R9CvTW0s/zsYNTcD4gZBXjqEd4BbX9eAVRERuSCFEflbuQV2XlqwjS9/PwBARO0ApsRG06BG5XN3djhg9j8hdSf4h8LAL8HDy8UVi4hIeaIwIhe1IzmTEdPi2ZGSCcA/Otfnse7N8PK4wFwyyyfAzkVg84bYr8A/xIXViohIeaQwIudlGAZf/5HIC99vJa/QQVBlb94YGMX1TWpc+KCt82Dla87l26dA7bauKVZERMo1hRE5x8nsfJ74diM/bE0B4PomNXh9QBQ1/L0vfFDyZpjzkHP56mEQFeuCSkVEpCJQGJGz/L73OKPiEkjOyMXTZuGJW5oxtFN9rNaLDEDNOQFxd0JBNjS4Abo977J6RUSk/FMYEQAK7Q4mL9vFOz/vxjCgQVAlpgyKJqJ24MUPtBfCzCGQdgCq1oP+n4JNf61EROTS6beGkHQih5Fx8axPTANgQNswnru9JZW8L+Gvx9JnYN9K8KwEsdPAr1rpFisiIhWOwoib+27DYf4zZxOZuYX4e3swoW8rekWFXtrBCd/A7/91Lt8xFUJalF6hIiJSYSmMuKmc/EKem7+FGX8eBKBNnSpMjo0mvNolTmJ3cB18N8q5fP0T0OL20ilUREQqPIURN7T5UDojpsWzNzUbiwWG3dCIUV0b42G7QO+Q/5WZDNMHgz0PmvaE658s3YJFRKRCUxhxIw6HwSe/7uOVxdspsBvUDPDhrZjWdGxY/dJPUpgH0++GzCMQ1NT5eMZ6iSFGRETkPBRG3ERqVh6PztzA8h3HALi5RQiv9IukaqVitGo3DFjwCBxcAz6BMGga+ASUUsUiIuIuFEbcwMqdxxgzYwOpWXl4e1h5+rYW3NWhzrkT3P2dtR9B/JdgsUL/T6B6w9IpWERE3IrCSAWWX+jg9R928MHKvQA0CanM24Pa0LSmf/FPtv8XWHx6bEjX56BR15IrVERE3JrCSAW1LzWbEdPi2XQoHYC7r67LUz2b4+NpK/7J0hJhxj3gKISI/nDNiBKuVkRE3JnCSAVjGAbfrj/Es/M2k5Nvp4qfJ6/0i6R7y5qXd8L8HGer95zjUCsKbn8bivt4R0RE5CIURiqQjNwCnp6zmfkbDgNwdYNqvBXTmlqBvpd3QsOAecMgeRP4BUHM1+B1iX1IRERELpHCSAWxPvEkI+PiSTpxCpvVwuiujXnohkbYLjbB3d/5dRJsmQ1WD4j5EqqEl1i9IiIif1EYKefsDoOpK/bw5tKd2B0GYVV9mRwbTdu6Va/sxDt/gB/HO5d7vAJ1r7nyYkVERM5DYaQcS07PZfT0BFbvPQ7AbZG1mNC3FQE+nld24tTd8O0DgAFt74V2919xrSIiIheiMFJO/bg1hcdmbeBkTgF+Xjaeu70lA9qGFb93yP/KzYC4QZCXDuFXQ4/XNGBVRERKlcJIOZNbYGfCwm18sfoAAC1DA3h7UDQNalS+8pM7HDD7n5C6E/xDYeAX4FGMDq0iIiKXQWGkHNmVksnwafFsT84E4IFr6/PYLU3x9riM3iHns3wC7FwEHj4Q+zX4h5TMeUVERC5CYaQcMAyDr/9I5IXvt5JX6CCoshevD4jihqbBJXeRLXNh5WvO5V5ToHabkju3iIjIRSiMlHFpOfk88e1GlmxJAeC6JjV4Y0AUNfy9S+4iyZth7kPO5Y4PQ1RMyZ1bRETkbyiMlGF/7D3OqOkJHEnPxdNm4YlbmjG0U32sV9I75H/lnHB2WC3IgQZdoOv4kju3iIjIJVAYKYMK7Q6mLNvFOz/vxmFA/aBKTImNplVYYMleKDsVZt0HaQegaj3nTLw2/ZUQERHX0m+eMubgyRxGxiWw7sBJAPq3DWP87S2p5F1C/6nyc2DHQtg4A3b/CIYdPCtB7DTwq1Yy1xARESkGhZEy5PuNhxk7exOZuYX4e3vw4h0R9G5d+8pP7LDDvpXOALJtPuRnFW0LjYZuz0NIiyu/joiIyGVQGCkDcvILGT9/K9P/TAIguk4VpsRGE17tCialMwznBHcbp8OmWZCVXLStSh2IjIFWA6FGkyusXkRE5MoojJhsy+F0hk+LZ++xbCwWGHZDI0Z2bYynzXp5J0xLgk0znXdBjm0rWu9TBSL6OkNIeAd1VRURkTJDYcQkhmHwya/7eWXRdvLtDkICvHkrpjXXNAwq/slOpcHWec4AcuCXovU2b2h6izOANOqmbqoiIlImKYyYIDUrj8dmbuDnHccA6No8hFf7R1KtUjHCQmEe7FrqfAyzczHY84u21esMkQOh+e3gW6VkixcRESlhCiMutmrXMcbM2MCxzDy8PKw807M5d11d99ImuHM4IOkPZwDZMgdy04q21WjubFYW0R+qhJda/SIiIiVNYcRF8gsdvPHDDt5fuReAJiGVmTIommY1A/7+4GM7Tw9EnQFpiUXr/WtBq/7OxzAhERoHIiIi5ZLCiAvsT81mRFw8Gw+mAzC4Qx2e7tkCX6+LTHCXmQKbv3WGkCMJReu9KkOL3s7HMPU6g7WEJskTERExicJIKZu9/iDPzN1Mdr6dQF9PXukXyS0RNc+/c14WbF/gDCB7fwbD4Vxv9YBGXZ0BpEkP8LqCV35FRETKGIWRUpKZW8AzczczN+EwAO3rV2NSTGtCq/ievaO9EPYudwaQ7d8754j5S9hVzkcwLe+ASpfxlo2IiEg5oDBSCuITTzIyLoHEEznYrBZG3dSYf3dphO2vCe4MAw7HO1/F3TwLso8VHVytwemGZAOgekNzPoCIiIgLKYyUIIfDYOrKPbz5w04KHQa1q/gyZVBr2tY9PefLyf1FDclSdxYd6FcdIvo5Q0jtthqIKiIibuWy2ny+++671KtXDx8fHzp06MCaNWsu6bi4uDgsFgt9+vS5nMuWaSkZudz9yR+8ungHhQ6DnpG1WDiyM21rAH9+Ap/cApOj4KcXnUHEw8cZQO6cAY/sgFtfg7B2CiIiIuJ2in1nZPr06YwZM4apU6fSoUMHJk2aRPfu3dmxYwfBwcEXPG7//v08+uijdO7c+YoKLouWbUvh0ZkbOJlTgK+njRd6NqKf/2Ys896AnUvAUXB6TwvUv855B6R5L/C5hNd6RUREKjiLYRhGcQ7o0KEDV111Fe+88w4ADoeD8PBwhg8fzpNPPnneY+x2O9dddx1Dhw5l1apVpKWlMXfu3Eu+ZkZGBoGBgaSnpxMQUHZ+gecW2Hl50XY++20/FhwMCEri6TqbCNizAPLSi3YMaeV8E6ZVfwgINa9gERERF7rU39/FujOSn5/PunXrGDt27Jl1VquVrl27snr16gse9/zzzxMcHMz999/PqlWr/vY6eXl55OXlnflzRkZGccp0id1HM3n4m3jsKdt43OMXBvv9QWBWCmw9vUNAbecg1MiBENLS1FpFRETKsmKFkdTUVOx2OyEhIWetDwkJYfv27ec95pdffuHjjz8mISHhkq8zceJExo8fX5zSXMYwDOatWseOHz/lDVbR0vuAc0M+4B1wuiFZDNTtBNbLnHlXRETEjZTq2zSZmZncfffdfPjhhwQFXXqfjLFjxzJmzJgzf87IyCA83OT5VvIyydkwlwM/f8rtOeuxWp1PtwyrJ5bGN59uSHYLePqYW6eIiEg5U6wwEhQUhM1mIyUl5az1KSkp1Kx5blfRPXv2sH//fnr16nVmncPh7Crq4eHBjh07aNjw3F4a3t7eeHt7F6e00mEvgD0/wcbp2LctwM+eS3MACyQHtia40z1YI+4Av2pmVyoiIlJuFSuMeHl50bZtW5YtW3bm9VyHw8GyZct4+OGHz9m/WbNmbNq06ax1Tz/9NJmZmUyePNn8ux3nYxhwaJ2zI+rmbyHnOAA2YI+jFsu9u9Dpjodo1iLS3DpFREQqiGI/phkzZgxDhgyhXbt2tG/fnkmTJpGdnc19990HwD333EPt2rWZOHEiPj4+REREnHV8lSpVAM5Zb7rje043JJsOJ/aeWZ1mrcLs/KuZY7+WJq07M75PBJW91StORESkpBT7t2pMTAzHjh3j2WefJTk5mdatW7N48eIzg1oTExOxlpeBm9mpsGWOM4AcXFu03tOPQzVv4sWkVvyQ0xxfb29e6h9B79a1zatVRESkgip2nxEzlEqfEYcD3mwGWafHv1is0KALeS37M2FPAz5f53w8ExVehbdjo6lTXTPlioiIFEep9BmpUKxWZxfUg386X8WN6MfWTF+GT1vPnmPHsVjgoesbMrpbEzxt5eROj4iISDnkvmEE4JaXweaJYRh89tt+Ji5cT77dQbC/N5NiWnNNo0t/HVlEREQuj3uHEZsnx7PyeGzWRn7afhSArs2DebV/FNUqeZlcnIiIiHtw6zDyy65UxsxI4GhmHl4eVp66tTn3dKyLRTPnioiIuIzbhpFT+XZGTU8gNSuPRsGVeXtQNM1rlZ1J+ERERNyF24YRXy8brw2IZOnWFJ7p2QJfL5vZJYmIiLgltw0jAF2aBtOlabDZZYiIiLg1vbMqIiIiplIYEREREVMpjIiIiIipFEZERETEVAojIiIiYiqFERERETGVwoiIiIiYSmFERERETKUwIiIiIqZSGBERERFTKYyIiIiIqRRGRERExFQKIyIiImKqcjFrr2EYAGRkZJhciYiIiFyqv35v//V7/ELKRRjJzMwEIDw83ORKREREpLgyMzMJDAy84HaL8XdxpQxwOBwcPnwYf39/LBZLiZ03IyOD8PBwkpKSCAgIKLHzlifu/j1w988P+h7o87v35wd9D0rz8xuGQWZmJqGhoVitFx4ZUi7ujFitVsLCwkrt/AEBAW75F/D/c/fvgbt/ftD3QJ/fvT8/6HtQWp//YndE/qIBrCIiImIqhRERERExlVuHEW9vb8aNG4e3t7fZpZjG3b8H7v75Qd8DfX73/vyg70FZ+PzlYgCriIiIVFxufWdEREREzKcwIiIiIqZSGBERERFTKYyIiIiIqdw6jLz77rvUq1cPHx8fOnTowJo1a8wuyWVWrlxJr169CA0NxWKxMHfuXLNLcqmJEydy1VVX4e/vT3BwMH369GHHjh1ml+Uy7733HpGRkWeaHHXs2JFFixaZXZZpXn75ZSwWC6NGjTK7FJd57rnnsFgsZ301a9bM7LJc6tChQ9x1111Ur14dX19fWrVqxZ9//ml2WS5Tr169c/4OWCwWhg0b5vJa3DaMTJ8+nTFjxjBu3DjWr19PVFQU3bt35+jRo2aX5hLZ2dlERUXx7rvvml2KKVasWMGwYcP4/fffWbp0KQUFBdx8881kZ2ebXZpLhIWF8fLLL7Nu3Tr+/PNPbrzxRnr37s2WLVvMLs3l1q5dy/vvv09kZKTZpbhcy5YtOXLkyJmvX375xeySXObkyZN06tQJT09PFi1axNatW3njjTeoWrWq2aW5zNq1a8/677906VIABgwY4PpiDDfVvn17Y9iwYWf+bLfbjdDQUGPixIkmVmUOwJgzZ47ZZZjq6NGjBmCsWLHC7FJMU7VqVeOjjz4yuwyXyszMNBo3bmwsXbrUuP76642RI0eaXZLLjBs3zoiKijK7DNM88cQTxrXXXmt2GWXKyJEjjYYNGxoOh8Pl13bLOyP5+fmsW7eOrl27nllntVrp2rUrq1evNrEyMUt6ejoA1apVM7kS17Pb7cTFxZGdnU3Hjh3NLselhg0bRs+ePc/6WeBOdu3aRWhoKA0aNGDw4MEkJiaaXZLLzJ8/n3bt2jFgwACCg4OJjo7mww8/NLss0+Tn5/PVV18xdOjQEp2Q9lK5ZRhJTU3FbrcTEhJy1vqQkBCSk5NNqkrM4nA4GDVqFJ06dSIiIsLsclxm06ZNVK5cGW9vbx588EHmzJlDixYtzC7LZeLi4li/fj0TJ040uxRTdOjQgc8++4zFixfz3nvvsW/fPjp37kxmZqbZpbnE3r17ee+992jcuDFLlizhoYceYsSIEXz++edml2aKuXPnkpaWxr333mvK9cvFrL0ipWnYsGFs3rzZrZ6XAzRt2pSEhATS09OZNWsWQ4YMYcWKFW4RSJKSkhg5ciRLly7Fx8fH7HJM0aNHjzPLkZGRdOjQgbp16zJjxgzuv/9+EytzDYfDQbt27ZgwYQIA0dHRbN68malTpzJkyBCTq3O9jz/+mB49ehAaGmrK9d3yzkhQUBA2m42UlJSz1qekpFCzZk2TqhIzPPzww3z//ff8/PPPhIWFmV2OS3l5edGoUSPatm3LxIkTiYqKYvLkyWaX5RLr1q3j6NGjtGnTBg8PDzw8PFixYgVTpkzBw8MDu91udokuV6VKFZo0acLu3bvNLsUlatWqdU7wbt68uVs9qvrLgQMH+PHHH3nggQdMq8Etw4iXlxdt27Zl2bJlZ9Y5HA6WLVvmds/M3ZVhGDz88MPMmTOHn376ifr165tdkukcDgd5eXlml+ESN910E5s2bSIhIeHMV7t27Rg8eDAJCQnYbDazS3S5rKws9uzZQ61atcwuxSU6dep0zuv8O3fupG7duiZVZJ5PP/2U4OBgevbsaVoNbvuYZsyYMQwZMoR27drRvn17Jk2aRHZ2Nvfdd5/ZpblEVlbWWf8HtG/fPhISEqhWrRp16tQxsTLXGDZsGN988w3z5s3D39//zFihwMBAfH19Ta6u9I0dO5YePXpQp04dMjMz+eabb1i+fDlLliwxuzSX8Pf3P2d8UKVKlahevbrbjBt69NFH6dWrF3Xr1uXw4cOMGzcOm83GoEGDzC7NJUaPHs0111zDhAkTGDhwIGvWrOGDDz7ggw8+MLs0l3I4HHz66acMGTIEDw8TI4HL398pQ95++22jTp06hpeXl9G+fXvj999/N7skl/n5558N4JyvIUOGmF2aS5zvswPGp59+anZpLjF06FCjbt26hpeXl1GjRg3jpptuMn744QezyzKVu73aGxMTY9SqVcvw8vIyateubcTExBi7d+82uyyX+u6774yIiAjD29vbaNasmfHBBx+YXZLLLVmyxACMHTt2mFqHxTAMw5wYJCIiIuKmY0ZERESk7FAYEREREVMpjIiIiIipFEZERETEVAojIiIiYiqFERERETGVwoiIiIiYSmFERERETKUwIiIiIqZSGBERERFTKYyIiIiIqRRGRERExFT/ByqTugv0ALidAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "ValueError", + "evalue": "Missing input(s) '['site.distance_to_landfall']'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparametric1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moss_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparameters\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;32m~\\ORBIT\\ORBIT\\parametric.py\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m 275\u001b[0m \u001b[0mmissing\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 276\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmissing\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 277\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Missing input(s) '{missing}'\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 278\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 279\u001b[0m \u001b[0minputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mv\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mValueError\u001b[0m: Missing input(s) '['site.distance_to_landfall']'" + ] + } + ], + "source": [ + "plt.plot(model1.predict(parameters))\n", + "plt.plot(parametric1.results.oss_cost)\n", + "plt.show()\n", + "print(model.predict(parameters))" + ] + }, + { + "cell_type": "markdown", + "id": "49143465-3b7a-439a-a842-73c0475670d8", + "metadata": {}, + "source": [ + "# Both (2 independent variables)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "543f7edf-88c6-42f6-909d-dac55d08cfad", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml b/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml new file mode 100644 index 00000000..0034c121 --- /dev/null +++ b/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1510 +site: + depth: 43 + distance: 150 + distance_to_landfall: 25.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml b/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml new file mode 100644 index 00000000..eb61ed57 --- /dev/null +++ b/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1500 +site: + depth: 43 + distance: 150 + distance_to_landfall: 25.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Bay State Wind base.yaml b/shared_transmission_configs/Bay State Wind base.yaml new file mode 100644 index 00000000..402517b4 --- /dev/null +++ b/shared_transmission_configs/Bay State Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 2277 +site: + depth: 43 + distance: 65 + distance_to_landfall: 33.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Beacon Wind base.yaml b/shared_transmission_configs/Beacon Wind base.yaml new file mode 100644 index 00000000..08695b0e --- /dev/null +++ b/shared_transmission_configs/Beacon Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1230 +site: + depth: 43 + distance: 118 + distance_to_landfall: 96.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/CVOW Commercial base.yaml b/shared_transmission_configs/CVOW Commercial base.yaml new file mode 100644 index 00000000..404a9a53 --- /dev/null +++ b/shared_transmission_configs/CVOW Commercial base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 2580 +site: + depth: 43 + distance: 100 + distance_to_landfall: 43.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Empire Wind 2 base.yaml b/shared_transmission_configs/Empire Wind 2 base.yaml new file mode 100644 index 00000000..aec4d305 --- /dev/null +++ b/shared_transmission_configs/Empire Wind 2 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1260 +site: + depth: 43 + distance: 285 + distance_to_landfall: 48.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Empire Wind base.yaml b/shared_transmission_configs/Empire Wind base.yaml new file mode 100644 index 00000000..5dc55135 --- /dev/null +++ b/shared_transmission_configs/Empire Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 816 +site: + depth: 43 + distance: 295 + distance_to_landfall: 32.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/Garden State Offshore Energy base.yaml b/shared_transmission_configs/Garden State Offshore Energy base.yaml new file mode 100644 index 00000000..72c2b43c --- /dev/null +++ b/shared_transmission_configs/Garden State Offshore Energy base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1050 +site: + depth: 43 + distance: 105 + distance_to_landfall: 17.0 +turbine: + turbine_rating: 10 diff --git a/shared_transmission_configs/Hudson North WEA base.yaml b/shared_transmission_configs/Hudson North WEA base.yaml new file mode 100644 index 00000000..adee2bc1 --- /dev/null +++ b/shared_transmission_configs/Hudson North WEA base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1059 +site: + depth: 43 + distance: 315 + distance_to_landfall: .nan +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Hudson South WEA base.yaml b/shared_transmission_configs/Hudson South WEA base.yaml new file mode 100644 index 00000000..056a7ec6 --- /dev/null +++ b/shared_transmission_configs/Hudson South WEA base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1024 +site: + depth: 43 + distance: 280 + distance_to_landfall: .nan +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Kitty Hawk base.yaml b/shared_transmission_configs/Kitty Hawk base.yaml new file mode 100644 index 00000000..e865e8a5 --- /dev/null +++ b/shared_transmission_configs/Kitty Hawk base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 2400 +site: + depth: 43 + distance: 150 + distance_to_landfall: 43.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Liberty Wind base.yaml b/shared_transmission_configs/Liberty Wind base.yaml new file mode 100644 index 00000000..8421f67f --- /dev/null +++ b/shared_transmission_configs/Liberty Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1600 +site: + depth: 43 + distance: 145 + distance_to_landfall: 135.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/MarWin base.yaml b/shared_transmission_configs/MarWin base.yaml new file mode 100644 index 00000000..f6eb43f3 --- /dev/null +++ b/shared_transmission_configs/MarWin base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 248 +site: + depth: 43 + distance: 143 + distance_to_landfall: 27.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/Mayflower Res base.yaml b/shared_transmission_configs/Mayflower Res base.yaml new file mode 100644 index 00000000..68ccc0e5 --- /dev/null +++ b/shared_transmission_configs/Mayflower Res base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 747 +site: + depth: 43 + distance: 135 + distance_to_landfall: 50.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Mayflower Wind 1 base.yaml b/shared_transmission_configs/Mayflower Wind 1 base.yaml new file mode 100644 index 00000000..3feaaa36 --- /dev/null +++ b/shared_transmission_configs/Mayflower Wind 1 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 804 +site: + depth: 43 + distance: 135 + distance_to_landfall: 60.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Mayflower Wind 2 base.yaml b/shared_transmission_configs/Mayflower Wind 2 base.yaml new file mode 100644 index 00000000..e67deacf --- /dev/null +++ b/shared_transmission_configs/Mayflower Wind 2 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 747 +site: + depth: 43 + distance: 135 + distance_to_landfall: 60.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Momentum Wind base.yaml b/shared_transmission_configs/Momentum Wind base.yaml new file mode 100644 index 00000000..5e1ee77a --- /dev/null +++ b/shared_transmission_configs/Momentum Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1205 +site: + depth: 43 + distance: 143 + distance_to_landfall: .nan +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Ocean Wind 1 base.yaml b/shared_transmission_configs/Ocean Wind 1 base.yaml new file mode 100644 index 00000000..9cc9abfd --- /dev/null +++ b/shared_transmission_configs/Ocean Wind 1 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1104 +site: + depth: 43 + distance: 128 + distance_to_landfall: 25.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/Ocean Wind 2 base.yaml b/shared_transmission_configs/Ocean Wind 2 base.yaml new file mode 100644 index 00000000..ec2ddd76 --- /dev/null +++ b/shared_transmission_configs/Ocean Wind 2 base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1148 +site: + depth: 43 + distance: 128 + distance_to_landfall: 25.0 +turbine: + turbine_rating: 14 diff --git a/shared_transmission_configs/Ocean Wind Res base.yaml b/shared_transmission_configs/Ocean Wind Res base.yaml new file mode 100644 index 00000000..49438892 --- /dev/null +++ b/shared_transmission_configs/Ocean Wind Res base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1148 +site: + depth: 43 + distance: 128 + distance_to_landfall: 50.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Park City Wind base.yaml b/shared_transmission_configs/Park City Wind base.yaml new file mode 100644 index 00000000..c0f1a18e --- /dev/null +++ b/shared_transmission_configs/Park City Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 804 +site: + depth: 43 + distance: 120 + distance_to_landfall: 37.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Revolution Wind (CT) base.yaml b/shared_transmission_configs/Revolution Wind (CT) base.yaml new file mode 100644 index 00000000..6b48b9ae --- /dev/null +++ b/shared_transmission_configs/Revolution Wind (CT) base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 304 +site: + depth: 43 + distance: 80 + distance_to_landfall: 15.0 +turbine: + turbine_rating: 11 diff --git a/shared_transmission_configs/Revolution Wind (RI) base.yaml b/shared_transmission_configs/Revolution Wind (RI) base.yaml new file mode 100644 index 00000000..80ce4bac --- /dev/null +++ b/shared_transmission_configs/Revolution Wind (RI) base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 400 +site: + depth: 43 + distance: 80 + distance_to_landfall: 15.0 +turbine: + turbine_rating: 11 diff --git a/shared_transmission_configs/Skipjack base.yaml b/shared_transmission_configs/Skipjack base.yaml new file mode 100644 index 00000000..aac7734a --- /dev/null +++ b/shared_transmission_configs/Skipjack base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 120 +site: + depth: 43 + distance: 115 + distance_to_landfall: 30.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/South Fork base.yaml b/shared_transmission_configs/South Fork base.yaml new file mode 100644 index 00000000..3c5c698f --- /dev/null +++ b/shared_transmission_configs/South Fork base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 130 +site: + depth: 43 + distance: 57 + distance_to_landfall: 56.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/Sunrise Wind base.yaml b/shared_transmission_configs/Sunrise Wind base.yaml new file mode 100644 index 00000000..2250012a --- /dev/null +++ b/shared_transmission_configs/Sunrise Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 880 +site: + depth: 43 + distance: 90 + distance_to_landfall: 48.0 +turbine: + turbine_rating: 8 diff --git a/shared_transmission_configs/TBD SC Lease base.yaml b/shared_transmission_configs/TBD SC Lease base.yaml new file mode 100644 index 00000000..2e322cad --- /dev/null +++ b/shared_transmission_configs/TBD SC Lease base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 400 +site: + depth: 43 + distance: 668 + distance_to_landfall: .nan +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Untitled.ipynb b/shared_transmission_configs/Untitled.ipynb new file mode 100644 index 00000000..cee6d224 --- /dev/null +++ b/shared_transmission_configs/Untitled.ipynb @@ -0,0 +1,694 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f57aa6ac-eff2-49b5-9897-de4e4d82aefb", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "import yaml\n", + "import pandas as pd\n", + "import numpy as np\n", + "from copy import deepcopy\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib import cm\n", + "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b1c57ade-d71e-4df3-ae7a-7c29f2612138", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_excel(\"C:/Users/sbredenk/ORBIT/osw_project_details.xlsx\",sheet_name=0)\n", + "proj_name = df['name'].to_list()\n", + "filename = deepcopy(proj_name)\n", + "for i in range(0,len(filename)):\n", + " filename[i] = \"%s base.yaml\" % proj_name[i]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "68659d52-49cd-4bc0-bd95-1fe91e8e8f42", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'c:\\users\\sbredenk\\orbit\\library'\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" + ] + } + ], + "source": [ + "total_capex = {}\n", + "for i in range(0,len(proj_name)):\n", + " with open(filename[i], \"r\") as fh:\n", + " config = yaml.load(fh, Loader=yaml.SafeLoader)\n", + " project = ProjectManager(config)\n", + " project.run()\n", + " total_capex[proj_name[i]] = project.capex_breakdown\n", + "# print(total_capex)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d239ca15-e8d1-491a-b0a3-3e7f2ecc9298", + "metadata": {}, + "outputs": [], + "source": [ + "# # print(filename[0])\n", + "# # config = yaml.load(filename[0], Loader=yaml.SafeLoader)\n", + "# with open(filename[0], \"r\") as fh:\n", + "# config = yaml.load(fh, Loader=yaml.SafeLoader)\n", + "# print(config)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2a7f96d0-e7b8-4974-b7fa-480e3be6de25", + "metadata": {}, + "outputs": [], + "source": [ + "# project = ProjectManager(config)\n", + "# project.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "81a3b807-9b1e-44bd-89c2-aa662441c331", + "metadata": {}, + "outputs": [], + "source": [ + "# project.capex_breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "dca4e2f1-88b2-45b7-be71-4495766f7864", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Export SystemOffshore SubstationExport System InstallationOffshore Substation InstallationTurbineSoftProjectTotal
Bay State Wind2.303148e+089.175986e+083.960141e+086.269466e+062.964000e+091.468665e+091.512500e+086.134112e+09
Park City Wind8.529159e+072.488645e+081.464821e+085.541351e+061.053000e+095.185800e+081.512500e+082.209009e+09
Vineyard Wind7.677159e+071.055821e+081.451418e+083.144713e+061.045200e+095.160000e+081.512500e+082.043090e+09
Beacon Wind3.516026e+085.239363e+082.320882e+085.505487e+061.599000e+097.933500e+081.512500e+083.656733e+09
Mayflower Wind 11.342816e+082.882594e+081.501469e+085.810329e+061.053000e+095.185800e+081.512500e+082.301328e+09
Mayflower Wind 21.342816e+081.250785e+081.402435e+083.448699e+069.750000e+084.818150e+081.512500e+082.011117e+09
Liberty Wind5.880632e+087.717445e+083.084256e+085.989648e+062.086500e+091.032000e+091.512500e+084.943973e+09
Sunrise Wind1.449621e+083.073611e+081.626852e+085.003394e+061.144000e+095.676000e+081.512500e+082.482862e+09
Revolution Wind (CT)2.562106e+074.832802e+076.106156e+072.971007e+064.004000e+081.960800e+081.512500e+088.857116e+08
Revolution Wind (RI)2.562106e+075.558142e+077.740593e+072.971007e+065.291000e+082.580000e+081.512500e+081.099929e+09
South Fork4.192053e+074.237166e+073.278349e+072.771245e+061.716000e+088.385000e+071.512500e+085.265469e+08
Empire Wind7.464159e+072.403004e+081.474387e+088.679431e+061.060800e+095.263200e+081.512500e+082.209430e+09
Empire Wind 21.812026e+083.929549e+082.295573e+088.500112e+061.638000e+098.127000e+081.512500e+083.414165e+09
Atlantic Shores Offshore Wind 11.194632e+083.804164e+082.651961e+086.079307e+061.969500e+099.739500e+081.512500e+083.865855e+09
Atlantic Shores Offshore Wind 21.194632e+083.804164e+082.627205e+086.079307e+061.950000e+099.675000e+081.512500e+083.837429e+09
Ocean Wind 19.955265e+073.031187e+081.962150e+085.684806e+061.435200e+097.120800e+081.512500e+082.903101e+09
Ocean Wind 29.955265e+073.091632e+082.034770e+085.684806e+061.492400e+097.404600e+081.512500e+083.001988e+09
Garden State Offshore Energy5.692212e+072.607424e+081.853546e+085.272372e+061.365000e+096.772500e+081.512500e+082.701792e+09
Skipjack2.346053e+073.434497e+072.965637e+073.274993e+061.560000e+087.740000e+071.512500e+084.753869e+08
MarWin2.133053e+074.255531e+075.139725e+073.518181e+063.276000e+081.599600e+081.512500e+087.576113e+08
CVOW Commercial3.269053e+081.538904e+094.552726e+089.258712e+063.354000e+091.664100e+091.512500e+087.499690e+09
Kitty Hawk2.942148e+081.027316e+094.243994e+088.579636e+063.120000e+091.548000e+091.512500e+086.573760e+09
Vineyard Wind South2.259632e+084.660576e+082.700570e+085.541351e+061.950000e+099.675000e+081.512500e+084.036369e+09
Mayflower Res1.129816e+081.165144e+081.394695e+083.448699e+069.750000e+084.818150e+081.512500e+081.980479e+09
Ocean Wind Res1.883026e+083.805308e+082.109008e+085.684806e+061.501500e+097.404600e+081.512500e+083.178629e+09
Hudson North WEANaNNaN1.863273e+089.038069e+061.384500e+096.830550e+081.512500e+082.414170e+09
Hudson South WEANaNNaN1.812817e+088.410453e+061.345500e+096.604800e+081.512500e+082.346922e+09
Momentum WindNaNNaN2.109680e+085.953784e+061.579500e+097.772250e+081.512500e+082.724897e+09
TBD SC LeaseNaNNaN7.693624e+078.090997e+065.265000e+082.580000e+081.512500e+081.020777e+09
TOTAL3.782688e+099.308041e+095.579104e+091.662062e+084.015180e+101.986278e+104.386250e+098.323686e+10
\n", + "
" + ], + "text/plain": [ + " Export System Offshore Substation \\\n", + "Bay State Wind 2.303148e+08 9.175986e+08 \n", + "Park City Wind 8.529159e+07 2.488645e+08 \n", + "Vineyard Wind 7.677159e+07 1.055821e+08 \n", + "Beacon Wind 3.516026e+08 5.239363e+08 \n", + "Mayflower Wind 1 1.342816e+08 2.882594e+08 \n", + "Mayflower Wind 2 1.342816e+08 1.250785e+08 \n", + "Liberty Wind 5.880632e+08 7.717445e+08 \n", + "Sunrise Wind 1.449621e+08 3.073611e+08 \n", + "Revolution Wind (CT) 2.562106e+07 4.832802e+07 \n", + "Revolution Wind (RI) 2.562106e+07 5.558142e+07 \n", + "South Fork 4.192053e+07 4.237166e+07 \n", + "Empire Wind 7.464159e+07 2.403004e+08 \n", + "Empire Wind 2 1.812026e+08 3.929549e+08 \n", + "Atlantic Shores Offshore Wind 1 1.194632e+08 3.804164e+08 \n", + "Atlantic Shores Offshore Wind 2 1.194632e+08 3.804164e+08 \n", + "Ocean Wind 1 9.955265e+07 3.031187e+08 \n", + "Ocean Wind 2 9.955265e+07 3.091632e+08 \n", + "Garden State Offshore Energy 5.692212e+07 2.607424e+08 \n", + "Skipjack 2.346053e+07 3.434497e+07 \n", + "MarWin 2.133053e+07 4.255531e+07 \n", + "CVOW Commercial 3.269053e+08 1.538904e+09 \n", + "Kitty Hawk 2.942148e+08 1.027316e+09 \n", + "Vineyard Wind South 2.259632e+08 4.660576e+08 \n", + "Mayflower Res 1.129816e+08 1.165144e+08 \n", + "Ocean Wind Res 1.883026e+08 3.805308e+08 \n", + "Hudson North WEA NaN NaN \n", + "Hudson South WEA NaN NaN \n", + "Momentum Wind NaN NaN \n", + "TBD SC Lease NaN NaN \n", + "TOTAL 3.782688e+09 9.308041e+09 \n", + "\n", + " Export System Installation \\\n", + "Bay State Wind 3.960141e+08 \n", + "Park City Wind 1.464821e+08 \n", + "Vineyard Wind 1.451418e+08 \n", + "Beacon Wind 2.320882e+08 \n", + "Mayflower Wind 1 1.501469e+08 \n", + "Mayflower Wind 2 1.402435e+08 \n", + "Liberty Wind 3.084256e+08 \n", + "Sunrise Wind 1.626852e+08 \n", + "Revolution Wind (CT) 6.106156e+07 \n", + "Revolution Wind (RI) 7.740593e+07 \n", + "South Fork 3.278349e+07 \n", + "Empire Wind 1.474387e+08 \n", + "Empire Wind 2 2.295573e+08 \n", + "Atlantic Shores Offshore Wind 1 2.651961e+08 \n", + "Atlantic Shores Offshore Wind 2 2.627205e+08 \n", + "Ocean Wind 1 1.962150e+08 \n", + "Ocean Wind 2 2.034770e+08 \n", + "Garden State Offshore Energy 1.853546e+08 \n", + "Skipjack 2.965637e+07 \n", + "MarWin 5.139725e+07 \n", + "CVOW Commercial 4.552726e+08 \n", + "Kitty Hawk 4.243994e+08 \n", + "Vineyard Wind South 2.700570e+08 \n", + "Mayflower Res 1.394695e+08 \n", + "Ocean Wind Res 2.109008e+08 \n", + "Hudson North WEA 1.863273e+08 \n", + "Hudson South WEA 1.812817e+08 \n", + "Momentum Wind 2.109680e+08 \n", + "TBD SC Lease 7.693624e+07 \n", + "TOTAL 5.579104e+09 \n", + "\n", + " Offshore Substation Installation \\\n", + "Bay State Wind 6.269466e+06 \n", + "Park City Wind 5.541351e+06 \n", + "Vineyard Wind 3.144713e+06 \n", + "Beacon Wind 5.505487e+06 \n", + "Mayflower Wind 1 5.810329e+06 \n", + "Mayflower Wind 2 3.448699e+06 \n", + "Liberty Wind 5.989648e+06 \n", + "Sunrise Wind 5.003394e+06 \n", + "Revolution Wind (CT) 2.971007e+06 \n", + "Revolution Wind (RI) 2.971007e+06 \n", + "South Fork 2.771245e+06 \n", + "Empire Wind 8.679431e+06 \n", + "Empire Wind 2 8.500112e+06 \n", + "Atlantic Shores Offshore Wind 1 6.079307e+06 \n", + "Atlantic Shores Offshore Wind 2 6.079307e+06 \n", + "Ocean Wind 1 5.684806e+06 \n", + "Ocean Wind 2 5.684806e+06 \n", + "Garden State Offshore Energy 5.272372e+06 \n", + "Skipjack 3.274993e+06 \n", + "MarWin 3.518181e+06 \n", + "CVOW Commercial 9.258712e+06 \n", + "Kitty Hawk 8.579636e+06 \n", + "Vineyard Wind South 5.541351e+06 \n", + "Mayflower Res 3.448699e+06 \n", + "Ocean Wind Res 5.684806e+06 \n", + "Hudson North WEA 9.038069e+06 \n", + "Hudson South WEA 8.410453e+06 \n", + "Momentum Wind 5.953784e+06 \n", + "TBD SC Lease 8.090997e+06 \n", + "TOTAL 1.662062e+08 \n", + "\n", + " Turbine Soft Project \\\n", + "Bay State Wind 2.964000e+09 1.468665e+09 1.512500e+08 \n", + "Park City Wind 1.053000e+09 5.185800e+08 1.512500e+08 \n", + "Vineyard Wind 1.045200e+09 5.160000e+08 1.512500e+08 \n", + "Beacon Wind 1.599000e+09 7.933500e+08 1.512500e+08 \n", + "Mayflower Wind 1 1.053000e+09 5.185800e+08 1.512500e+08 \n", + "Mayflower Wind 2 9.750000e+08 4.818150e+08 1.512500e+08 \n", + "Liberty Wind 2.086500e+09 1.032000e+09 1.512500e+08 \n", + "Sunrise Wind 1.144000e+09 5.676000e+08 1.512500e+08 \n", + "Revolution Wind (CT) 4.004000e+08 1.960800e+08 1.512500e+08 \n", + "Revolution Wind (RI) 5.291000e+08 2.580000e+08 1.512500e+08 \n", + "South Fork 1.716000e+08 8.385000e+07 1.512500e+08 \n", + "Empire Wind 1.060800e+09 5.263200e+08 1.512500e+08 \n", + "Empire Wind 2 1.638000e+09 8.127000e+08 1.512500e+08 \n", + "Atlantic Shores Offshore Wind 1 1.969500e+09 9.739500e+08 1.512500e+08 \n", + "Atlantic Shores Offshore Wind 2 1.950000e+09 9.675000e+08 1.512500e+08 \n", + "Ocean Wind 1 1.435200e+09 7.120800e+08 1.512500e+08 \n", + "Ocean Wind 2 1.492400e+09 7.404600e+08 1.512500e+08 \n", + "Garden State Offshore Energy 1.365000e+09 6.772500e+08 1.512500e+08 \n", + "Skipjack 1.560000e+08 7.740000e+07 1.512500e+08 \n", + "MarWin 3.276000e+08 1.599600e+08 1.512500e+08 \n", + "CVOW Commercial 3.354000e+09 1.664100e+09 1.512500e+08 \n", + "Kitty Hawk 3.120000e+09 1.548000e+09 1.512500e+08 \n", + "Vineyard Wind South 1.950000e+09 9.675000e+08 1.512500e+08 \n", + "Mayflower Res 9.750000e+08 4.818150e+08 1.512500e+08 \n", + "Ocean Wind Res 1.501500e+09 7.404600e+08 1.512500e+08 \n", + "Hudson North WEA 1.384500e+09 6.830550e+08 1.512500e+08 \n", + "Hudson South WEA 1.345500e+09 6.604800e+08 1.512500e+08 \n", + "Momentum Wind 1.579500e+09 7.772250e+08 1.512500e+08 \n", + "TBD SC Lease 5.265000e+08 2.580000e+08 1.512500e+08 \n", + "TOTAL 4.015180e+10 1.986278e+10 4.386250e+09 \n", + "\n", + " Total \n", + "Bay State Wind 6.134112e+09 \n", + "Park City Wind 2.209009e+09 \n", + "Vineyard Wind 2.043090e+09 \n", + "Beacon Wind 3.656733e+09 \n", + "Mayflower Wind 1 2.301328e+09 \n", + "Mayflower Wind 2 2.011117e+09 \n", + "Liberty Wind 4.943973e+09 \n", + "Sunrise Wind 2.482862e+09 \n", + "Revolution Wind (CT) 8.857116e+08 \n", + "Revolution Wind (RI) 1.099929e+09 \n", + "South Fork 5.265469e+08 \n", + "Empire Wind 2.209430e+09 \n", + "Empire Wind 2 3.414165e+09 \n", + "Atlantic Shores Offshore Wind 1 3.865855e+09 \n", + "Atlantic Shores Offshore Wind 2 3.837429e+09 \n", + "Ocean Wind 1 2.903101e+09 \n", + "Ocean Wind 2 3.001988e+09 \n", + "Garden State Offshore Energy 2.701792e+09 \n", + "Skipjack 4.753869e+08 \n", + "MarWin 7.576113e+08 \n", + "CVOW Commercial 7.499690e+09 \n", + "Kitty Hawk 6.573760e+09 \n", + "Vineyard Wind South 4.036369e+09 \n", + "Mayflower Res 1.980479e+09 \n", + "Ocean Wind Res 3.178629e+09 \n", + "Hudson North WEA 2.414170e+09 \n", + "Hudson South WEA 2.346922e+09 \n", + "Momentum Wind 2.724897e+09 \n", + "TBD SC Lease 1.020777e+09 \n", + "TOTAL 8.323686e+10 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dfcapex = pd.DataFrame.from_dict({(i): total_capex[i]\n", + " for i in total_capex.keys()},\n", + " orient='index')\n", + "\n", + "dfcapex[\"Total\"] = dfcapex.sum(axis=1)\n", + "dfcapex_T = dfcapex.T\n", + "dfcapex_T[\"TOTAL\"] = dfcapex_T.sum(axis=1)\n", + "dfcapex = dfcapex_T.T\n", + "\n", + "display(dfcapex)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2cb4e83-be91-4a08-812e-1ff6960b5e22", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/shared_transmission_configs/Vineyard Wind South base.yaml b/shared_transmission_configs/Vineyard Wind South base.yaml new file mode 100644 index 00000000..4235ec94 --- /dev/null +++ b/shared_transmission_configs/Vineyard Wind South base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 1500 +site: + depth: 43 + distance: 120 + distance_to_landfall: 50.0 +turbine: + turbine_rating: 15 diff --git a/shared_transmission_configs/Vineyard Wind base.yaml b/shared_transmission_configs/Vineyard Wind base.yaml new file mode 100644 index 00000000..41eb6524 --- /dev/null +++ b/shared_transmission_configs/Vineyard Wind base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 800 +site: + depth: 43 + distance: 100 + distance_to_landfall: 33.0 +turbine: + turbine_rating: 12 diff --git a/shared_transmission_configs/nan base.yaml b/shared_transmission_configs/nan base.yaml new file mode 100644 index 00000000..66c61c5c --- /dev/null +++ b/shared_transmission_configs/nan base.yaml @@ -0,0 +1,21 @@ +array_system: + cables: + - XLPE_630mm_66kV +design_phases: !!set + ElectricalDesign: null +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_630mm_220kV +feeder: future_feeder +install_phases: !!set + ExportCableInstallation: null + OffshoreSubstationInstallation: null +oss_install_vessel: example_heavy_lift_vessel +plant: + capacity: 30795 +site: + depth: 43 + distance: .nan + distance_to_landfall: .nan +turbine: + turbine_rating: .nan diff --git a/tests/data/library/cables/XLPE_630mm_33kV.yaml b/tests/data/library/cables/XLPE_630mm_33kV.yaml index 27839b82..db4005ef 100644 --- a/tests/data/library/cables/XLPE_630mm_33kV.yaml +++ b/tests/data/library/cables/XLPE_630mm_33kV.yaml @@ -7,3 +7,4 @@ inductance: 0.35 linear_density: 42.5 name: XLPE_630mm_33kV rated_voltage: 33 +cable_type: HVAC diff --git a/tests/data/library/project/config/export_design.yaml b/tests/data/library/project/config/export_design.yaml index db5bbef5..4cab54c7 100644 --- a/tests/data/library/project/config/export_design.yaml +++ b/tests/data/library/project/config/export_design.yaml @@ -1,5 +1,5 @@ export_system_design: - cables: XLPE_300mm_33kV + cables: XLPE_630mm_33kV percent_added_length: 0.01 percent_redundant: 0.0 plant: diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index e1cf3024..448a09c2 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -18,7 +18,7 @@ "empty": {}, "passes": { "conductor_size": 400, - "current_capacity": 610, + "current_capacity": 600, "rated_voltage": 33, "ac_resistance": 0.06, "inductance": 0.375, @@ -26,6 +26,7 @@ "linear_density": 35, "cost_per_km": 300000, "name": "passes", + "cable_type": "HVAC", }, } @@ -123,6 +124,16 @@ def test_power_factor(): if any((a < 0) | (a > 1) for a in results): raise Exception("Invalid Power Factor.") +def test_cable_power(): + cable = Cable(cables["passes"]) + assert cable.cable_power == pytest.approx(34.1341, abs=2e-1) + + c = copy.deepcopy(cables["passes"]) + c["cable_type"] = "HVDC" + cable = Cable(c) + print(c) + assert cable.cable_power == pytest.approx(39.6,abs=2e-1) + @pytest.mark.parametrize( "config", diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py new file mode 100644 index 00000000..513b4ee3 --- /dev/null +++ b/tests/phases/design/test_electrical_design.py @@ -0,0 +1,276 @@ +__author__ = "Jake Nunemaker" +__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" +__maintainer__ = "Jake Nunemaker" +__email__ = "Jake.Nunemaker@nrel.gov" + + +from copy import deepcopy +from itertools import product + +import pytest + +from ORBIT.core.library import extract_library_specs +from ORBIT.phases.design import ElectricalDesign + + +# OSS TESTING + +base = { + "site": {"distance_to_landfall": 50, "depth": 30}, + "landfall": {}, + "plant": {"capacity": 500}, + "export_system_design": {"cables":"XLPE_630mm_220kV"}, + "substation_design": {}, +} + + +@pytest.mark.parametrize( + "distance_to_landfall,depth,plant_cap,cable", + product(range(10,201,50), range(10, 51, 10), range(100, 2001, 500), + ["XLPE_630mm_220kV","XLPE_800mm_220kV","XLPE_1000m_220kV"] + ), +) +def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): + + config = { + "site": {"distance_to_landfall": distance_to_landfall, "depth": depth}, + "plant": {"capacity": plant_cap}, + "export_system_design": {"cables": cable}, + "substation_design": {}, + } + + o = ElectricalDesign(config) + o.run() + + # Check valid substructure length + assert 10 <= o._outputs["offshore_substation_substructure"]["length"] <= 80 + + # Check valid substructure mass + assert ( + 200 <= o._outputs["offshore_substation_substructure"]["mass"] <= 2500 + ) + + # Check valid topside mass + assert 200 <= o._outputs["offshore_substation_topside"]["mass"] <= 5000 + + # Check valid substation cost + assert 1e6 <= o.total_cost <= 1e9 + + +def test_oss_kwargs(): + + test_kwargs = { + "mpt_cost_rate": 13500, + "topside_fab_cost_rate": 17000, + "topside_design_cost": 7e6, + "shunt_cost_rate": 40000, + "switchgear_cost": 15e5, + "backup_gen_cost": 2e6, + "workspace_cost": 3e6, + "other_ancillary_cost": 4e6, + "topside_assembly_factor": 0.09, + "oss_substructure_cost_rate": 7250, + "oss_pile_cost_rate": 2500, + "num_substations": 4, + "converter_cost": 300e6 + } + + o = ElectricalDesign(base) + o.run() + base_cost = o.total_cost + + for k, v in test_kwargs.items(): + + config = deepcopy(base) + config["substation_design"] = {} + config["substation_design"][k] = v + + o = ElectricalDesign(config) + o.run() + cost = o.total_cost + + assert cost != base_cost + + +def test_hvdc_substation(): + config = deepcopy(base) + config["export_system_design"] = {"cables": "XLPE_1200m_300kV_DC"} + o = ElectricalDesign(config) + o.run() + assert o.converter_cost != 0 + assert o.shunt_reactor_cost == 0 + + +# EXPORT CABLE TESTING + + +def test_export_kwargs(): + + test_kwargs = { + "num_redundant": 2, + "touchdown_distance": 50, + "percent_added_length": 0.15, + } + + o = ElectricalDesign(base) + o.run() + base_cost = o.total_cost + + for k, v in test_kwargs.items(): + + config = deepcopy(base) + config["export_system_design"] = {"cables": "XLPE_630mm_220kV"} + config["export_system_design"][k] = v + + o = ElectricalDesign(config) + o.run() + cost = o.total_cost + + assert cost != base_cost + +config = extract_library_specs("config", "export_design") + +def test_export_system_creation(): + export = ElectricalDesign(config) + export.run() + + assert export.num_cables + assert export.length + assert export.mass + assert export.cable + assert export.total_length + assert export.total_mass + assert export.num_substations + assert export.topside_mass + assert export.substructure_mass + +def test_number_cables(): + export = ElectricalDesign(config) + export.run() + + assert export.num_cables == 11 + +def test_cable_length(): + export = ElectricalDesign(config) + export.run() + + length = (0.02 + 3 + 30) * 1.01 + assert export.length == length + +def test_cable_mass(): + export = ElectricalDesign(config) + export.run() + + length = (0.02 + 3 + 30) * 1.01 + mass = length * export.cable.linear_density + assert export.mass == pytest.approx(mass, abs=1e-10) + +def test_total_cable(): + export = ElectricalDesign(config) + export.run() + + length = 0.02 + 3 + 30 + length += length * 0.01 + mass = length * export.cable.linear_density + assert export.total_mass == pytest.approx(mass *11, abs=1e-10) + assert export.total_length == pytest.approx(length * 9, abs=1e-10) + +def test_cables_property(): + export = ElectricalDesign(config) + export.run() + + assert ( + export.sections_cables == export.cable.name + ).sum() == export.num_cables + +def test_cable_lengths_property(): + export = ElectricalDesign(config) + export.run() + + cable_name = export.cable.name + assert ( + export.cable_lengths_by_type[cable_name] == export.length + ).sum() == export.num_cables + +def test_total_cable_len_property(): + export = ElectricalDesign(config) + export.run() + + cable_name = export.cable.name + assert export.total_cable_length_by_type[cable_name] == pytest.approx( + export.total_length, abs=1e-10 + ) + +def test_design_result(): + export = ElectricalDesign(config) + export.run() + + _ = export.cable.name + cables = export.design_result["export_system"]["cable"] + + assert cables["sections"] == [export.length] + assert cables["number"] == 9 + assert cables["linear_density"] == export.cable.linear_density + + +def test_floating_length_calculations(): + + base = deepcopy(config) + base["site"]["depth"] = 250 + base["export_system_design"]["touchdown_distance"] = 0 + + sim = ElectricalDesign(base) + sim.run() + + base_length = sim.total_length + + with_cat = deepcopy(config) + with_cat["site"]["depth"] = 250 + + new = ElectricalDesign(with_cat) + new.run() + + assert new.total_length < base_length + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From ac5e9acc7409474885daf5b77f6f05ee2eb2278b Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Mon, 20 Dec 2021 10:48:45 -0700 Subject: [PATCH 019/240] remove analysis files --- atlantic_tx_base_case.ipynb | 459 -------- aubryn.ipynb | 188 ---- bycap_bydist.ipynb | 464 -------- cable_comparison.ipynb | 389 ------- define_configs.ipynb | 326 ------ gut_check_runs.ipynb | 231 ---- hvdc_comparison.ipynb | 727 ------------ oss_component_breakdown.ipynb | 450 -------- osw_project_details.xlsx | Bin 10551 -> 0 bytes param_model.ipynb | 1001 ----------------- .../Atlantic Shores Offshore Wind 1 base.yaml | 21 - .../Atlantic Shores Offshore Wind 2 base.yaml | 21 - .../Bay State Wind base.yaml | 21 - .../Beacon Wind base.yaml | 21 - .../CVOW Commercial base.yaml | 21 - .../Empire Wind 2 base.yaml | 21 - .../Empire Wind base.yaml | 21 - .../Garden State Offshore Energy base.yaml | 21 - .../Hudson North WEA base.yaml | 21 - .../Hudson South WEA base.yaml | 21 - .../Kitty Hawk base.yaml | 21 - .../Liberty Wind base.yaml | 21 - shared_transmission_configs/MarWin base.yaml | 21 - .../Mayflower Res base.yaml | 21 - .../Mayflower Wind 1 base.yaml | 21 - .../Mayflower Wind 2 base.yaml | 21 - .../Momentum Wind base.yaml | 21 - .../Ocean Wind 1 base.yaml | 21 - .../Ocean Wind 2 base.yaml | 21 - .../Ocean Wind Res base.yaml | 21 - .../Park City Wind base.yaml | 21 - .../Revolution Wind (CT) base.yaml | 21 - .../Revolution Wind (RI) base.yaml | 21 - .../Skipjack base.yaml | 21 - .../South Fork base.yaml | 21 - .../Sunrise Wind base.yaml | 21 - .../TBD SC Lease base.yaml | 21 - shared_transmission_configs/Untitled.ipynb | 694 ------------ .../Vineyard Wind South base.yaml | 21 - .../Vineyard Wind base.yaml | 21 - shared_transmission_configs/nan base.yaml | 21 - test_HVDC.ipynb | 235 ---- 42 files changed, 5794 deletions(-) delete mode 100644 atlantic_tx_base_case.ipynb delete mode 100644 aubryn.ipynb delete mode 100644 bycap_bydist.ipynb delete mode 100644 cable_comparison.ipynb delete mode 100644 define_configs.ipynb delete mode 100644 gut_check_runs.ipynb delete mode 100644 hvdc_comparison.ipynb delete mode 100644 oss_component_breakdown.ipynb delete mode 100644 osw_project_details.xlsx delete mode 100644 param_model.ipynb delete mode 100644 shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml delete mode 100644 shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml delete mode 100644 shared_transmission_configs/Bay State Wind base.yaml delete mode 100644 shared_transmission_configs/Beacon Wind base.yaml delete mode 100644 shared_transmission_configs/CVOW Commercial base.yaml delete mode 100644 shared_transmission_configs/Empire Wind 2 base.yaml delete mode 100644 shared_transmission_configs/Empire Wind base.yaml delete mode 100644 shared_transmission_configs/Garden State Offshore Energy base.yaml delete mode 100644 shared_transmission_configs/Hudson North WEA base.yaml delete mode 100644 shared_transmission_configs/Hudson South WEA base.yaml delete mode 100644 shared_transmission_configs/Kitty Hawk base.yaml delete mode 100644 shared_transmission_configs/Liberty Wind base.yaml delete mode 100644 shared_transmission_configs/MarWin base.yaml delete mode 100644 shared_transmission_configs/Mayflower Res base.yaml delete mode 100644 shared_transmission_configs/Mayflower Wind 1 base.yaml delete mode 100644 shared_transmission_configs/Mayflower Wind 2 base.yaml delete mode 100644 shared_transmission_configs/Momentum Wind base.yaml delete mode 100644 shared_transmission_configs/Ocean Wind 1 base.yaml delete mode 100644 shared_transmission_configs/Ocean Wind 2 base.yaml delete mode 100644 shared_transmission_configs/Ocean Wind Res base.yaml delete mode 100644 shared_transmission_configs/Park City Wind base.yaml delete mode 100644 shared_transmission_configs/Revolution Wind (CT) base.yaml delete mode 100644 shared_transmission_configs/Revolution Wind (RI) base.yaml delete mode 100644 shared_transmission_configs/Skipjack base.yaml delete mode 100644 shared_transmission_configs/South Fork base.yaml delete mode 100644 shared_transmission_configs/Sunrise Wind base.yaml delete mode 100644 shared_transmission_configs/TBD SC Lease base.yaml delete mode 100644 shared_transmission_configs/Untitled.ipynb delete mode 100644 shared_transmission_configs/Vineyard Wind South base.yaml delete mode 100644 shared_transmission_configs/Vineyard Wind base.yaml delete mode 100644 shared_transmission_configs/nan base.yaml delete mode 100644 test_HVDC.ipynb diff --git a/atlantic_tx_base_case.ipynb b/atlantic_tx_base_case.ipynb deleted file mode 100644 index d488615e..00000000 --- a/atlantic_tx_base_case.ipynb +++ /dev/null @@ -1,459 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "0439fc41-2ead-4ff6-b959-3155b776a2fd", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "38aa8c32-937e-41c8-ab52-f58bd9649eb9", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - " 'distance_to_landfall': 60\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10,\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': 'XLPE_500mm_220kV',\n", - " }\n", - " \n", - "}" - ] - }, - { - "cell_type": "markdown", - "id": "7f7a9a85-4da3-4077-a1ad-a5ea448c08d1", - "metadata": {}, - "source": [ - "## Low Cap" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "96b81f59-4f64-4f6f-ac65-78f3e2de1725", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - "# 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "e6db2414-3a88-45f3-920f-74d87891724e", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "456ea826-43c6-437c-a0a1-ff9c0809f38c", - "metadata": { - "tags": [] - }, - "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", - "
plant.capacitycable_costoss_cost
010041908300.03.894692e+07
120041908300.04.620032e+07
230083816600.06.972274e+07
340083816600.07.697614e+07
4500125724900.01.004986e+08
5600125724900.01.077520e+08
6700125724900.01.150054e+08
7800167633200.01.385278e+08
8900167633200.01.612057e+08
91000209541500.01.847281e+08
101100209541500.01.907726e+08
111200209541500.01.998393e+08
121300251449800.02.227573e+08
131400251449800.02.300107e+08
141500293358100.02.547420e+08
151600293358100.02.589732e+08
161700293358100.02.828600e+08
171800335266400.03.069869e+08
181900335266400.03.118225e+08
192000377174700.03.395760e+08
\n", - "
" - ], - "text/plain": [ - " plant.capacity cable_cost oss_cost\n", - "0 100 41908300.0 3.894692e+07\n", - "1 200 41908300.0 4.620032e+07\n", - "2 300 83816600.0 6.972274e+07\n", - "3 400 83816600.0 7.697614e+07\n", - "4 500 125724900.0 1.004986e+08\n", - "5 600 125724900.0 1.077520e+08\n", - "6 700 125724900.0 1.150054e+08\n", - "7 800 167633200.0 1.385278e+08\n", - "8 900 167633200.0 1.612057e+08\n", - "9 1000 209541500.0 1.847281e+08\n", - "10 1100 209541500.0 1.907726e+08\n", - "11 1200 209541500.0 1.998393e+08\n", - "12 1300 251449800.0 2.227573e+08\n", - "13 1400 251449800.0 2.300107e+08\n", - "14 1500 293358100.0 2.547420e+08\n", - "15 1600 293358100.0 2.589732e+08\n", - "16 1700 293358100.0 2.828600e+08\n", - "17 1800 335266400.0 3.069869e+08\n", - "18 1900 335266400.0 3.118225e+08\n", - "19 2000 377174700.0 3.395760e+08" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "parametric_low = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric_low.run()\n", - "parametric_low.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "795c19de-6ef9-474e-9760-2f82d9cd9efc", - "metadata": {}, - "outputs": [], - "source": [ - "model_low = parametric_low.create_model([\"plant.capacity\"],'oss_cost')" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "9c0261f6-2ddc-4112-8626-ac9e1f895fef", - "metadata": {}, - "outputs": [], - "source": [ - "# model.perc_diff" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "c17f27b8-b759-470b-b32a-848bec83add6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(model_low.predict(parameters))\n", - "plt.plot(parametric_low.results.oss_cost)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a69666b1-700f-4a80-a32a-0ecb46a9e9ab", - "metadata": {}, - "source": [ - "## Med Cap" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f7bbca3c-a54d-4ac8-8c54-159a6a08e580", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - "# 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(900,1700,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "18160b8a-dc10-4077-9923-a401da5b43db", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "27e83fbc-4bca-441c-894e-10be33a4e6bb", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "parametric_med = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric_med.run()\n", - "# parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "76a3f864-8294-4df1-979a-86f3e330c62c", - "metadata": {}, - "outputs": [], - "source": [ - "model_med = parametric_med.create_model([\"plant.capacity\"],'oss_cost')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "f2f9dfd2-0584-4d97-a261-c5ad024903ad", - "metadata": {}, - "outputs": [], - "source": [ - "# model1.predict(parameters)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "afce23f8-2eac-4184-a275-4dacf4541d18", - "metadata": {}, - "outputs": [], - "source": [ - "# model1.perc_diff" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "c71303b7-d2d2-459c-a783-1c486aaf2e6d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGsCAYAAAAPJKchAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABT/ElEQVR4nO3deVxU9eLG8c8Mu7IoKiqI4o6KIriUmWVllqVp5pJYanX73brgktXtWt3Mbkn7LdO8t25pi6hpbplptriVZoqouO+44c4OA8yc3x9jmqUlCnOAed6vF6+GmXNmnkFlnr7f7znHYhiGgYiIiIhJrGYHEBEREfemMiIiIiKmUhkRERERU6mMiIiIiKlURkRERMRUKiMiIiJiKpURERERMZXKiIiIiJhKZURERERMpTIiIiIipqpQZWTFihX06tWL0NBQLBYL8+bNK/FzLFmyhGuvvZaAgABq1arFPffcw/79+0s9q4iIiFyeClVGcnNziY6OZtKkSVe0/759++jduzc333wzKSkpLFmyhJMnT9K3b99STioiIiKXy1JRL5RnsViYO3cuffr0OXefzWbjmWeeYfr06WRkZBAVFcUrr7xC165dAZg9ezaDBg3CZrNhtTp72BdffEHv3r2x2Wx4eXmZ8E5ERETcW4UaGfkzCQkJrF69mhkzZrBp0yb69+/P7bffzq5duwBo164dVquVKVOmYLfbyczM5JNPPqFbt24qIiIiIiapNCMjaWlpNGrUiLS0NEJDQ89t161bNzp27Mj48eMBWL58OQMGDODUqVPY7XY6derEokWLqFatmgnvQkRERCrNyMjmzZux2+00a9YMf3//c1/Lly9nz549AKSnp/Pwww8zdOhQfv75Z5YvX463tzf9+vWjgnYyERGRCs/T7AClJScnBw8PD9avX4+Hh8cFj/n7+wMwadIkgoKCePXVV8899umnnxIeHs5PP/3Etdde69LMIiIiUonKSExMDHa7nePHj9OlS5eLbpOXl3du4eovfikuDoejzDOKiIjI71WoaZqcnBxSUlJISUkBnIfqpqSkkJaWRrNmzRg8eDBDhgxhzpw57Nu3j7Vr15KYmMiXX34JwJ133snPP//MCy+8wK5du0hOTuaBBx6gQYMGxMTEmPjORERE3FeFWsC6bNkybrrppt/dP3ToUKZOnUpRUREvvvgiH3/8MYcPH6ZmzZpce+21jBs3jtatWwMwY8YMXn31VXbu3EmVKlXo1KkTr7zyCpGRka5+OyIiIkIFKyMiIiJS+VSoaRoRERGpfFRGRERExFQV4mgah8PBkSNHCAgIwGKxmB1HRERELoNhGGRnZxMaGvq7o1l/rUKUkSNHjhAeHm52DBEREbkCBw8epF69epd8vEKUkYCAAMD5ZgIDA01OIyIiIpcjKyuL8PDwc5/jl1IhysgvUzOBgYEqIyIiIhXMny2x0AJWERERMZXKiIiIiJhKZURERERMpTIiIiIiplIZEREREVOpjIiIiIipVEZERETEVCojIiIiYiqVERERETGVyoiIiIiYSmVERERETKUyIiIiIqZSGREREXFjP+09xf0f/EReYbFpGVRGRERE3JDdYfDOt7sY9P4aVu46ybvf7zEti6dprywiIiKmOJFt47GZKazafRKAe2Lr8bebGpuWR2VERETEjfy4+yQjZ6ZwItuGn5cH/+oTRb929UzNpDIiIiLiBuwOg7e/3cU73+3CMKBZbX8mxcXStHaA2dFURkRERCq7Y1kFjJyxgTV7TwNwb4dwxvZqhZ+3h8nJnFRGREREKrEVO0/w2MwUTuUWUtXbg/F9W9O7bZjZsS6gMiIiIlIJFdsdvLl0J+8ucx4l06JuIJPiYmhUy9/kZL+nMiIiIlLJHM3MZ8T0Dfy8/wwAg6+pzz97tsTXq3xMy/yWyoiIiEgl8v3244z+LIUzeUX4+3jy8j2t6dkm1OxYf0hlREREpBIosjt4fckO/rtiLwCtw4KYGBdDgxpVTU7251RGREREKrhDZ/IYPn0DG9IyABh2XQRj7ojEx7N8Tsv8lsqIiIhIBfb1lnSenL2JzPwiAn09ebVfNLdH1TE7VomojIiIiFRAhcUOEr/axpQf9gMQHV6NiYNiCA+uYm6wK6AyIiIiUsGkncojYXoymw5lAvBwl4Y8eVsk3p4V8/q3KiMiIiIVyKLNR3lq9iaybcVUq+LF6/2i6dayttmxrorKiIiISAVQUGTnpS+38cmaAwC0a1CdCYNiCKvmZ3Kyq6cyIiIiUs7tO5lLQlIyW45kAfDIjY15vHszvDwq5rTMb6mMiIiIlGMLNh5hzOebyC20E1zVmzcHRNO1eYjZsUqVyoiIiEg5VFBkZ9wXW5m+Ng2Ajg2DmXBvDHWCfE1OVvpURkRERMqZ3cdzSEhKZnt6NhYLJNzUhJG3NMWzkkzL/JbKiIiISDkyJ/kQz85LJa/QTk1/H94a2Jbrm9Y0O1aZUhkREREpB/IKi3lu/hZmrz8EwHWNa/DWvW0JCah80zK/pTIiIiJisp3Hsomflsyu4zlYLTDylmYk3NwED6vF7GguoTIiIiJiEsMwmLXuEM8tSKWgyEFIgA9v3xtDp8Y1zI7mUiojIiIiJsi1FfPM3M3MSzkCQJemNfn3wLbU9PcxOZnrqYyIiIi42NYjWSQkJbP3ZC4eVgujb23Gozc2xuom0zK/pTIiIiLiIoZhkLQ2jXFfbKWw2EGdQF/eiYuhQ0Sw2dFMVaIDlhMTE+nQoQMBAQGEhITQp08fduzY8af7ZWRkEB8fT926dfHx8aFZs2YsWrToikOLiIhUNNkFRQyfvoFn5qZSWOzg5sgQFo3s4vZFBEo4MrJ8+XLi4+Pp0KEDxcXFPP3003Tv3p2tW7dStWrVi+5TWFjIrbfeSkhICLNnzyYsLIwDBw5QrVq10sgvIiJS7qUeziQ+KZkDp/LwtFr4++3N+cv1jdx2Wua3SlRGFi9efMH3U6dOJSQkhPXr13PDDTdcdJ8PP/yQ06dP8+OPP+Ll5QVARETElaUVERGpQAzD4OPVB3jpy20U2h2EVfPjnbgYYutXNztauXJV55XNzMwEIDj40kNMCxYsoFOnTsTHx1O7dm2ioqIYP348drv9kvvYbDaysrIu+BIREalIMvOLePTTZMYu2EKh3cGtLWuzaEQXFZGLuOIFrA6Hg1GjRtG5c2eioqIuud3evXv57rvvGDx4MIsWLWL37t387W9/o6ioiLFjx150n8TERMaNG3el0UREREyVcjCDhKRkDp3Jx8vDwpgeLXigcwQWi6ZlLsZiGIZxJTs++uijfPXVV6xatYp69epdcrtmzZpRUFDAvn378PDwAODNN9/ktdde4+jRoxfdx2azYbPZzn2flZVFeHg4mZmZBAYGXklcERGRMmcYBh+s2scri7dTZDcID/Zj4qBYosOrmR3NFFlZWQQFBf3p5/cVjYwkJCSwcOFCVqxY8YdFBKBu3bp4eXmdKyIALVq0ID09ncLCQry9vX+3j4+PDz4+7nfSFxERqbgy8gp5YtZGvtl2HIA7Wtfh5XvaEOjrZXKyi8jPgGNbIH2z8+vYZuj5FoTFmhKnRGXEMAyGDx/O3LlzWbZsGQ0bNvzTfTp37kxSUhIOhwOr1blEZefOndStW/eiRURERKSiWX/gNMOTNnAkswBvDyv/7NmC+65tYP60jGFARtqvSkcqpG9y3vdbRzdWjDISHx9PUlIS8+fPJyAggPT0dACCgoLw8/MDYMiQIYSFhZGYmAg4p3MmTpzIyJEjGT58OLt27WL8+PGMGDGilN+KiIiIazkcBu+t3MtrS3ZgdxhE1KjCxLhYosKCXB+m2AbHt/2qdGyG9FSwZV58+6BwqNMaakc5/xt+jWvz/kqJysjkyZMB6Nq16wX3T5kyhWHDhgGQlpZ2bgQEIDw8nCVLlvDYY4/Rpk0bwsLCGDlyJE899dTVJRcRETHRqRwbj8/ayLIdJwC4KzqU8X1b4+/jgpOb555yjnCcKx2b4eROcBT/flurF4REQu3WztJRpzXUbgVVys/J1q54AasrXe4CGBEREVdYu+80w6cncyzLho+nlefvasW9HcJLf1rG4YDTe51rOn4pHempkH3k4tv7VT870tHmbPGIgprNwdOcZRFluoBVRETEHTkcBu8u282bS3fiMKBxrapMGhxLZJ1S+B/lwjw4vtU54pF+dsTj2BYoyr349tUbni0cbZylo05rCAwDs9epXAGVERERkctwItvG6M9SWLnrJAB9Y8P4V+8oqpZ0WsYwIOfYr0Y6zn6d3gOG4/fbe/pCSMvzUyx1Wju/9608MwUqIyIiIn/ix90nGTkzhRPZNvy8PHihdyv6tw//8x3txXBq19mRjk3nF5fmnrj49lVr/Wqk4+xUS3Bj8KjcH9eV+92JiIhcBbvDYMK3u5jw3S4MA5rV9mdSXCxNawf8fuOCrF+du+Ps4tJjW8Fu+/22FivUaHp+eqVOa+cC04DaZf+myiGVERERkYs4nlXAiBkbWLP3NAAD24fz/F2t8POyQsbBC08Ylr4Zzuy/+BN5+zuPXvl16QhpAd5VXPdmyjmVERERkd9YsfMEj81MISs3j1jvozzTzk47n1WQdLZ4FGRcfMfAsF+VjrOjHtUbgvWqrktb6amMiIiIAOSdxn50M8tXfMeZvev5xJJGU9/DeFEMG36zrdUTakVeWDrqtC5X5+6oSFRGRETEfRXmweKnYPd3kHUID+BmAI9fbeMb5FxM+uvSUas5eOoaaqVFZURERNyTvQhmDYVdX5+764AjhF2WCOq17EhkdGfnAtOg8Ap57o6KRGVERETcj8MB8+Nh19cUWX1IKHiUHx1RNAirw8RBsUTUrGp2QreiMiIiIu7FMGDJ07BpJnas/F/BCL53xDDsugjG3BGJj6fHnz+HlCqVERERcS8rX4efnBd+fbzwEdZ5d+A//dpwe1Rdk4O5L5URERFxG8U/fYDndy8CMK7ofvaF3smiuFjCg3XODzOpjIiIiFs4+dNnBH/1OADvFPfBo9PfmHV7JN6eOgeI2VRGRESk0lv77RzarnwUKwazuJUWg16hW6s6ZseSs1RGRESk0ioosjN11hzu25GAt6WYH32u57q/TiUs2N/saPIrKiMiIlIp7T+ZS+In80nMeBJ/SwH7AtvTIX42Xj5+ZkeT31AZERGRSmfBxiNMmPM9H/FPgi05ZAW3puFf54GKSLmkMiIiIpVGQZGdcV9s5au1W5jl/RJh1lMUV29C4EPzwSfA7HhyCSojIiJSKew+nkNCUjJp6SdI8n6VptbDGIGheA6dB1VrmB1P/oDKiIiIVHhzkg/x7LxUigsL+NjvLdoae8CvOpb750G1cLPjyZ9QGRERkQorr7CYsfO3MGv9Iaw4mFbtA64t2AReVWHwbOfVdaXcUxkREZEKaeexbOKnJbPreA5Wi8G8BvNok74CrF4w8BOo197siHKZVEZERKRCMQyDWesP8dz8VAqKHNQK8GFOi2WEb5oNWKDve9DkFrNjSgmojIiISIWRayvm2XmpzN1wGIAuTWsyuek6/L97x7nBna9DVF8TE8qVUBkREZEKYdvRLOKTktl7IherBR7v3pxHg5Oxzn3auUHXp6HDX8wNKVdEZURERMo1wzBIWpvGuC+2UljsoE6gLxMGxdCxeD1Mf9S5Ucf/gxv/bm5QuWIqIyIiUm5lFxQxZs5mFm46CsBNzWvxxoC2BJ9OgWn3g6MYovrB7a+AxWJuWLliKiMiIlIupR7OJCEpmf2n8vC0WnjytuY83KUR1pPbYVp/KM6HJt2gz2SwWs2OK1dBZURERMoVwzD4ePUBXvpyG4V2B2HV/JgwKIZ2DarDmQPwyd1QkAH1OsKAj8HT2+zIcpVURkREpNzIzC/iH59v4qvUdAC6tajN6/3bUK2KN+SccBaR7KNQqwXEzQTvqiYnltKgMiIiIuXCxoMZJExP5uDpfLw8LIzp0YIHOkdgsVigIAs+7Qun90BQfbh/DlQJNjuylBKVERERMZVhGHz4w35e/mobRXaD8GA/Jg6KJTq8mnODogKYEQfpm6BKTbh/LgSGmppZSpfKiIiImCYjr5AnZm3im23HAOgRVYeX72lDkJ+XcwN7MXz+EOxfCd4BcN/nULOJiYmlLKiMiIiIKdYfOMOI6Rs4nJGPt4eVZ3u24P5rGzinZQAMAxaOgu0LwcMbBiVBaFszI0sZURkRERGXcjgM3lu5l9eW7MDuMIioUYWJcbFEhQVduOG342DDJ2CxQr8PoeEN5gSWMqcyIiIiLnM6t5DRn6WwbMcJAHpFhzL+7igCfL0u3PDHd2DVv523e74FLXq5Nqi4lMqIiIi4xNp9pxkxfQPpWQX4eFoZ26sVgzqGn5+W+UVKEnz9rPN2t+eh3VCXZxXXUhkREZEy5XAYvLtsN28u3YnDgEa1qjIpLpYWdQN/v/GOr2B+gvN2pwToPMqlWcUcKiMiIlJmTmTbGP1ZCit3nQSgb0wY/+oTRVWfi3z87P8BZg0Dww7RcdD9RV1vxk2ojIiISJn4cc9JRs5I4US2DV8vKy/0jqJ/u3q/n5YBOLoJpt8LxQXQrAfc9Y6KiBtRGRERkVJldxi8890uJny7C4cBTUP8mTQ4lma1Ay6+w+m98Ok9YMuC+tdB/yngoY8nd6I/bRERKTXHswoYOSOF1XtPATCgfT3G3RWFn7fHxXfIToeP+0DucajdGgZNBy8/1wWWckFlRERESsXKXSd4bGYKJ3MKqeLtwYt9ougbW+/SO+RnOEdEMg5A9YbOs6v6VXNVXClHVEZEROSqFNsdvPXNLiYt241hQGSdACbGxdIkxP/SOxXmOdeIHEsF/9rO680E1HZdaClXVEZEROSKHc3MZ+T0FNbuPw1A3DX1ea5nS3y9LjEtA2AvgtkPQNpq8AmC++ZAcEMXJZbyyFqSjRMTE+nQoQMBAQGEhITQp08fduzYcdn7z5gxA4vFQp8+fUqaU0REypnvtx/njrdXsnb/afx9PJkwKIbxd7f+4yLicDjPI7JzMXj6QtwMqBPlutBSLpWojCxfvpz4+HjWrFnD0qVLKSoqonv37uTm5v7pvvv37+eJJ56gS5cuVxxWRETMV2R3kLhoGw9M/ZkzeUW0Cg1k4fDruSs69I93NAznmVU3zQCLB/T/CBpc55rQUq6VaJpm8eLFF3w/depUQkJCWL9+PTfccOkLGNntdgYPHsy4ceNYuXIlGRkZVxRWRETMdTgjn+FJySSnZQAwtFMDxtzR4o9HQ36x6k1YM8l5u8+70Pz2sgsqFcpVrRnJzMwEIDg4+A+3e+GFFwgJCeGhhx5i5cqVf/q8NpsNm8127vusrKyriSkiIqVg6dZjPDFrI5n5RQT4evLqPW3o0bru5e28fip8+4Lz9m3jIfreMsspFc8VlxGHw8GoUaPo3LkzUVGXnu9btWoVH3zwASkpKZf93ImJiYwbN+5Ko4mISCkqLHbwyuLtfLBqHwDR9YJ4Z1As9WtUubwn2DofFj7mvH39aOgUX0ZJpaIq0ZqRX4uPjyc1NZUZM2Zccpvs7Gzuv/9+3n//fWrWrHnZzz1mzBgyMzPPfR08ePBKY4qIyFU4eDqP/v/58VwRebBzQ2Y9ct3lF5G9y+Hzv4DhgNihcMtzZZhWKqorGhlJSEhg4cKFrFixgnr1Ln1Cmz179rB//3569ep17j6Hw+F8YU9PduzYQePGjX+3n4+PDz4+PlcSTURESsni1KM8OXsT2QXFBPl58Xr/aG5tWYJzgRxOhhlxYC+EFr2g5791vRm5qBKVEcMwGD58OHPnzmXZsmU0bPjHx4VHRkayefPmC+579tlnyc7O5u233yY8PLzkiUVEpEwVFNlJXLSNj1YfACCmfjXeGRRDveqXORoCcHIXTOsHhTnQ8Aa45wOwXsYiV3FLJSoj8fHxJCUlMX/+fAICAkhPTwcgKCgIPz/ntQSGDBlCWFgYiYmJ+Pr6/m49SbVq1QD+cJ2JiIiYY//JXOKTktlyxHngwF9vbMQT3Zvj5VGCWf3Mw/DJ3ZB3Cuq2hXuTwFOj3XJpJSojkydPBqBr164X3D9lyhSGDRsGQFpaGlbrFS9FERERk3yx8Qhj5mwmx1ZM9SpevDmgLTdFhpTsSfJOw6d9IfMg1GjivN6MzyWu1itylsUwDMPsEH8mKyuLoKAgMjMzCQwMNDuOiEilUlBk54WFW0n6KQ2ADhHVmTAohrpBJbx6ri0HPu4Nh9dBQCg8tASq1S+DxFJRXO7nt65NIyLixvacyCF+WjLb07OxWCC+axNGdWuKZ0mmZQCKC+Gz+51FxK+688J3KiJymVRGRETc1NwNh3hmbip5hXZqVPXmrXvb0qVprZI/kcMB8x6BPd+BVxWImwUhkaUfWCotlRERETeTX2jnufmpzFp/CIBOjWrw1r1tqR3oW/InMwz46u+Q+jlYvWDgJxDeoZQTS2WnMiIi4kZ2Hssmfloyu47nYLHAiJubMuKWpnhYr/D8H8tfgZ/fByxw93+gSbdSzSvuQWVERMQNGIbBrPWHeG5+KgVFDmoF+PD2wLZc1+Tyz479Oz+9B8sSnbfveA1a9yudsOJ2VEZERCq5XFsx/5yXypwNhwHo0rQmbw5oS62Aqzj3x+bZzukZgK5joOPDpZBU3JXKiIhIJbbtaBbxScnsPZGL1QKjb23G37o2wXql0zIAu7+BuX8FDOj4f3DjU6WWV9yTyoiISCVkGAbT1x5k3BdbsBU7qBPoy4RBMXRsGHx1T3zwZ5h5PziKIeoeuP0VXW9GrprKiIhIJZNdUMTTc1P5YuMRALo2r8WbA9oSXNX76p74+DZI6g9FedD4FujzH9AZt6UUqIyIiFQiqYczSUhKZv+pPDysFv5+W3Me7tLo6qZlADLS4JO+kH8Gwto7D+H1vMpyI3KWyoiISCVgGAafrDnAiwu3UWh3EBrkyztxsbRrUP3qnzz3pPPCd9lHoFYkDJ4F3lWv/nlFzlIZERGp4DLzixgzZxOLNjuvpN6tRW1e79+GalVKYeTClg2f3gOndkNQONw3B6pc5boTkd9QGRERqcA2HswgYXoyB0/n4+Vh4anbI3no+oZYSmNRaVEBzIiDoylQpQbcPw+Cwq7+eUV+Q2VERKQCMgyDD3/Yz8tfbaPIblCvuh8T42JpG16tdF7AYYc5f4F9K8DbH+77HGo2KZ3nFvkNlRERkQomI6+QJ2Zt4pttxwC4vVUdXunXhiA/r9J5AcOAhaNg2xfg4Q33JkFoTOk8t8hFqIyIiFQg6w+cYcT0DRzOyMfbw8ozd7ZgSKcGpTMt84tvX4Dkj8FihXs+gEY3lt5zi1yEyoiISAXgcBi8v3Ivry3ZQbHDoEGNKkyKiyUqLKh0X2j1JFj1pvN2z39Dy7tK9/lFLkJlRESknDudW8jjn6Xw/Y4TAPRsU5fEvq0J8C2laZlfpEyHJU87b9/yHLQbVrrPL3IJKiMiIuXY2n2nGTF9A+lZBXh7Wnm+VysGdQwv3WkZgB1fwfx45+1r4+H60aX7/CJ/QGVERKQccjgMJi/fw5tLd2J3GDSqWZVJg2NpUTew9F/swI8waxgYdmhzL3R/UdebEZdSGRERKWdO5th4bGYKK3edBODumDBe7BNFVZ9S/pWdewp2fAlLnoXiAmh2O/SeqOvNiMupjIiIlCOr95xi5IwNHM+24etl5YW7oujfvl7pTctkHobtC52H7R74AQyH8/76naD/VPAo5XUoIpdBZUREpBywOwze+W4XE77dhcOApiH+TBocS7PaAVf/5Cd3w/YvnAXk8PoLH6vTGlr0hmsfAS+/q38tkSugMiIiYrLj2QWMmpHCj3tOAdC/XT3G9W5FFe8r/BVtGJC+CbadHQE5se1XD1og/Bpo0Qta9ITqEVedX+RqqYyIiJho1a6TjJq5gZM5hVTx9uDFPlH0ja1X8idyOODQWmf52LYAMtLOP2b1hIY3OAtI8zshoHbpvQGRUqAyIiJigmK7g7e+2cWkZbsxDIisE8DEuFiahPiX4EkKYf9KZwHZ/iXkHj//mKcfNLnFWUCa3QZ+1Uv/TYiUEpUREREXS88sYMT0DazdfxqAQR3rM7ZXS3y9PP5858I82POts4DsWAy2zPOP+QRB89shsqeziHhXLaN3IFK6VEZERFzo+x3HefyzjZzOLaSqtweJ97ThrujQP94pPwN2LnFOv+z+Forzzz9WtRZE3ukcAYm4ATy9yzS/SFlQGRERcYEiu4PXv97Bf5fvBaBVaCAT42JpWPMSoxfZx5znANn2BexbAY7i849Vqw+RvZwFJLwjWC9jREWkHFMZEREpY4cz8hkxfQPrD5wBYEinBjx9R4vfT8uc2e88Amb7QkhbAxjnH6sVefYImF5Qp43OkCqVisqIiEgZ+mbrMR6ftZHM/CICfDx5pV8b7mhd1/mgYcCJHeePgEnfdOHOobHnC0jNpq4PL+IiKiMiImWgsNjBq4u3879V+wBoUy+IiYNiqR/s5zzx2LazJyE7tfv8ThYrNOjsLB+Rd0LQFRziK1IBqYyIiJSyg6fzSJi+gY0HMwB46Lpw/tEyA6+fnndOwWQdPr+xhzc0uunsOUB6QNWapmQWMZPKiIhIKVqcepQnZ2/CVpDPnb7bGBOxi3rbl0HyqfMbeVWFZt2dBaTJreBbBlfiFalAVEZEREqBrdjO6wvWcWTdQsZ7rOUWv41UMfJh/9kN/Ko7z37aoqdzJMTL18y4IuWKyoiIyNXIO83JdXPZs3IGTxRuwMe7yHm/AQSEOstHZE/nWhAP/coVuRj9yxARKanMw87Tr2//Asf+H6hp2KkJYIE8/wZUie4DLe5yHg1jtZocVqT8UxkREbkcp/acPwLm8Lpzd1uBLY4GpAZ24ea7H6JWoxidA0SkhFRGREQuxjAgfbPz6JdtX8DxrecfwsJWj0jmFsTytaM9vbpex2PdmuHpoVEQkSuhMiIi8guHAw797DwB2bYvIOPA+cesnhDRhRT/LoxICSWtIJAaVb3598C23NCslnmZRSoBlRERcW/2Iti/0lk+tn8JOcfOP+bpC026QYte5EfcyvNLDzNz7UEArm0UzIR7YwgJ1FExIldLZURE3FfWUfikD5zYfv4+n0BodvvZc4DcAt5V2XUsm/gPk9l5LAeLBUbc3JQRtzTFw6q1ISKlQWVERNxTdjp81NN5Ona/6tCyt7OARNwAnt7nNpu17iDPzd9CfpGdWgE+vD2wLdc10VlSRUqTyoiIuJ/sYzD1bBEJCodhX0L1Bhdskmsr5p/zU5mT7Dx1+/VNavLvgW2pFeBjRmKRSk1lRETcS85x+KgXnNoFgfVg2MLfFZHt6VnET0tmz4lcrBYYfWsz/ta1CVZNy4iUCZUREXEfOSecReTkDggMO1tEIs49bBgGM34+yPMLtmArdlA70IcJ98ZwTaMa5mUWcQMlOig+MTGRDh06EBAQQEhICH369GHHjh1/uM/7779Ply5dqF69OtWrV6dbt26sXbv2qkKLiJRY7klnETmx3Xma9mELIbjhuYdzbMWMnJHCmDmbsRU7uLFZLRaN6KIiIuICJSojy5cvJz4+njVr1rB06VKKioro3r07ubm5l9xn2bJlDBo0iO+//57Vq1cTHh5O9+7dOXz48CX3EREpVbkn4aO74MQ2CKh7tog0Ovdw6uFMek5YyYKNR/CwWvhHj0imDOtADX+tDxFxBYthGMaV7nzixAlCQkJYvnw5N9xww2XtY7fbqV69OhMnTmTIkCGXtU9WVhZBQUFkZmYSGKhLbYtICeSego/vgmOp4F/HuVi1ZhPAOS3z6ZoD/OvLbRQWOwgN8uWduBjaNQg2ObRI5XC5n99XtWYkMzMTgODgy/+Hm5eXR1FR0R/uY7PZsNls577Pysq68pAi4r7yTsMnvc8WkdrOEZGzRSSroIh/fL6JRZvTAejWIoTX+0dTrYr3Hz2jiJSBKy4jDoeDUaNG0blzZ6Kioi57v6eeeorQ0FC6det2yW0SExMZN27clUYTEXEWkY97O68vUzUEhi6Emk0B2HQog/ikZA6ezsfLw8JTt0fy0PUNsegCdyKmuOJpmkcffZSvvvqKVatWUa9evcva5+WXX+bVV19l2bJltGnT5pLbXWxkJDw8XNM0InJ58s84i8jRjVC1lnNqplZzDMNgyg/7SfxqG0V2g3rV/ZgYF0vb8GpmJxaplMp0miYhIYGFCxeyYsWKyy4ir7/+Oi+//DLffPPNHxYRAB8fH3x8tHBMRK5AfgZ83MdZRKrUdI6I1GpOZl4RT87eyNdbndeeub1VHV7p14YgPy9T44pICcuIYRgMHz6cuXPnsmzZMho2bPjnOwGvvvoqL730EkuWLKF9+/ZXFFRE5E/lZ8And8PRFKhSA4Z+ASGRJKedYXjSBg5n5OPtYeWZO1swpFMDTcuIlBMlKiPx8fEkJSUxf/58AgICSE93LvwKCgrCz88PgCFDhhAWFkZiYiIAr7zyCs899xxJSUlERESc28ff3x9/f//SfC8i4s4KMuHTvnAkGfyCYegXOGq14H8r9vDq4h0UOwwa1KjCxEGxtK4XZHZaEfmVEq0ZudT/RUyZMoVhw4YB0LVrVyIiIpg6dSoAERERHDhw4Hf7jB07lueff/6yXleH9orIHyrIchaRQz+fLSILOBPQnMdnbeS77ccBuLNNXV7u25oAX03LiLhKmawZuZzesmzZsgu+379/f0leQkSkZGzZ8Ok9Z4tIdRgyn58LwhgxZSVHMwvw9rQytldL4jrW17SMSDmla9OISMVly4ZP+8GhteBbDcd985i8vQpvLl2D3WHQqGZVJsbF0jJUI6oi5ZnKiIhUTLYcmNYfDq4B3yDO9JvFiMU2Vu5yXmqiT9tQXry7Nf4++jUnUt7pX6mIVDyFuZA0ANJWg08Qm27+iL/MzOJ4tg1fLysv3BVF//b1NC0jUkGojIhIxVKYC0kD4cAPGD6BzIycwNNz83AY0CTEn3cHx9KsdoDZKUWkBFRGRKTiKMxzFpH9K3F4BzA28F988pPz6Jj+7eoxrncrqnjr15pIRaN/tSJSMRTmwXRnESn29Ocv9qdZdrAWfl4evHR3FH1jL+9s0CJS/qiMiEj5V5QPMwbBvhUUWqswKO8J1jsaEFkngIlxsTQJ0QkURSoylRERKd+KCmBGHOxdRoHFl8H5T7LeaMagjuGM7dUKXy8PsxOKyFVSGRGR8quoAGYOhj3fkYcvQwv+znavlrzdtzW924aZnU5ESonKiIiUT8U2HDMHY939DXmGD8MKnyS3TkcWDo6lYc2qZqcTkVKkMiIi5U+xjYJpcfju+4Z8w5sHi56k+TW388ydLTQtI1IJqYyISPlSbOPEBwOpdfR78g1vEvgHQwbFcUfrumYnE5EyojIiIuVGoa2AfZP70TxjJQWGFy8FjWXs0AepX6OK2dFEpAypjIhIuXDwRCaH3x/ItYWrKTC8mNXsdf458H58PDUtI1LZqYyIiOmWbDqIx5wH6cZabHix5Yb/cP8t/cyOJSIuYjU7gIi4L1uxnRfmb8Q+y1lEivAkq/dU2qmIiLgVlRERMcWBU7kMeHcVseue5A6PtRRbvLDcO41aMT3NjiYiLqZpGhFxuYWbjvDM5ym86Hibnh4/4bB64XnvNGh2m9nRRMQEKiMi4jIFRXb+tXArM37ax5tek+nlsQbD6oV14CcqIiJuTGVERFxi74kc4pM2sONoBm94/YfeHj9iWL2wDPgYmvcwO56ImEhlRETK3LwNh3l67mYKCouY4PcePY0fwOqJpf9UiLzD7HgiYjKVEREpM/mFdp5fsIWZ6w5ixcGU6lO5MX8FWDyg3xRoocWqIqIyIiJlZPfxbOKnbWDHsWysFgcLwmcQdfybs0XkQ2h5l9kRRaScUBkRkVI3e/0h/jkvlfwiO7WqerEw4jNq71l4toh8AK36mB1RRMoRlRERKTW5tmL+OT+VOcmHAbi+cXXeD/4Uv82zwGKFe96HVnebnFJEyhuVEREpFdvTs4iflsyeE7lYLfDYLU2Iz3sXa/I0ZxHp+z5E3WN2TBEph1RGROSqGIbBzJ8PMnbBFmzFDmoH+vD2wLZcu+0lSJ7qLCJ3/xda6xTvInJxKiMicsVybMU8PWczCzYeAeDGZrV4s38baqx4BtZ9CFigz2RoM8DcoCJSrqmMiMgV2XIkk4SkDew7mYuH1cIT3Zvz1y4NsS55Cn7+H84i8i5E32t2VBEp51RGRKREDMPg05/S+NfCrRQWO6gb5Ms7g2Jo36A6LB4Da98DLNB7ErSNMzuuiFQAKiMictmyCooY8/lmvtx8FIBbIkN4vX801at4wZKn4afJzg3vegdiBpuYVEQqEpUREbksmw5lkJC0gbTTeXhaLfyjRyQPXd8QC8DXz8Kad50b9poAsfebGVVEKhiVERH5Q4ZhMPXH/YxftI0iu0FYNT8mxsUQU786GAYs/SesnujcuOdb0G6oqXlFpOJRGRGRS8rMK+LJ2Rv5eusxALq3rM1r/aIJquLlLCLfPA8/vuPc+M43of0D5oUVkQpLZURELmpD2hkSkjZwOCMfbw8rT98RydDrIrBYLM4i8u0L8MNbzo3veB06PGRqXhGpuFRGROQCDofBB6v28cri7RQ7DOoHV2FSXCyt6wU5NzAM+O5FWPWm8/ser0HHh80LLCIVnsqIiJxzJreQx2dt5LvtxwG4s3VdEu9pTaCv1/mNliXCytedt29/Ba75PxOSikhlojIiIgCs23+a4dM3cDSzAG9PK8/1bMnga+o7p2V+sexlWP6K8/Zt4+HaR8wJKyKVisqIiJtzOAz+s2IPb3y9E7vDoGHNqkyMi6FVaNCFGy57xTkqAtD9JegU7/qwIlIpqYyIuLGTOTYe/2wjy3eeAKB321Beurs1/j6/+dWw4jVYNt55+9Z/wXUJLk4qIpWZyoiIm1qz9xQjpm/geLYNH08rL/RuxYD24RdOywCsfMO5YBWg2zjoPML1YUWkUlMZEXEzdofBxO928/a3O3EY0CTEn4lxMUTWCfz9xqv+7TyEF+CWsXD9KJdmFRH3oDIi4kaOZxfw2MwUfth9CoB7Yuvxrz6tqOJ9kV8FP7ztPKkZwM3PQpfRrgsqIm5FZUTETfyw+yQjZ6RwMseGn5cH/+oTRb929S6+8Y/vwNLnnLdvegZueNJ1QUXE7aiMiFRyxXYHE77dxTvf78YwoHntACYNjqFJSMDFd1g9yXnhO4CuY+DGv7surIi4JWtJNk5MTKRDhw4EBAQQEhJCnz592LFjx5/uN2vWLCIjI/H19aV169YsWrToigOLyOU7llVA3P9+YsJ3ziJyb4dw5sV3vnQRWfMfWPK08/aNT0HXf7gurIi4rRKVkeXLlxMfH8+aNWtYunQpRUVFdO/endzc3Evu8+OPPzJo0CAeeughNmzYQJ8+fejTpw+pqalXHV5ELm3ZjuP0eHsla/edpqq3B2/f25aX72mDn7fHxXf46T1Y/JTz9g1POkdFRERcwGIYhnGlO584cYKQkBCWL1/ODTfccNFtBg4cSG5uLgsXLjx337XXXkvbtm35z3/+c1mvk5WVRVBQEJmZmQQGXmTFv4icU2x38MbSnUxetgeAFnUDmRQXQ6Na/pfeae37sOgJ5+3rR8Mtz8FvD/EVESmhy/38vqo1I5mZmQAEBwdfcpvVq1czevSFq/Bvu+025s2bd8l9bDYbNpvt3PdZWVlXE1PEbRzJyGfE9A2sO3AGgPuurc+zd7bE1+sSoyEAP//vfBHpPEpFRERc7orLiMPhYNSoUXTu3JmoqKhLbpeenk7t2rUvuK927dqkp6dfcp/ExETGjRt3pdFE3NK3247x+KyNZOQVEeDjSeI9renZJvTiGxcXwo5FsH4q7P3eed91I6Db8yoiIuJyV1xG4uPjSU1NZdWqVaWZB4AxY8ZcMJqSlZVFeHh4qb+OSGVQWOzgtSXbeX/lPgBahwUxMS6GBjWq/n7jU3sg+WNImQa5J87eaXGezOyWsSoiImKKKyojCQkJLFy4kBUrVlCv3iXOU3BWnTp1OHbs2AX3HTt2jDp16lxyHx8fH3x8fK4kmohbOXg6j+HTN5ByMAOAYddFMOaOSHw8fzUtU1wI2xc6R0H2LT9/v38diL0fYu6H6g1cmltE5NdKVEYMw2D48OHMnTuXZcuW0bBhwz/dp1OnTnz77beMGjXq3H1Lly6lU6dOJQ4rIuct2ZLOk7M2klVQTKCvJ6/1j+a2Vr8q+af2QPJHsGEa5J08e6cFmnSDdsOg2W3g4WVGdBGRC5SojMTHx5OUlMT8+fMJCAg4t+4jKCgIPz8/AIYMGUJYWBiJic5LjY8cOZIbb7yRN954gzvvvJMZM2awbt063nvvvVJ+KyLuwVZsJ3HRdqb+uB+AtuHVeGdQDOHBVaDY9qtRkBXndwqo6xwBib0fqtU3JbeIyKWUqIxMnjwZgK5du15w/5QpUxg2bBgAaWlpWK3nT19y3XXXkZSUxLPPPsvTTz9N06ZNmTdv3h8uehWRiztwKpeEpA1sPuw8ku3hLg158rZIvDP2wtdTISUJ8k6d3doCTW+Fdg9A0+7goRMui0j5dFXnGXEVnWdEBL7cdJR/fL6JbFsx1ap48WbfFtxs/OQcBdm/8vyGAaHn14JU08JvETGPS84zIiJlr6DIzotfbuXTNWkA3BWWy/gG6/H/8q+Qf9q5kcXqHP1oNwya3KpREBGpUPQbS6Qc23sih/ikDew9epK7rOt4osaP1D+VDL/MxASEQuwQiLlPoyAiUmGpjIiUU/NTDvP+nMX0dXxDP9+VVCcbsjk7CnLb2VGQbhoFEZEKT7/FRMqZ/Lxc5idNpmHaLBZat5+/nGVg2NlRkPshKMzUjCIipUllRKS8OLGDjFXvY900g3uNbLCCAys0uw1r+wecoyDWP7jGjIhIBaUyImKmonzYusB5REzaj1Q7e3c6NbG1uY8Gt/yfRkFEpNJTGRExw/HtzgKycToUZABQbFj5zhFDSkgfhg15iAZBF7m2jIhIJaQyIuIqRfmwdT6smwIH15y7+5ilFp8UduVzx40M6nYtj9/UBA+rLlgnIu5DZUSkrB3f9qtREOeZUw2LB4dDbmTckQ58W9SamgF+TBgUw7WNapibVUTEBCojImWhMA+2znOWkIM/nb8/qD626Pt48XAsn2wpBOCGZrV4c0A0Nf11pWoRcU8qIyKl6dgWWP8RbJpxbhQEiwdE3gHthrHFN5bhMzax92QuHlYLj3dvxiM3NMaqaRkRcWMqIyJXqzAPtsx1joIcWnv+/mr1IXYoxNyH4V+bT39K418Lf6Kw2EHdIF8mDIqhQ0SwabFFRMoLlRGRK5We6iwgmz4D29lREKsnNHeOgtDoJrBaySooYsz0DXy56SgAN0eG8Eb/aKpX9TYtuohIeaIyIlIShbnOUZB1U+DwuvP3V2sA7YZC2/sgoPa5uzcfyiQ+KZm003l4Wi08dXskD13fUNMyIiK/ojIicjnSN/9qFCTLeZ/VEyLvdI6CNOwKVuu5zQ3D4KMf9zN+0XYK7Q7CqvnxTlwMsfWrmxBeRKR8UxkRuRRbDmyZ4ywhh9efv796hLOAtB0M/iG/2y0zr4i/f76RJVuOAdC9ZW1e6xdNUBUvl8QWEaloVEZEfuvopvOjIIXZzvusnhDZ8+woyI0XjIL82oa0MwyfvoFDZ/Lx8rDw9B0tGHZdBBaLpmVERC5FZUQEnKMgqZ87S8iR5PP3V294dhQk7qKjIL8wDIMPVu3j5a+2U+wwqB9chYlxMbSpV62sk4uIVHgqI+K+im1w6GfYPBs2z4LCHOf9Vi9ocXYUJOKGS46C/OJMbiFPzNrIt9uPA3BH6zq8fE8bAn01LSMicjlURsR9OBxwfCvsXQZ7v4cDP0JR3vnHgxs5C0h0HPjXuqynXH/gNMOTNnAkswBvTyv/7NmS+66pr2kZEZESUBmRyi3j4NnysQz2LYfcExc+XqUmNLnFuRg1osufjoL8wuEw+O+Kvbz+9Q7sDoOGNasyMS6GVqFBpf4WREQqO5URqVzyz8C+lecLyOk9Fz7uVQUadIZGXZ1fIS0vu4D84lSOjdGfbWT5TmexuSs6lPF9W+Pvo39OIiJXQr89pWIrtjkvRPdL+TiyAQzH+cctVghr5zwbaqOuUK8DeF75mU9/2nuKETM2cCzLho+nlXF3tWJgh3BNy4iIXAWVEalYHA44tvl8+TiwGorzL9ymZrPzIx8R14Pv1U+d2B0G736/m39/sxOHAY1rVWXS4Fgi6wRe9XOLiLg7lREp/84cOL/odN8KyDt14eP+tc+Xj4Y3QlBYqb78iWwbo2Zu4IfdztftGxvGv3pHUVXTMiIipUK/TaX8yTvtLB2/jH6c2Xfh497+zhGPXwpIrUgoo2mSH3afZOSMFE7m2PDz8uCF3q3o3z68TF5LRMRdqYyI+YoKIG31+fJxdCNgnH/c4uFc6/FL+ajXHjzK9hwedofB29/u4p3vdmEY0Ky2P5PiYmlaO6BMX1dExB2pjIjrOeyQvul8+UhbA8UFF25Tq8X58tHgOvB13dqMY1kFjJyxgTV7TwMwsH04z9/VCj9vD5dlEBFxJyojUvYMwznVcu58Hyuch+D+WkDds+XjJmh4AwTWNSEoLN95gtEzUziVW0gVbw/G392aPjGluwZFREQupDIiZSP3FOxbdr6AZKRd+Lh3ADTscn70o2azMlv3cTmK7Q7eXLqTd5c5z0vSom4gk+JiaFTL37RMIiLuQmVESkdh3oXrPtI3Xfi41QvCO54vH6Gx4FE+/vodzcxnxPQN/LzfOVoz+Jr6/LNnS3y9NC0jIuIK5ePTQCoehx2OpDgPt927zHniMXvhhduEtILGZ082Vr8T+JS/UYbvth/j8c82ciavCH8fT16+pzU924SaHUtExK2ojMjlMQw4vfd8+di3AgoyL9wmMOz8mU4b3gABtc1IelmK7A5eW7KD91bsBSAqLJBJcbE0qFHV5GQiIu5HZUQuLeeE8+Jye7+Hvcsh8+CFj/sE/Wrdx01Qo7Gp6z4u16EzeSQkbSDlYAYAw66LYMwdkfh4alpGRMQMKiNyXmGu8/Tqv4x+HEu98HEPbwi/BhrdCI1uhrrR5Wbdx+VasiWdJ2dtJKugmABfT17r14bbo8w5ckdERJwq1ieJlL70VNjx1fl1H46iCx+v0/r8otP6ncC7Yk5jFBY7SPxqG1N+2A9AdHg1Jg6KITy4irnBREREZcStJX8CCxIuvC+oPjTuev46L1VrmpGsVKWdyiNhejKbDjnXuPzl+ob8/fZIvD2tJicTERFQGXFfm2bBguHO241vgcg7nUe+VG9YIdZ9XK5Fm4/y1OxNZNuKCfLz4o3+0XRrWX4X1oqIuCOVEXe0dT7M/StgQPsH4c43K1UBASgosvPSl9v4ZM0BANo1qM6EQTGEVfMzOZmIiPyWyoi72bEYZj8Ihh3aDoY73qh0RWTfyVzipyWz9WgWAI/c2JjHuzfDy0PTMiIi5ZHKiDvZ8x18dj84iiGqH9z1Dlgr1wf0/JTDPD1nM7mFdoKrevPmgGi6Ng8xO5aIiPwBlRF3sX8VTI9zniU1sifc/R+wVp7zahQU2Rn3xRamr3WeC6Vjw2Am3BtDnSBfk5OJiMifURlxBwfXwrQBUJwPTbtDvyng4WV2qlKz+3gOCUnJbE/PxmKBhJuaMPKWpnhqWkZEpEJQGansjmyAT++Bolzn4boDPgFPb7NTlZrP1x/i2Xmp5BfZqenvzVsDY7i+acU/HFlExJ2ojFRm6anwyd1gy4L618G9SeBVOaYt8gqLeW7+FmavPwTAdY1r8NbAtoQEVo73JyLiTlRGKqsTO+Dj3pB/BsLaw+DPKuzZU39r57Fs4qcls+t4DlYLjLylGQk3N8HDWrmOChIRcRclnlRfsWIFvXr1IjQ0FIvFwrx58/50n2nTphEdHU2VKlWoW7cuDz74IKdOnbqSvHI5Tu2Bj+6CvJPO68fc9zn4BJid6qoZhsHMn9O4a+Iqdh3PISTAh2l/uZaR3ZqqiIiIVGAlLiO5ublER0czadKky9r+hx9+YMiQITz00ENs2bKFWbNmsXbtWh5++OESh5XLkJHmHBHJSYeQlnD/PPCrZnaqq5ZjK+axmSk89flmCoocdGlak0Uju9CpcQ2zo4mIyFUq8TRNjx496NGjx2Vvv3r1aiIiIhgxYgQADRs25K9//SuvvPJKSV9a/kzWEfioF2QehBpNYch8qBJsdqqrtvVIFglJyew9mYuH1cLoW5vx6I2NsWo0RESkUijzYx87derEwYMHWbRoEYZhcOzYMWbPns0dd9xxyX1sNhtZWVkXfMmfyDnunJo5sx+qR8DQBeBfsU/2ZRgG0346QJ93f2DvyVzqBPoy4/+uJf6mJioiIiKVSJmXkc6dOzNt2jQGDhyIt7c3derUISgo6A+neRITEwkKCjr3FR4eXtYxK7bcU86pmVO7ICgchn4BgaFmp7oq2QVFJEzfwDNzUyksdnBzZAiLRnahQ0TFH+kREZELlXkZ2bp1KyNHjuS5555j/fr1LF68mP379/PII49ccp8xY8aQmZl57uvgwYNlHbPiys+AT/rA8a3gX8c5NVOtvtmprkrq4Ux6vrOKLzcdxdNq4ek7IvnfkPYEV60850cREZHzyvzQ3sTERDp37syTTz4JQJs2bahatSpdunThxRdfpG7dur/bx8fHBx8fn7KOVvHZsp0nNEvfBFVqOqdmajQ2O9UVMwyDj1cf4KUvt1FodxBWzY934mKIrV/d7GgiIlKGyryM5OXl4el54ct4eDiviWIYRlm/fOVVmOs8xfvhdeBX3TkiUqu52amuWGZ+EU/N3sTiLekA3NqyNq/1a0O1KhoNERGp7EpcRnJycti9e/e57/ft20dKSgrBwcHUr1+fMWPGcPjwYT7++GMAevXqxcMPP8zkyZO57bbbOHr0KKNGjaJjx46EhlbsdQ2mKSqAGXGQ9iP4BMH9c6FOlNmprljKwQwSkpI5dCYfLw8LY3q04IHOEVgsWqQqIuIOSlxG1q1bx0033XTu+9GjRwMwdOhQpk6dytGjR0lLSzv3+LBhw8jOzmbixIk8/vjjVKtWjZtvvlmH9l6p4kL47H7Yuwy8qsJ9syE0xuxUV8QwDD5YtY9XFm+nyG4QHuzHxEGxRIdXMzuaiIi4kMWoAHMlWVlZBAUFkZmZSWBgoNlxzGMvglnDYPtC8PRzFpGI681OdUUy8gp5YtZGvtl2HIA7Wtfh5XvaEOhbea4mLCLi7i7381vXpqkoHHaY+1dnEfHwgUFJFbaIrD9wmuFJGziSWYC3h5V/9mzBfdc20LSMiIibUhmpCBwOWDAcUj8HqycM+Bga32x2qhJzOAzeW7mX15bswO4wiKhRhYlxsUSFBZkdTURETKQyUt4ZBix6HFKmgcUD+n0IzW83O1WJncqx8fisjSzbcQKAu6JDGd+3Nf4++isoIuLu9ElQnhkGLHka1n0IWODu/0LL3manKrGf9p5ixIwNHMuy4eNp5fm7WnFvh3BNy4iICKAyUn4ZBnz7Aqx51/n9Xe9Am/7mZiohh8Pg3WW7eXPpThwGNKpVlUlxsbSo68aLkEVE5HdURsqrFa/Bqjedt+94HWLvNzdPCZ3ItjH6sxRW7joJQN+YMP7VJ4qqmpYREZHf0CdDefTD2/D9S87b3V+Cjg+bm6eEftx9kpEzUziRbcPPy4MXereif3td7FBERC5OZaS8+em/sPQ55+2b/wnXJZibpwTsDoMJ3+5iwne7MAxoVtufSXGxNK0dYHY0EREpx1RGypP1U+Grvztv3/Ak3PCEqXFK4nhWASNmbGDN3tMADGwfzvN3tcLP28PkZCIiUt6pjJQXG2fAF6OctzslwE3PmBqnJFbsPMFjM1M4lVtIFW8Pxt/dmj4xYWbHEhGRCkJlpDxInQPzHgUM6PAwdH8RKsBhr8V2B//+ZifvLtuDYUBknQAmDY6lcS1/s6OJiEgFojJitu1fwpyHwXBAzP3Q49UKUUSOZuYzcnoKa/c7p2UGX1Off/Zsia+XpmVERKRkVEbMtOsb54XvHMXQegD0ehusVrNT/anvtx9n9GcpnMkrwt/Hk8S+rekVHWp2LBERqaBURsyydznMHAz2QudZVftMBmv5HlUosjt4fckO/rtiLwBRYYFMHBRLRM2qJicTEZGKTGXEDGlrYPq9UFwAzXpA3/+BR/n+ozh0Jo/h0zewIS0DgGHXRTDmjkh8PMt3gRIRkfKvfH8CVkaH18On/aAoz3nl3f5TwdPb7FR/6Ost6Tw5exOZ+UUE+HryWr823B5V1+xYIiJSSaiMuNLRTfBJXyjMhoguMHAaePmaneqSCosdvPzVdj78YR8A0fWCmBgXS3hwFZOTiYhIZaIy4irHt8EnfaAgA+p1hEEzwLv8fqgfPJ1HQlIyGw9lAvCX6xvy99sj8fYs/wtsRUSkYlEZcYVTe+Dj3pB3CkJj4L7Z4FN+z8Xx1eaj/P3zTWQXFBPk58Ub/aPp1rK22bFERKSSUhkpa2f2w0e9IOcY1I6C++aAb5DZqS6qoMjO+EXb+Hj1AQBi61fjnbhYwqr5mZxMREQqM5WRspR5CD66C7IOQ83mcP88qBJsdqqL2n8yl/ikZLYcyQLgrzc24onuzfHy0LSMiIiULZWRspKd7iwiGQcguBEMmQ/+tcxOdVELNh7h6TmbybEVE1zVmzcGRHNT8xCzY4mIiJtQGSkLuSeda0RO74Gg+jBkAQSWv0NhC4rsjPtiK9PXpgHQMSKYCYNiqBNUfo/wERGRykdlpLTlnXYeNXNiOwSEwtAFUC3c7FS/s/t4DglJyWxPz8ZigYSbmjDylqZ4alpGRERcTGWkNBVkwqf3QPpmqBriLCLBDc1O9Ttzkg/x7LxU8grt1PT35t8D29KlafmcQhIRkcpPZaS02HJg2gA4kgx+wc41IjWbmp3qAnmFxYydv4VZ6w8B0KlRDd6+ty0hgZqWERER86iMlIaifOe1Zg6ucR62O2Qe1G5pdqoL7DyWTfy0ZHYdz8FqgZG3NCPh5iZ4WC1mRxMRETenMnK1im0w8z7YvxK8A5znEakbbXaqcwzDYNb6Qzw3P5WCIge1AnyYcG8MnRrXMDuaiIgIoDJydexFMOsB2P0NeFWBwZ9BvfZmpzon11bMs/NSmbvhMABdmtbk3wPbUtPfx+RkIiIi56mMXCl7Mcx5GHZ8CR4+MGg6NLjO7FTnbDuaRXxSMntP5GK1wOPdm/PojY2xalpGRETKGZWRK+FwwPx42DIXrF5w7zRo1NXsVIBzWmb62oM8/8UWCosd1An0ZcKgGDo2LJ9nfhUREVEZKSnDgIWjYNMMsHhA/ynQ9FazUwGQXVDE03NT+WLjEQBual6LNwa0Jbiqt8nJRERELk1lpCQMA756CpI/AosV7nkfWvQyOxUAqYczSUhKZv+pPDytFv5+e3P+cn0jTcuIiEi5pzJyuQwDvhkLa//r/L73JIi6x9xMOKdlPllzgBcXbqPQ7iCsmh8TBsXQrkF1s6OJiIhcFpWRy7XsZfjhbeftnv+GtnHm5gEy84v4x+eb+Co1HYBuLWrzev82VKuiaRkREak4VEYux8o3YfnLztu3vwztHzQ3D7DxYAYJ05M5eDofLw8LY3q04IHOEVgsmpYREZGKRWXkz6x+F74d57zd7Xm49lFT4xiGwYc/7Oflr7ZRZDcID/Zj4qBYosOrmZpLRETkSqmM/JGfP4AlY5y3b/wHXP+YqXEy8gp5YtYmvtl2DIAeUXV4+Z42BPl5mZpLRETkaqiMXMqGafDlaOftziOh6z9MjbP+wBlGTN/A4Yx8vD2sPNuzBfdf20DTMiIiUuGpjFzM5tmwIMF5+5pHoNs4MOlD3+EweH/lXl5bsoNih0FEjSpMjIslKizIlDwiIiKlTWXkt7Z9AXP+DwwHtBvmXLBqUhE5nVvI45+l8P2OEwD0ig5l/N1RBPhqWkZERCoPlZFf2/m188J3hh2iB8Gd/zatiKzdd5oR0zeQnlWAj6eV5+9qxb0dwjUtIyIilY7KyC/2fA8z7wNHEbTqC3dNBKvV5TEcDoPJy/fw5tKd2B0GjWpVZVJcLC3qBro8i4iIiCuojAAc+BGmDwK7DSJ7Qt/3wMP1P5qTOTYem5nCyl0nAegbE8a/+kRR1Ud/TCIiUnnpU+7gzzCtPxTnQ5Nu0O9D8HD9mowf95xk5IwUTmTb8PWy8kLvKPq3q6dpGRERqfTcu4wcSYFP74HCHGh4Awz8FDx9XBrB7jB457tdTPh2Fw4Dmob48+7gWJrWDnBpDhEREbOUeFHEihUr6NWrF6GhoVgsFubNm/en+9hsNp555hkaNGiAj48PERERfPjhh1eSt/Q4HDD3EbBlQv1OMGgGePm5NMLxrALu+99PvPWNs4gMaF+PBQnXq4iIiIhbKfHISG5uLtHR0Tz44IP07dv3svYZMGAAx44d44MPPqBJkyYcPXoUh8NR4rClymqFgZ/AN89Dn8ngXdWlL79y1wkem5nCyZxCqnh78NLdUdwdU8+lGURERMqDEpeRHj160KNHj8vefvHixSxfvpy9e/cSHBwMQERERElftmzUbAr3TnPpSxbbHbz1zS4mLduNYUBknQAmxsXSJMTfpTlERETKizI/dnXBggW0b9+eV199lbCwMJo1a8YTTzxBfn7+Jfex2WxkZWVd8FUZHM3MJ+79n5j4vbOIxF1Tn3nxnVVERETErZX5Ata9e/eyatUqfH19mTt3LidPnuRvf/sbp06dYsqUKRfdJzExkXHjxpV1NJf6fsdxRs9M4UxeEf4+niT2bU2v6FCzY4mIiJjOYhiGccU7WyzMnTuXPn36XHKb7t27s3LlStLT0wkKcl5PZc6cOfTr14/c3Fz8/H6/aNRms2Gz2c59n5WVRXh4OJmZmQQGVqyTfxXZHbz+9Q7+u3wvAFFhgUwcFEtETdeuUREREXG1rKwsgoKC/vTzu8xHRurWrUtYWNi5IgLQokULDMPg0KFDNG3a9Hf7+Pj44OPj2kNsy8LhjHyGJyWTnJYBwNBODXj6zhb4eHqYG0xERKQcKfM1I507d+bIkSPk5OScu2/nzp1YrVbq1au8R48s3XqMO95eSXJaBgG+nkweHMu43lEqIiIiIr9R4jKSk5NDSkoKKSkpAOzbt4+UlBTS0tIAGDNmDEOGDDm3fVxcHDVq1OCBBx5g69atrFixgieffJIHH3zwolM0FV1hsYN/LdzKwx+vIzO/iOh6QSwa0YUereuaHU1ERKRcKvE0zbp167jpppvOfT969GgAhg4dytSpUzl69Oi5YgLg7+/P0qVLGT58OO3bt6dGjRoMGDCAF198sRTily8HT+eRMH0DGw9mAPDQ9Q156vZIvD1df8E9ERGRiuKqFrC6yuUugDHT4tSjPDl7E9kFxQT5efF6/2hubVnb7FgiIiKmKTcLWCs7W7Gd8V9u46PVBwCIrV+NCYNiqFe9isnJREREKgaVkauw/2QuCdOTST3sPCnbX29sxBPdm+PloWkZERGRy6UycoW+2HiEMXM2k2MrpnoVL94c0JabIkPMjiUiIlLhqIyUUEGRnRcWbiXpJ+ci3Y4Rwbw9qC11gyrfkUEiIiKuoDJSAntO5BA/LZnt6dlYLBDftQmjujXFU9MyIiIiV0xl5DLN3XCIZ+amkldop6a/N/8e2JYuTWuZHUtERKTCUxn5E/mFdsYuSOWzdYcA6NSoBm/f25aQQF+Tk4mIiFQOKiN/YNexbOKTktl5LAeLBUbe0pThNzfFw2oxO5qIiEiloTJyEYZhMGv9IZ6bn0pBkYNaAT68fW9brmtc0+xoIiIilY7KyG/k2or557xU5mw4DECXpjV5c0BbagVU/KsIi4iIlEcqI7+y7WgWCUnJ7DmRi9UCj3dvzqM3NsaqaRkREZEyozKCc1pm+tqDjPtiC7ZiB3UCfZkwKIaODYPNjiYiIlLpuX0ZyS4o4um5qXyx8QgAXZvX4s0BbQmu6m1yMhEREffg1mUk9XAmCUnJ7D+Vh4fVwt9va87DXRppWkZERMSF3LaMOBwGT8zayP5TeYRV82PCoBjaNahudiwRERG347bnMbdaLfx7YFvubF2XL0dcryIiIiJiErcdGQFoUTeQSYNjzY4hIiLi1tx2ZERERETKB5URERERMZXKiIiIiJhKZURERERMpTIiIiIiplIZEREREVOpjIiIiIipVEZERETEVCojIiIiYiqVERERETGVyoiIiIiYSmVERERETKUyIiIiIqaqEFftNQwDgKysLJOTiIiIyOX65XP7l8/xS6kQZSQ7OxuA8PBwk5OIiIhISWVnZxMUFHTJxy3Gn9WVcsDhcHDkyBECAgKwWCyl9rxZWVmEh4dz8OBBAgMDS+15KxJ3/xm4+/sH/Qz0/t37/YN+BmX5/g3DIDs7m9DQUKzWS68MqRAjI1arlXr16pXZ8wcGBrrlX8Bfc/efgbu/f9DPQO/fvd8/6GdQVu//j0ZEfqEFrCIiImIqlRERERExlVuXER8fH8aOHYuPj4/ZUUzj7j8Dd3//oJ+B3r97v3/Qz6A8vP8KsYBVREREKi+3HhkRERER86mMiIiIiKlURkRERMRUKiMiIiJiKrcuI5MmTSIiIgJfX1+uueYa1q5da3Ykl1mxYgW9evUiNDQUi8XCvHnzzI7kUomJiXTo0IGAgABCQkLo06cPO3bsMDuWy0yePJk2bdqcO8lRp06d+Oqrr8yOZZqXX34Zi8XCqFGjzI7iMs8//zwWi+WCr8jISLNjudThw4e57777qFGjBn5+frRu3Zp169aZHctlIiIifvd3wGKxEB8f7/IsbltGZs6cyejRoxk7dizJyclER0dz2223cfz4cbOjuURubi7R0dFMmjTJ7CimWL58OfHx8axZs4alS5dSVFRE9+7dyc3NNTuaS9SrV4+XX36Z9evXs27dOm6++WZ69+7Nli1bzI7mcj///DP//e9/adOmjdlRXK5Vq1YcPXr03NeqVavMjuQyZ86coXPnznh5efHVV1+xdetW3njjDapXr252NJf5+eefL/jzX7p0KQD9+/d3fRjDTXXs2NGIj48/973dbjdCQ0ONxMREE1OZAzDmzp1rdgxTHT9+3ACM5cuXmx3FNNWrVzf+97//mR3DpbKzs42mTZsaS5cuNW688UZj5MiRZkdymbFjxxrR0dFmxzDNU089ZVx//fVmxyhXRo4caTRu3NhwOBwuf223HBkpLCxk/fr1dOvW7dx9VquVbt26sXr1ahOTiVkyMzMBCA4ONjmJ69ntdmbMmEFubi6dOnUyO45LxcfHc+edd17wu8Cd7Nq1i9DQUBo1asTgwYNJS0szO5LLLFiwgPbt29O/f39CQkKIiYnh/fffNzuWaQoLC/n000958MEHS/WCtJfLLcvIyZMnsdvt1K5d+4L7a9euTXp6ukmpxCwOh4NRo0bRuXNnoqKizI7jMps3b8bf3x8fHx8eeeQR5s6dS8uWLc2O5TIzZswgOTmZxMREs6OY4pprrmHq1KksXryYyZMns2/fPrp06UJ2drbZ0Vxi7969TJ48maZNm7JkyRIeffRRRowYwUcffWR2NFPMmzePjIwMhg0bZsrrV4ir9oqUpfj4eFJTU91qvhygefPmpKSkkJmZyezZsxk6dCjLly93i0Jy8OBBRo4cydKlS/H19TU7jil69Ohx7nabNm245ppraNCgAZ999hkPPfSQiclcw+Fw0L59e8aPHw9ATEwMqamp/Oc//2Ho0KEmp3O9Dz74gB49ehAaGmrK67vlyEjNmjXx8PDg2LFjF9x/7Ngx6tSpY1IqMUNCQgILFy7k+++/p169embHcSlvb2+aNGlCu3btSExMJDo6mrffftvsWC6xfv16jh8/TmxsLJ6ennh6erJ8+XImTJiAp6cndrvd7IguV61aNZo1a8bu3bvNjuISdevW/V3xbtGihVtNVf3iwIEDfPPNN/zlL38xLYNblhFvb2/atWvHt99+e+4+h8PBt99+63Zz5u7KMAwSEhKYO3cu3333HQ0bNjQ7kukcDgc2m83sGC5xyy23sHnzZlJSUs59tW/fnsGDB5OSkoKHh4fZEV0uJyeHPXv2ULduXbOjuETnzp1/dzj/zp07adCggUmJzDNlyhRCQkK48847TcvgttM0o0ePZujQobRv356OHTvy1ltvkZubywMPPGB2NJfIycm54P+A9u3bR0pKCsHBwdSvX9/EZK4RHx9PUlIS8+fPJyAg4NxaoaCgIPz8/ExOV/bGjBlDjx49qF+/PtnZ2SQlJbFs2TKWLFlidjSXCAgI+N36oKpVq1KjRg23WTf0xBNP0KtXLxo0aMCRI0cYO3YsHh4eDBo0yOxoLvHYY49x3XXXMX78eAYMGMDatWt57733eO+998yO5lIOh4MpU6YwdOhQPD1NrAQuP36nHHnnnXeM+vXrG97e3kbHjh2NNWvWmB3JZb7//nsD+N3X0KFDzY7mEhd774AxZcoUs6O5xIMPPmg0aNDA8Pb2NmrVqmXccsstxtdff212LFO526G9AwcONOrWrWt4e3sbYWFhxsCBA43du3ebHculvvjiCyMqKsrw8fExIiMjjffee8/sSC63ZMkSAzB27Nhhag6LYRiGOTVIRERExE3XjIiIiEj5oTIiIiIiplIZEREREVOpjIiIiIipVEZERETEVCojIiIiYiqVERERETGVyoiIiIiYSmVERERETKUyIiIiIqZSGRERERFTqYyIiIiIqf4fMd8uaBDCeJcAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(model_med.predict(parameters))\n", - "plt.plot(parametric_med.results.oss_cost)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f1a082a1-6d64-4b91-a394-ca759d1f32e1", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/aubryn.ipynb b/aubryn.ipynb deleted file mode 100644 index ddf43e84..00000000 --- a/aubryn.ipynb +++ /dev/null @@ -1,188 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "425e445d-d671-410e-bdbf-3d7498fc0f8f", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "992084e9-831b-4283-82a6-7243b81de8b5", - "metadata": {}, - "outputs": [], - "source": [ - "config1 = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 45},\n", - " 'plant': {'num_turbines': 4, 'capacity': 48},\n", - " 'turbine': {'turbine_rating': 12},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "386c636d-f3dd-47ec-97eb-1a652a68bea4", - "metadata": {}, - "outputs": [], - "source": [ - "config2 = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 45},\n", - " 'plant': {'num_turbines': 2, 'capacity': 24},\n", - " 'turbine': {'turbine_rating': 12},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_185mm_66kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1626e009-4c93-41dc-9fa7-6e9ffd299861", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - } - ], - "source": [ - "design1 = ElectricalDesign(config1)\n", - "design1.run()\n", - "design2 = ElectricalDesign(config2)\n", - "design2.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9c63662e-c794-4dc1-8852-92afa2a93f07", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "for 24 MW:\n", - "compensation = 10450757.32027138\n", - "transformer = 1750000\n", - "switchgear = 134000\n", - "\n", - "for 48 MW:\n", - "compensation = 750487.1946612032\n", - "transformer = 1750000\n", - "switchgear = 134000\n" - ] - } - ], - "source": [ - "print(\"for 24 MW:\")\n", - "print(\"compensation = \", design1.shunt_reactor_cost)\n", - "print(\"transformer = \", design1.mpt_cost)\n", - "print(\"switchgear = \", design1.switchgear_costs)\n", - "print(\"\")\n", - "print(\"for 48 MW:\")\n", - "print(\"compensation = \", design2.shunt_reactor_cost)\n", - "print(\"transformer = \", design2.mpt_cost)\n", - "print(\"switchgear = \", design2.switchgear_costs)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "00e698be-82d9-48d5-a8e5-7c706255c65d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/bycap_bydist.ipynb b/bycap_bydist.ipynb deleted file mode 100644 index 1619aa45..00000000 --- a/bycap_bydist.ipynb +++ /dev/null @@ -1,464 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "34256382-d968-446b-b4f5-2900571b6202", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT.phases.design import OffshoreSubstationDesign\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "id": "09623e08-fe09-46c6-8697-d80dfb455428", - "metadata": {}, - "source": [ - "## Cost Curves \n", - "#### Vary Plant Capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ab071a0f-25e7-401e-952d-7d420fde68b4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" - ] - } - ], - "source": [ - "cap = np.arange(100,2010,10)\n", - "i = 0\n", - "capex_list = [None] * len(cap)\n", - "for x in cap:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - "# 'ExportSystemDesign',\n", - "# 'OffshoreSubstationDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = ElectricalDesign(config)\n", - " design.run()\n", - "# mpt_cost[i] = design.mpt_cost\n", - "# print(x, \":\", design.num_cables)\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - "# print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - " \n", - " \n", - "\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list[i] = project.capex_breakdown\n", - " i = i + 1\n" - ] - }, - { - "cell_type": "markdown", - "id": "79968dab-bc0a-4746-8205-306942cd0348", - "metadata": {}, - "source": [ - "#### Vary Distance to Shore" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2a9b6a5b-fa16-499d-b4fb-705ac25d44f5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "topside costs = 47151750.0\n", - "topside costs = 47151750.0\n", - "topside costs = 47151750.0\n", - "topside costs = 47151750.0\n", - "topside costs = 47151750.0\n", - "topside costs = 47151750.0\n" - ] - } - ], - "source": [ - "dist = [40, 80, 100, 140, 180, 200]\n", - "i = 0\n", - "mpt_cost = [0] * len(dist)\n", - "capex_list_dist = [None] * len(dist)\n", - "for x in dist:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': x},\n", - " 'plant': {'num_turbines': 60, 'capacity': 600},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - "# 'ExportSystemDesign',\n", - "# 'OffshoreSubstationDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = ElectricalDesign(config)\n", - " design.run()\n", - " mpt_cost[i] = design.mpt_cost\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - " print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list_dist[i] = project.capex_breakdown\n", - " i = i + 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "2f8eda8b-9b2c-4b39-9912-f11507634a56", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Export System': 165624900.0,\n", - " 'Offshore Substation': 122731375.30288924,\n", - " 'Export System Installation': 116801066.62180227,\n", - " 'Offshore Substation Installation': 3098929.2998477924,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "capex_list_dist[1]" - ] - }, - { - "cell_type": "markdown", - "id": "2336fbf6-9c9b-4ec6-b55f-f63b4bb01cda", - "metadata": { - "tags": [] - }, - "source": [ - "### Extract and Plot Cable + Substation Costs \n", - "#### By Plant Cap\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3558606a-2e7c-4aef-8652-db48274450fd", - "metadata": {}, - "outputs": [], - "source": [ - "i = 0\n", - "cable_cost = [0] * len(cap)\n", - "oss_cost = [0] * len(cap)\n", - "for x in capex_list:\n", - " cable_cost[i] = x.get('Export System')\n", - " oss_cost[i] = x.get('Offshore Substation')\n", - " i = i + 1" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "362f145f-603a-4c5b-8b32-ea96d4e81f95", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, cable_cost)\n", - "plt.plot(cap, oss_cost)\n", - "plt.title(\"Cable, OSS Cost by Plant Capacity\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "225fc353-d75d-43a4-a1f3-6305c6f10745", - "metadata": {}, - "source": [ - "#### By Distance" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "73432368-74ab-4ba5-8546-67d21ee00be7", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "i = 0\n", - "cable_cost_dist = [0] * len(dist)\n", - "oss_cost_dist = [0] * len(dist)\n", - "for x in capex_list_dist:\n", - " cable_cost_dist[i] = x.get('Export System')\n", - " oss_cost_dist[i] = x.get('Offshore Substation')\n", - " i = i + 1" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f5e2a52e-eb9c-4405-974a-bd699b44fc75", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(dist, cable_cost_dist)\n", - "plt.plot(dist, oss_cost_dist)\n", - "plt.title(\"Cable, OSS Cost by Distance to Shore\")\n", - "plt.xlabel(\"DIstance to Shore (mi)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "4f606331-1524-42e2-a6c7-44e06c68607d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[85824900.0, 165624900.0, 205524900.0, 285324900.00000006, 365124900.00000006, 405024900.00000006]\n" - ] - } - ], - "source": [ - "print(cable_cost_dist)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9d6dc085-dc82-403c-bf16-989cb39e1c4b", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f5045921-95dc-4967-b462-8ae593e1a363", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/cable_comparison.ipynb b/cable_comparison.ipynb deleted file mode 100644 index 2217d784..00000000 --- a/cable_comparison.ipynb +++ /dev/null @@ -1,389 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "6672f27a-8604-4f5c-b885-028ab3425360", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 50\n", - " },\n", - " 'plant': {\n", - " 'num_turbines': 60, \n", - "# 'capacity': 600\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - "# 'export_system_design': {\n", - "# 'cables': 'XLPE_500mm_220kV',\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a1bb5c31-9881-46d8-bb20-b40ecb487ab9", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - " 'export_system_design.cables': ['XLPE_500mm_220kV', 'XLPE_630mm_220kV', 'XLPE_800mm_220kV', 'XLPE_1000m_220kV'],\n", - " 'site.distance_to_landfall': np.arange(50,550,50),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2300,300)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1627fd49-5e96-45c8-8d40-05f3b2bab6ba", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - " 'compensation': lambda run: run.cable.compensation_factor\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "514e6a20-be60-4048-9094-d49f49a69a5e", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - }, - { - "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", - "
export_system_design.cablessite.distance_to_landfallplant.capacitycable_costoss_costcompensation
0XLPE_500mm_220kV501003.525830e+073.560015e+072.345849
1XLPE_500mm_220kV504007.051660e+076.951580e+072.345849
2XLPE_500mm_220kV507001.057749e+081.034314e+082.345849
3XLPE_500mm_220kV5010001.762915e+088.312412e+072.345849
4XLPE_500mm_220kV5013002.115498e+081.000819e+082.345849
.....................
315XLPE_1000m_220kV50010001.710268e+093.890738e+083.174298
316XLPE_1000m_220kV50013002.137835e+094.839672e+083.174298
317XLPE_1000m_220kV50016002.565402e+095.794189e+083.174298
318XLPE_1000m_220kV50019002.992969e+094.540108e+083.174298
319XLPE_1000m_220kV50022002.992969e+094.605238e+083.174298
\n", - "

320 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", - "0 XLPE_500mm_220kV 50 100 \n", - "1 XLPE_500mm_220kV 50 400 \n", - "2 XLPE_500mm_220kV 50 700 \n", - "3 XLPE_500mm_220kV 50 1000 \n", - "4 XLPE_500mm_220kV 50 1300 \n", - ".. ... ... ... \n", - "315 XLPE_1000m_220kV 500 1000 \n", - "316 XLPE_1000m_220kV 500 1300 \n", - "317 XLPE_1000m_220kV 500 1600 \n", - "318 XLPE_1000m_220kV 500 1900 \n", - "319 XLPE_1000m_220kV 500 2200 \n", - "\n", - " cable_cost oss_cost compensation \n", - "0 3.525830e+07 3.560015e+07 2.345849 \n", - "1 7.051660e+07 6.951580e+07 2.345849 \n", - "2 1.057749e+08 1.034314e+08 2.345849 \n", - "3 1.762915e+08 8.312412e+07 2.345849 \n", - "4 2.115498e+08 1.000819e+08 2.345849 \n", - ".. ... ... ... \n", - "315 1.710268e+09 3.890738e+08 3.174298 \n", - "316 2.137835e+09 4.839672e+08 3.174298 \n", - "317 2.565402e+09 5.794189e+08 3.174298 \n", - "318 2.992969e+09 4.540108e+08 3.174298 \n", - "319 2.992969e+09 4.605238e+08 3.174298 \n", - "\n", - "[320 rows x 6 columns]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "parametric = ParametricManager(base_config, parameters, results, module=ElectricalDesign, product=True)\n", - "parametric.run()\n", - "parametric.results\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0f9311f2-9b72-4c71-b8e1-5ffc448bdaf8", - "metadata": {}, - "outputs": [], - "source": [ - "# plt.plot(parametric.results.cable_cost)\n", - "# plt.show()\n", - "# index = results.index" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGsCAYAAAAhYYazAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADqdElEQVR4nOz9eXycd3nvD7/v2UfbaN9377sdSIIdQgIJSdhKztPDYTtP6Gnh1/IkLS2npU2hpwdO25yWUsIPUiilJaUU0oYlFAqhCSEJkBDI4sSO7XiTLVubbe3LzNzr88f3vmdGtmRppFkk+Xq/XnpZ0nxndGkk6/7MdX2u69Icx3EQBEEQBEFYI/iKHYAgCIIgCEIuEXEjCIIgCMKaQsSNIAiCIAhrChE3giAIgiCsKUTcCIIgCIKwphBxIwiCIAjCmkLEjSAIgiAIawoRN4IgCIIgrClE3AiCIAiCsKYQcSMIgiAIwpriihY3Tz75JG9729tobm5G0zQeeuihrB/j3/7t39i9ezclJSV0dHTwyU9+MveBCoIgCIKwaK5ocTM9Pc2uXbu47777lnT/H/zgB7z3ve/lt37rtzh48CB/+7d/y6c//Wk+97nP5ThSQRAEQRAWiyaLMxWapvHtb3+b22+/PfW5ZDLJRz/6Ub7+9a8zNjbG9u3b+cu//EtuvPFGAN7znvdgGAYPPvhg6j6f/exn+au/+it6e3vRNK3A34UgCIIgCFd05mYh7rrrLp5++mkeeOABXnrpJd7xjndw2223cezYMUCJn0gkMus+0WiUs2fPcvr06WKELAiCIAhXPCJu5qG3t5cvf/nLPPjgg1x//fWsW7eO3//93+e1r30tX/7ylwG49dZb+da3vsWPfvQjbNvm6NGjfOpTnwJgYGCgmOELgiAIwhVLoNgBrFQOHDiAZVls3Lhx1ueTySQ1NTUAfOADH+DEiRO89a1vxTAMKioq+NCHPsT//t//G59PdKMgCIIgFAMRN/MwNTWF3+/nueeew+/3z7qtrKwMUD6dv/zLv+Qv/uIvGBwcpK6ujh/96EcAdHd3FzxmQRAEQRBE3MzLnj17sCyLc+fOcf3111/2rN/vp6WlBYCvf/3r7N27l7q6ukKEKQiCIAjCRVzR4mZqaorjx4+nPu7p6WH//v1UV1ezceNG3vve93LHHXfwqU99ij179nD+/Hl+9KMfsXPnTt7ylrdw4cIFvvGNb3DjjTeSSCRSHp0nnniiiN+VIAiCIFzZXNGt4I8//jivf/3rL/n8+973Pu6//34Mw+DP/uzP+MpXvkJfXx+1tbW85jWv4eMf/zg7duzgwoULvO1tb+PAgQM4jsPevXv58z//c6699toifDeCIAiCIMAVLm4EQRAEQVh7SEuPIAiCIAhrChE3giAIgiCsKa44Q7Ft2/T391NeXi7rEQRBEARhleA4DpOTkzQ3Ny84S+6KEzf9/f20tbUVOwxBEARBEJbAmTNnaG1tveyZK07clJeXA+rJqaioKHI0giAIgiAshomJCdra2lLX8ctxxYkbrxRVUVEh4kYQBEEQVhmLsZSIoVgQBEEQhDWFiBtBEARBENYUIm4EQRAEQVhTiLgRBEEQBGFNIeJGEARBEIQ1hYgbQRAEQRDWFCJuBEEQBEFYU4i4EQRBEARhTSHiRhAEQRCENYWIG0EQBEEQ1hQibgRBEARBWFOIuBEEQRAEYU0h4kYQBEEQhNxw/hX43ofh518oahgibgRBEARByA0XjsKz/wAHv1nUMETcCIIgCIKQG2ZG1L8lNUUNQ8SNIAiCIAi5YWZY/VtSXdQwRNwIgiAIgpAb4m7mJlpV1DBE3AiCIAiCkBtmRtW/UpYSBEEQBGFNIGUpQRAEQRDWFKmylIgbQRAEQRDWAtItJQiCIAjCWsKRspQgCIIgCGsG22K/M8O+9lZ+Z/+9RQ1FxI0gCIIgCMsnMU5vwM+k38eMYxY1FBE3giAIgiAsn5kRzgQCALRVtBc1FBE3giAIgiAsn/gIZ4JK3LSXi7gRBEEQBGG1MzOcztyUtxU1FBE3giAIgiAsn5l05kbEjSAIgiAIq56JqQHG/H5AxI0gCIIgCGuAM5NnAKjxhSkJlhQ1FhE3giAIgiAsmzMzgwC0ByuKHImIG0EQBEEQcsCZpFq90BapLXIkRRY3n//859m5cycVFRVUVFSwd+9efvCDH1z2Pg8++CCbN28mEomwY8cOvv/97xcoWkEQBEEQ5uOMMQlAW2ljkSMpsrhpbW3l//7f/8tzzz3Hs88+yxve8Abe/va38/LLL895/qmnnuLd7343v/Ebv8ELL7zA7bffzu23387BgwcLHLkgCIIgCJn02nEAasLNOI5T1Fg0p9gRXER1dTWf/OQn+Y3f+I1LbnvnO9/J9PQ03/ve91Kfe81rXsPu3bv5whe+sKjHn5iYIBaLMT4+TkVF8euCgiAIgrAWuOkft3POr1F/6v9DtPpmvvfb1+f08bO5fgdy+pWXgWVZPPjgg0xPT7N37945zzz99NN8+MMfnvW5W2+9lYceemjex00mkySTydTHExMTOYlXEARBEK5k7Hgc/YzqkNLNJOERaMMhcj5ER/lYUWMrurg5cOAAe/fuJZFIUFZWxre//W22bt0659nBwUEaGhpmfa6hoYHBwcF5H/+ee+7h4x//eE5jFgRBEIQrGce2OXn77Rine1Of+1Tqva8y3LEJPvy2YoQGrIBuqU2bNrF//36eeeYZPvjBD/K+972PQ4cO5ezx7777bsbHx1NvZ1yVKQiCIAjC0jDPn08JG391NVZFCeMlMBV1GAuVEqyMFTW+omduQqEQ69evB+BVr3oVv/zlL/nMZz7D3/3d311ytrGxkaGhoVmfGxoaorFxfmd2OBwmHA7nNmhBEARBuIIxzp4FINjayvpHH+Gfnvpz/vrYA9wwZfK9Mx/nmx/cV9T4ip65uRjbtmd5ZDLZu3cvP/rRj2Z97pFHHpnXoyMIgiAIQu4x+voAJW4gPZ24ylA5k/X1ZcUJzKWomZu7776bN73pTbS3tzM5OcnXvvY1Hn/8cX74wx8CcMcdd9DS0sI999wDwIc+9CFuuOEGPvWpT/GWt7yFBx54gGeffZYvfvGLxfw2BEEQBOGKIiVuWpoBODM9AECZHqG+PEwsGixabFBkcXPu3DnuuOMOBgYGiMVi7Ny5kx/+8Ie88Y1vBKC3txefL51c2rdvH1/72tf42Mc+xh//8R+zYcMGHnroIbZv316sb0EQBEEQrjh0ryzV0gLAmcQFAKJGadGzNlBkcfMP//APl7398ccfv+Rz73jHO3jHO96Rp4gEQRAEQVgIo68fgFBrK4Zt0O9OJ/brsRUhblac50YQBEEQhJVNuizVwuDUIBYOYdvGsKpE3AiCIAiCsLpwLAtjQHlsgi0t9E6qlvA202TMKRdxIwiCIAjC6sIcGgLThGCQQH19qlOq1TAZEXEjCIIgCMK8/ORT8L0Pw8paAZkuSTU3ofl8KXHTbprooRh1ZcWfLSfiRhAEQRBWGrYFj/05PPsPMNFf7GhmoZ9V4ibkdkqlylKGSUV1A5qmFS02DxE3giAIgrDSmBkBx1Lvm4nixnIRmWZigLOTqi283TSprm0qWlyZiLgRBEEQhJXGzIX0+7ZZvDjmIC1uWrEdO1WWajNMGhubixlaChE3giAIgrDSmD6fft/SixfHHBgZA/zOz5wnaSXxOw7VhkNHc32Ro1OIuBEEQRCElcZ0RubGMooXxxxklqU8v02zaTJFOevry4sZWgoRN4IgCIKw0pgZTr+/gsSNY5oYQ0MABFtbUn6bNsNknHJaKqPFDC+FiBtBEARBWGlklqXslSNujMFBsCy0UIhAbW3ab2OaJIMxfL7id0qBiBtBEARBWHlMX8ABTFhRmRvjrDfjphnN55vVBm5Fq4sZ2iyKujhTEARBEIQ5mD7PrzfWMxTw8x0jTrDY8bik/DatrQCzMjeBipqixXUxIm4EQRAEYYUxPnOOZ6MRAM4lh2kpcjweRl+6U8pxHM5MuNOJDRMttjI6pUDKUoIgCIKw4uiJp7uljBU0xC+zU2o8Oc6kMQlAq2kSq2koZmizkMyNIAiCIKwwTpkTgMrcmObKmXOju+Im1NrCKddvU2lqRByHQG1jMUObhWRuBEEQBGElYZmccpKpDw1rBWVuzqYzN57fptFQiz0DpSvHcyPiRhAEQRBWEvEReoJpC7GxQiYUO7qO6c24yRA37Ya7HqJExI0gCIIgCHMxfZ5TGeLGXCHixhgcBMdBi0Tw19SkxE2X6WaZSlZOK7iIG0EQBEFYQZhTQ/QG05ZYw0pe5nThyNwppWlaStysN+PqgIgbQRAEQRDmom/kGKaWnvS7UspSeqpTSm3+7p3wBvgZOJoPwrGixXYxIm4EQRAEYQVxaqJn1scrRdwYqU6pVmaMGYYTav9Vm2lCtAp8K0dSSCu4IAiCIKwgTrnLKD3MFbJbaq5OKb8ZpsJ2VpSZGCRzIwiCIAgrip7E+Vkfz+grxHPTd6m4iRol6sYVtFcKJHMjCIIgCEVl5rnnGP7i3+MYKkNzzUA/mx0LgOPNEH/TyipLBVtaOTP5SwAqjLC6cQWZiUHEjSAIgiAUlQt/93dMP/mT1MddGbftOgUvvma64DFdjK3rmOfOARBsbaH3yDcBqDH86oCIG0EQBEEQPPTTpwGovfNOzJY6PvH0JwD44PdtgpYSFsXGy9poJSX4KyszphO7B6QsJQiCIAgCgGMYGH39AFT+t3dwyDfITyd91JsmxiMaQcvB0s0iR0kqxlBLM5qmcXpctYG3mqp8ttIyN2IoFgRBEIQiYQwMgGmihcME6uroGT0OQJdhYvrVrBvbKn63VKbfxrAMhmbUGoZNjhubdEsJgiAIggCgn1YZkFB7G5rPx6nhIwB06AamzxU3hlW0+DwypxP3TfXhYOPYITb43OnEK6wsJeJGEARBEIqE3qv8NsH2DgBOjZ0AoN7wY7nixrJWQlkq3QbeO6kEma1XU6NNqQNSlhIEQRAEAcDo9TI37QD0uMKhUo+my1LmCsjceOKmNT3jxtZrKLMm1AEpSwmCIAiCABllqY52TNuk1x3gV6KXYrnrDJwVIG70OQb4YVQTMifV+1KWEgRBEAQBQM/I3PRP9WM6NhHbxjZjKXGDaRcxQrATCawLFwAItbSkOqXCeikajjoUrSpWeHMi4kYQBEEQioBjWRhnVBYk2N5Bz7hamNlhmIw6MWy/m7mxiitujH7VBu4rK8MXi3HSFTcNlKkDkRj4V9ZkGRE3giAIglAEzKEhtXIhGCTY1MipiVMAdBoGY1SgBd3pv8UWNxmdUrZjMzSjxM62UlfcrLCSFIi4EQRBEK4EHKfYEVxCqiTV2orm96cyN52Gia+8Htu/QsRNht/m3Mw5LMfAcfzsKgupAyvMTAwibgRBEIS1zgtfhb/qgjO/KHYks0jPuHE7pVxx02UYlFU1ZIib4gqzzE4prw3c0avoLvEG+EnmRhAEQRAKy5HvQ3wUTj9V7EhmkZ5xo8RNZlmqur4FJ+D6WIosbvSzStyEMjqlbKOGlvDKHOAHIm4EQRCEtc6UWhXAClhjkEnmjJvx5DgjiRFAlaWaWlqxXXGj2Sskc9PSwulxJchsvYZ6v7utXMpSgiAIglBgps6pf63ib9fOJHPGjZe1qTdNSh2HzvZObK8DqchjbtJlqVZeGVHixm/VUmZ7A/xWVhs4iLgRBEEQ1jKOk5G5WTnixnGcWTNuTo2fAtyFmfior6vHCQSB4mZu7OlprBGVUQo2N6dm3DSVtqLFR9UhKUvN5p577uHqq6+mvLyc+vp6br/9dl555ZXL3uf+++9H07RZb5FIpEARC4IgCKuKxDhYSfX+CipLmefO4yQS4PcTbG6e5beZ9MXQfH6coCtuipi5Sc24qajAV17O+YTK4qyr7ICZYXVIylKzeeKJJ7jzzjv5+c9/ziOPPIJhGNxyyy1MT09f9n4VFRUMDAyk3k6fPl2giAVBEIRVhVeSghWVuTE8M3FzM1ooNKtTSg+pTIiXufEV0VCsezNuWlsYSYxgOAkcR2N7QxfMqIzOSuyWKupIwYcffnjWx/fffz/19fU899xzvO51r5v3fpqm0djYmO/wBEEQhNXO1CAG0BMMssFMoBU7Hhf9ooWZXlmq0zBxSmvVoUBY/VvEMTdGn8rcZHZKOWaMTQ1V8KybuZGy1OUZHx8HoLr68k/U1NQUHR0dtLW18fa3v52XX3553rPJZJKJiYlZb4IgCMIVwtQ5PlcV41dbm/hhcrDY0aTQe5VQSC3MdOfHdBoG4ViDOhRUQ/J8xSxLeWbi5hZOT6gYbb2a9XUlqr0epCx1OWzb5nd/93e57rrr2L59+7znNm3axD/+4z/yne98h69+9avYts2+ffs466bOLuaee+4hFoul3tra2vL1LQiCIAgrjakhnnV9mWfNy1seCknmjJv+qX4M28BvazSZFuXVqjKheeLGBuziKJzU6oXWVg6f73E/WUtHYAwcC3wB8DJNK4gVI27uvPNODh48yAMPPHDZc3v37uWOO+5g9+7d3HDDDXzrW9+irq6Ov/u7v5vz/N133834+Hjq7Yy7pEwQBEFY+ziTgxwPKe+K4awcQ7GRmk7ckTIT1xhBfECgvF4dCkUB0CytaH6hzBk3r4wocVMVaiIwekIdqOoCf7AosV2OFbHG86677uJ73/seTz75JK2trVndNxgMsmfPHo4fPz7n7eFwmHA4nIswBUEQhFXGwOQZZnzqdbxRpOzHxcxqA+9op2f8pwA0efrFzYT4Qirj5LNRnV7BaKFDnSVuzr6gsjgtZa0w7F5za9YXPKbFUNTMjeM43HXXXXz729/mscceo6urK+vHsCyLAwcO0NTUlIcIBUEQhNXM8en+1PuGbRYxkjTW6Cj21BRoGsHW1lkLM4GUuNHCSsz4LKAIsVtTU1iuFzbY0sJIUj2XG2u60uKmVsTNJdx555189atf5Wtf+xrl5eUMDg4yODhIPB5Pnbnjjju4++67Ux9/4hOf4D//8z85efIkzz//PP/9v/93Tp8+zfvf//5ifAuCIAjCCuZocjj1vuGsjMyN7o4vCTQ24guHU2Wp9UZCHSitA8DnlqVU5qbwZSkva+OvrCQectCZBGB34zq4cEwdqtlQ8LgWQ1HLUp///OcBuPHGG2d9/stf/jK/9mu/BkBvby8+X1qDjY6O8oEPfIDBwUGqqqp41atexVNPPcXWrVsLFbYgCIKwSjhuzeBd6vQVIm6Mi9rAvczNVsPb1aQyNwHXUuG3KMoAwsySVK/XKWWWsa2xHp5c2WWpooobx1l4MNHjjz8+6+NPf/rTfPrTn85TRIIgCMKawTI47ksPiVkpZanUTqn2dib0idTCzG3mlDrglqX8rufGb4FjJgs+oyezU+pZt1PK0avprvLDmPoeqF2ZmZsV0y0lCIIgCLnEnBziZCjdyaMXcxpeBplmYm94n2aUUeo44AtCJAZA0G1h99tgFbEsFWxp4cCQ6o6Kag1EJk4DDoRjqRLaSkPEjSAIgrAm6T3/EoaWznfoK6RbSj+jxE2wPb0NPKRXqBtLa8GNOeh6boIWGOZM4eNMiZtmjo+qOOsizTDs+m1q16diXWmsiFZwQRAEQcgF8ZdfxhpWJuIzhx9md5/K1kxHNBLVKyNzk5px09FBz7haQ1Sul6gbS9ID8YJhlbkJWGAYcQrdCG6cVeIm1NrKwNl/B6A91rbi28BBxI0gCIKwRpj+xS/oveN9qY/rgT/OuP27by54SJdgjY9jjY0BEGpr49QzpwCo1tU0YkrTqwxCkbS4Mc1kIcMEZpelxnsGQYMtNd1w4VvqwArtlAIpSwmCIAhrhPgL+wHwV1UR2bqV880hTjbCtNIIlI8XLzYPb6dUoK4OX0kJJ8aUUbfRcMs7GR6WUGbmxkoUNE5rYgJ7UrV+2w21GKg9Ulc1r59dllqhiLgRBEEQ1gT6SWV6rX7f++j61jf55K9H+KP/EeB4tzIVa/bCHbr5JrVTqqMdy7Y44y7M3OJ5VzLKUoGwyuYELDDMwoobr1PKX1PD0Zkh0BwcK8yelpZVUZYScSMIgiCsCZInVRYk1N1FwkzQaykTrg93jcEK8BOnZty0qYWZpmPg2AF2hmZPJ4b0nJtilKX0jJLUL8+qTI3fqqPCnkxvA69eV9CYskHEjSAIgrDqcRwH/eRJAMLd3ZwcP4kNVFkWSU2ZdbUVIG5SM2462umZUGLM1mtpDrrdUJniJuJmbuzCl6U8M3GwpTm1Dbw80JAuScXaIFRS0JiyQcSNIAiCsOoxz53Dnp4Gv59QezvHx1TpZL1uMKN527WBIreD6xnTib3JxLZeRw0T6kCG5yYYSWduCl6W6kt3SvWMq1JaY0lrxtqFlZu1ARE3giAIwhrAy9qE2trQQiGOj6bFzYRWCoDP0oqyoykTT9wE2zvocQf42XodZdaYOjCrFVyJm6AFepHETbClhaG4er8r1p7ht1m5nVIg4kYQBEFYAyQ9cdPdDcCxkSMArDcMxnxlQPEWUHpYU9NYFy4AEGpv45VhZYD2mfUE4u6Cz4yyVMgtSwHoyeIYioMtLUxZQwBsr+/O2AYu4kYQBEEQ8op+wvXbrFPi5vioKp+0JiHu9zI3FGUBpYdxVrWB+6uq8FdUpKYTrytrQvOWZmaIm2CmuIkXbkKx4zipzI1eV4/lV8LrmtYNUpYSBEEQhEKR7HEzN13dTOgTDCZUhiSml1IVKwc8cVO8zE3mwsxJfZIpU3UdXR1zB/f5QxCuSJ33ylJQ2MyNNTaGPaPE1H4rjqbZ4ATYVNMMI+p5lrKUIAiCIOQZ3W0DD3d3cWJMlXsaTZMZO0ZjbSWgtmtThEm/HqkZN+3phZm2Uc7uKvdSXFI7a1dTMBRIrfo09cLF7XVK+etqeWFEZZtCTh2+8TNgGxCIqG6pFYyIG0EQBGFVY01NYQ4pX0iou5tjbklqvW4wTCUtdZUA+C0Nxyxe5iY146ajI6MNvI6NZW5WJqMkBeDz+bD87n0LmLlJdUq1tHLkgoqzMtgIF1y/TfU68K1s+bCyoxMEQRCEBdB71AXYX1eLv6Ii1Qa+QTcwonVEStQ8lqDlYJrx4sWZMePmmFvesfU62sKXzrjx8MSNmSxg5iajU6p3QmVuWsra0jNuVrjfBkTcCIIgCKuc1PC+LtdM7M24MQxClc2EwmrOTcAEo5jiJjWduI2Xz6sYozRR7rWBZ8y48bB8qkxlFjDjZPSlO6WG9X4A1ld1rJpOKRBxIwiCIGTD8AkwCtuWvBBJt1MqtK4bx3FSZakNuk6sroVg1MvcgGEUrusoEzuRwBwcVHF0dKQ6pToqOmBamZ8zZ9x4eJkbSy+cuPFWL/iam4k75wDY1bg+o1NKxI0gCIKwVhg8AJ+9Cr79/xQ7klnoPenMzXBimLHkGJoDXYZJY3MHoYibubGKl7kxzqjyjq+8HCrKGU6qjMjW2vVpcTNnWUplbizDLEygpMtSw2U1aEHVBr6rsXtVLMz0EHEjCIIgLI7+/epfrx14hZDK3GSYiVsMm4jj0NzWkVpjELRAN4ojbjLXLgzMDGCjFmZe1dwF40r4UN54yf28spRlFCZzo2bcKOF12Oeg+QxwNFqCFTA5oA7VirgRBEEQ1grexa2IHUcX4xhGSjiE13Wn/DYb3dJZKNZEMKK2ghczczNrYeaY1ylVw9bmSjivpilTt+mS+3mZG8csTObGGhnBicdB03jOmgQg6qslOKbip6QWolUFiWU5iLgRBEEQFseEKldgFW9WzMXoZ86CaaKVlBBoaEiLG93ARoPSOgJe5sYs/I6mVJwZM25eOqeyS45Rz/qyJEyfV4dqLxU3titu7AKJG68kFaiv55UJZSyuCTevqpIUiLgRBEEQFsvEysvc6CfVwL5wZyeazzfLTKyHqsAfJBRNl6WMIgmz1Iyb9g4OnlNCoTLQTHjkqDpQ2Q7hskvuZ7nzZBzDvuS2vMSZsVOqb0q931beljYTr4KSFIi4EQRBEBbLhPJirKTMTdKdTBxatw7bsWe1gVNWD6TXGASK6rlxJ/12tNMzrmJuK+uEc4fVgbotc97Py9w4VmEyN16nVKC5mTFD/bw313Stmm3gHiJuBEEQhEXhTPbzH6Ul9DqF69xZiNSMm+4u+qf6iZtxNNtHu2ESijUBpDI3ARsSeuHFjaPrGP1KKITa27mQVBmRLbXr0n6b+s1z3tf2u5dp08p7nJAuSyVqG3ACqlNqe31XxgA/ydwIgiAIawUjwdP2NH9UX8v/iUWKHU2K5Mn0wkwvaxPTowQAX3kDAOFoOl49Xnhxo/f1gW2jlZQQr4igMw7Ata2b4JxnJp4vc+OWpaxClaWUuLlQWoMvpMRNZ6xdzTeCVTHAD0TcCIIgCIthsp/9rjF3xKeB4xQ5INW2nMrcZHRKNegBdcArS0XT27WTycIP8TMyJhMfG3PXLpjl7G5tgvNuWWq+zI1PTfErmLhxMzfHAyE0vxKCrQRBnwLND1VdBYljuYi4EQRBEBZmYoDDoSAAuqaBVXxTsXn+PPbUFPh8BDs6ODqqzLkduiu8ylTmxptzA2AWcAGlR6oNvL2dX5x5BQCfUU9TYBJmhgFtzk4pACugLtOamX9x49h2Sty8iPJVRX1VlIyrMhpVHRAI5T2OXCDiRhAEQViYiX4OhdWFTdc0MItvKvayNsG2VnyhEMdHvTZwV3i54kbTNEx3jUEyUQRx05uecXPAbQOvDLageX6bqg4Ilcx5X8fv7V/If6bMvHABR9fB5+OAMwpAfbQ5Y+3C6vDbgIgbQRAEYRFcGD3OuYAq96yUzE0yZSZeh2EbqS6kneaUOuB6boCUuLH0wouyzBk3PeOnAGgr61jQbwNg+90Sm53/zE1qxk1DPX1JtQerK9ax6jqlQMSNIAiCsAgOuSUfAF1jhWRu3Dbw7i56J3oxHRPHCrHdnlAHytLiJrWjqQjixjidnnFzPqlawrfWrU/7beaYTOzhBJQq0wqQufHMxDQ2Y/jUYMHNtZlt4OvyHkOuEHEjCIIgLMjh6bOp91XmZiWIG3eAX3c3x8bcqb/JesodN3PjGoohvaPJNIyCxuiYZmp2jL+thQRDAFzdktEpVT9/5sbxK59TIcpSXuZmurIOze2U6oq1Zwzwk8yNIAiCsIY4pI+k3leem5VQlvIyN+mFmeGku/fIH4JIZeqsmcrcFFbcGAMDaj1EKMRxXwI0E8cOsLdtXUbmZu5OKQDHLQUWJHPjipsL5TX4gurn3V7aCGOqrCZlKUEQBGFNcdhJZ2psTcM0Ct9SnYk1NY05qHwh4a4ujrlm4gq9VB0oawBNS5/3djQVOHPjdUoF29t46qzqlArYdVRY4xAfRXVKbZz3/k5AZW58BZjhZ/Sp7NypUBm+oCrttRkWODaEyubcWr5SCRQ7AEEQBGHlMXTP/2XqJz8BwLJN/mBSXV1tDb57rQ/9dVNFvYDoPSpr46+pwV9ZyZFh5QlqNt2274ySFGSImwJN+vXwzMSh9g5eHFLZpVigJZ21qeqct1MKSLVea3b+Mzde+eyQT02gjvjLiE2qMho162aJxZWOiBtBEARhFuboKCP/9E+zPtea8f6tz9noxjSXuSTnHb3H65TqJm7GGZxRF+ZXRyKgA2WzswyWO+nXNgtclsqYceN1SrWWtcN5lcW5nN8GwAkWJnPj2DZGv1qMetCnhvc1lbRmrF1YPSUpkLKUIAiCcBHJV1QWJNDURMc/f4UDH3kDf/pePz+9Xt0eMkEvclkqtXahu5uT4ydxcLDNUq4qcVXARZkb2x2GR4G2a3voZ1R3VLC9jfMJt1Oqdn3Gwsz5/TYAWlBlorQ8h22eOweGAX4/pyOTAKyraocLbqfUKjITg4gbQRAE4SKSR1VWIbJtKyVXX83Pa0c43K5hVKksQsiEZJHFjX4ivTDTMxPbyUbawl6nVMOs81ZqAWVhl356ZSl/axtxVGbk6pZNGQszL5+5IajKUvnO3HhmYru2HiJjwMUzblbPAD/Isiw1NjbGt7/9bX7yk59w+vRpZmZmqKurY8+ePdx6663s27cvX3EKgiAIBSLxiituNqr5K4enVGklYpUCYwQtMMzCL6DMJNnjZW7WcWz0aQDsZAMNJWqy7iWZG3fSr1OANQYejm1j9KpszeloGVpAZUSubdm0+MxNSC399OU5bE/czFTX4wuqNvC28rZVtw3cY1GZm/7+ft7//vfT1NTEn/3ZnxGPx9m9ezc33XQTra2t/PjHP+aNb3wjW7du5V//9V/zHbMgCIKQR7yyVHjzJsaT45w1VOeMz6wBIGhC0iieuHFMM9WFFO7u4sA5Jcb8ZjOlhrowX5q58UYUF07cmENDap1BIMBTSRWX364gZsYhMQaa77KdUgC+UFT9m+fMjX5WdUpdKEtvA28PVbq7r1h14mZRmZs9e/bwvve9j+eee46tW7fOeSYej/PQQw9x7733cubMGX7/938/p4EKgiAI+cexLJLH1Kv1yKZNvDCiyicthskotcAJ5bmxiidu9DNnwDDQIhECTU2ceEKVTroqutGmvqEOXSRubHdeTCGG4aXi9MzELS28eEF1d8WCLemsTVUXBCOXfYxZmRvbAndLeK7xMjdnwuVowTEA2ry2+fJmCJfl5evmi0WJm0OHDlFTU3PZM9FolHe/+928+93vZnh4OCfBCYIgCIVFP92Lk0yiRaME29o4dOgxALbqOkO+agACFsSLmLnx2sBD3V1MGJNMuNmaPY2b4CW3dfkSQ7EnbgqXuUntlOpo56S796q1tH3xfhvSmRu/hdrn5YvmJVajrx+AI34fmmYT8oWpm1QrGFbT2gWPRZWlFhI2Sz1/zz33cPXVV1NeXk59fT233347r7i13svx4IMPsnnzZiKRCDt27OD73/9+VvEJgiAIc+OZicMbN6D5fBweVlmGrUmdRHkTAAEbZhLTxYvxhLt2oaub42Mqa2PrlVzbUJpeC3FR5qaQk349jN70TqlzbqfUppp1i/bbAPgiaiihzwKs/LWxG25Z6nhYfY2Wsla04dXZKQU56JY6fPgwX/7yl9m/f3/W933iiSe48847+fnPf84jjzyCYRjccsstTE/P/5/mqaee4t3vfje/8Ru/wQsvvMDtt9/O7bffzsGDB5fxXQiCIAhwqZn40PAhQGVumrrSFzk9XsTMjbd2YV03R0fSnVI7K11hE4ldUu6x3Um/hRQ3XlnKbm4hiZqmnFWnFBCIqGlCAQuw89Pp5Zgmhjvt+XxMmXs6Y+2rdsYNZNkt9YlPfIJoNMof/MEfAPDjH/+Y2267jfLycsbHx7n//vt573vfu+jHe/jhh2d9fP/991NfX89zzz3H6173ujnv85nPfIbbbrstFcP/+T//h0ceeYTPfe5zfOELX8jm2xEEQRAuImUm3rSJKX2K05OqtLIlqdO/Ke25TCaKKW7SA/yeH1SdUj6zidag6ka6OGsDgDsMTzMLKG7czM1AaTW+mQsAbK9bn16YuYjMjSdu/DY4ZpJ8zAg2z50D08TxBxiLzRAA2svb4cgv1YFVZiaGLDM33/jGN2YZiv/8z/+c3/md3+HChQt87nOf4y/+4i+WFcz4+DgA1dXV8555+umnufnmm2d97tZbb+Xpp5+e83wymWRiYmLWmyAIgjA3ySPqwhvZtJHDI6p80mSaWFYZV21oxvJm4RVJ3DiOkx7g19XN4QtKjLWWduGfVL6RucSN486L0Qq0fcFxnJS42e9z0HwmmhOg2dEgOQ6af1HlnpDruQlYYJqJvMTqdUrNVNVCRC3MbCtrgWFV/qN29YmbRWVuvvKVr+A4DqdOnWL//v0MDw/jOA4/+9nPuP766/nKV76CbducPHmSr3zlKwDccccdWQVi2za/+7u/y3XXXcf27dvnPTc4OEhDw+xf3IaGBgbdlNrF3HPPPXz84x/PKhZBEIQrEWtyEqNfCYTwxo0cPvsdQGVtLmjVbKot5UW/yiKYyfxcaBeM8cIF7MlJ8PkIdrQz8MwpALbVbYKhn6lDc5R7nEBhhuF5mOfP48Tj4PPxC3MMgIpAE/7zSoxR3Q2B8IKPE4ykxY1hzBDMQ6yemXi4rAbNbQNv80WUf8kfgsqOPHzV/LKozE1HRwednZ2EQiEaGhro6OhgbGyMiooKXv/619PR0cG6devQNI3Ozk46OrJ/Iu68804OHjzIAw88kPV9L8fdd9/N+Ph46u2MOwpbEARBmE3yaHrtgj8W49BI2m+TLGlE0zRMdwGlkdSLE6Prtwm2tjJsT6A7UziOj71tW2DwJXWocecl9yvUMDwPz0wcbGrimDsEsaUss1Nq4ZIUQDii4g5YYFrJBU4vjXQbeAxf0M3cGO7Xqu7OW/t5PllU5uaGG24A4KqrruJ73/sef/iHf8jDDz/Mm9/85pQ35sCBA7S1tc3rlbkcd911F9/73vd48sknaW1tvezZxsZGhoaGZn1uaGiIxsa5V7GHw2HC4YXVsSAIwpVO2kysBst5nVJbkjrBqhYAzIAGOFh6ccSNftLrlOriFXcTuK3XcFVbLTziiZsdl94xpK4DhcrceGbiYHs75xJn0EKweVan1MJmYoBQhqHYyNPKC69T6mQwhOYz8Wt+miaVyFmNfhvI0nPzyU9+kv3793Pddddx+vRpPvGJT6Ruu//++7ntttuy+uKO43DXXXfx7W9/m8cee4yurq4F77N3715+9KMfzfrcI488wt69e7P62oIgCMJsMs3EM8YMPe5slq26TqxBZeRNb7u2Udjt2qkYU51S6/h5n8os+YwmuoKjauqvLzBnWUrLnPTr5N9UrJ9R4kZvbMbyqxfkuxs3Zp25CXmZGxuMPHluvMzNULnKd7SUtRAYcf02q1TcZNUttWvXLk6dOsXw8PAls2x+//d/n4qKiqy++J133snXvvY1vvOd71BeXp7yzcRiMaJR9Yt4xx130NLSwj333APAhz70IW644QY+9alP8Za3vIUHHniAZ599li9+8YtZfW1BEARhNkk3cxPetJFXRl/BwSFmatRaNkZrN+BlbsAqkrhJd0p18dLQUwDUhzvwDbnjQOo2z+ll8YVVBsTntVT78+FeSeOVpS5U1OMLqU6pdbFOOO/Ocltk5iYQDmHiZm7yLG7OVSrR11beBgOrd8YNLHHOzVxD+pqamigtLc3qcT7/+c8zPj7OjTfeSFNTU+otcz9Vb28vAwMDqY/37dvH1772Nb74xS+ya9cuvvGNb/DQQw9d1oQsCIKw4jjzCziycgaQOrad8txENm9OzbdZn1QmlWClKkt527Udo7DbtT1SnVLd3ZyeVO9vrN6Q4beZoyRFWtykJv3mGa8sdTxUii+ounQ7tTAkJ1R2aZEZkWBEGaHztazUMU0M1+pxvko9L63lrXBhdW4D91hU5uaBBx7gXe9616Ie8MyZM/T29nLdddcteNZZRGrw8ccfv+Rz73jHO3jHO96xqHgEQRBWHI4DX3snxEfhD45DaW2xI8Lo68OemUELhQh1dHDo5/8IwC7dvaBWuOIm4G7XNgpkXsnAnp7GdF/sBjs7GXvpDGhwdctW6HlUHZpP3LiTftPiJrsX49mQ2Qb+gk8Zc0v8lVSMKW8L1evA7d5aiGA4jCdpjGTuxY0xOAiWhekPMl45qWbclDTChBvrKhzgB4vM3Hz+859ny5Yt/NVf/RWHDx++5Pbx8XG+//3v8573vIerrrpKdksJgiBcjukLEB8BHJgZKXY0QEZJav16tEAglbnZrbsT493VC6nMjVl4cZM8dQoAf3U1Z3yTOJqOYwe4ofvynVIAgXDmjqb8ltSssTHVrg48p6n5bc0l7XDevX4u0m8D6cwNgJmHlRfGWVWSGimrRguNAtDmuN1R0SoozW790kphUZmbJ554gn//93/ns5/9LHfffTelpaU0NDQQiUQYHR1lcHCQ2tpafu3Xfo2DBw9eModGEARByGCsN/1+nnwU2ZJI+W02kTATKTPxlqSOHSrDF1GeSjuoLhuOWbgFlB56qiTVxROnlMdGMxroLrHSz2nj3BaFoJu5CVj5m/TrYZxWU539DQ0MWoOEgE013RmTiRfntwEIZXT76nkYnOj5bfoiMXwhNe+mXXfbwFdpSQqyMBT/yq/8Cr/yK7/ChQsX+OlPf8rp06eJx+PU1tayZ88e9uzZg8+37FVVgiAIa5+x0+n3zfzMLsmWdKeUMhNbjkXAjNBgWWhuGziAVYTt2qkYU2bidTzbrzJLlYE2fOdcM3GsXWUb5iAYTbdUm2Z+huF5eCUpo7EFLaQ2a2+pXQ9H/0kdyCZzEw5go8osyXxkbvpU+WmgpALNr57flimvDXx1lqQgy24pgNraWm6//fY8hCIIgnCFMEvcrIzMjVeWimzalJpvE0uUqwxHRVPqnO1t1y5G5uZEOnNzbEx1SnVUrIPBA+pA09wlKYCwK26CFuhGPL/ixjUTj1XW4wsp4dVV0Zl1pxRA0O/H8qsuLz0PU6FTnVLlqvzVUNJAZERl7Vbj2gUPSbUIgiAUmrFevldawpdiFSsic2PPzKSyDeFNm1J+m6ak6/eoSGdubHdHE0VoltJ70gszzyWUQNzdsCUtbuYxEwOEM4fh6bnPgMyK030uz5RUp9rAO7Uw6FPgC0LNukU/VtCvYbkWmHzs89I9cRNThbq28jYY9jqlVm/mRsSNIAhCgYmPnuJ/1dXwmepKBmfm3otXSJLHj4Pj4K+rJVBdnRI365JuR2t5OnPjBFTOw1fgzI1jmuinlKCxWlvRfep5u7Frx4Jt4ADhEjdzY+ZvXoyH3qviPBzwuxN/AzRPK7MuNeuzmrGjaVp6Wameh8yNayg+X6UM4rPFjWRuBEEQhEXy8lQvhqZeKU8nJ4scTebahU0krSTHx9TF7Spvl1FFc+qsXeDt2h7G2bM4hoEWDvNUchRNs8GOcFV9U3rq7zydUgAB15gbsEDP0xqDVKynvTZwJUYaS1oJuNvLs/HbeHj7vMwc7/NydB0zNeNGxdoerlKzeNDUXqlViogbQRCEQuI47NfT7d9JI78lksWQPJLulDo+ehzLsXDMEvb4ptSBDHFT6B1NqRi9tQtdXTx1VmWWSmjBN3xUTRyOVEJs/t2EoaiKO1/D8DysiQmssTEATpWrr7OhammdUqnHdMtSlp7bEqYxOAiOQ9IfZDKmBg222q4sqGyHYCSnX6+QZC1uPvGJTzAzc6nqjcfjs3ZNCYIgCHMwfZ4XQukty0kzv1mExZA2E2/k5eGXAbASLTQ4rgibJW7c7dpW/vczZZLpt3nZzYI0l3TBQEZJSpu/wTuQMek3aeRP3Oi9ZwCwKqtJlo0BsL6qe0kzbjy8slSul5V6CzOHSqrQwupn3e6VvlZxSQqWIG4+/vGPMzU1dcnnZ2Zm+PjHP56ToARBENYq9ugp9ofTg9kSebzQLgbHcUgcTS/M9DqlSDRSYrgDWTMMxbjD8HwFNhQnT6TXLvRNq/e31m7K6JTaddn7h6LpLISZzF+2zHD9NlM1jfjcNvDO8o4ldUp52P787PPyzMRDJZX4Auq63jbp/sxX6U4pj6zFjeM4aHOo4xdffJHq6uqcBCUIgrBW6Rl8jgl/OnOjFzlzYw4OYk9MQCBAqLub/e7MmEq9Uh3wh6AkPaVW8xZQ2hpYhVM43gA/X2cnU47KOOxr27aoTimAcCQ9DC8xkz9x43VKDZbXpsWNLwLGjHoul+BjsVxxYxs5ztx4nVJlSrBWhasoH3XHFKzyzM2i59xUVVWhaRqaprFx48ZZAseyLKampvit3/qtvAQpCIKwVth/7sVZHyeKPOcmNZm4uxvLr9EzoczEV5dWQRLVKZXx916LlAFu5sZKgj/rcWlZ4zgOyR7luTlVWokvpEoor2ndvGhxEypJZ270eP4EZWphZrAsvTAz4X69mg1Ler5snytuzNyKSa9TaiimYmorb4OTrjdolWduFv0s33vvvTiOw6//+q/z8Y9/nFgslrotFArR2dnJ3r178xKkIAjCasUaG2PysR/juCWFyV++xE1uG3VvncZkWXEzN+nJxJs4MX4CyzFxrAg3VIZghNl+G8AXydiubSYhlL8FlB7W8DD2+DhoGk8YaldTwKmgJjEJ+iT4w1C78bKPEQ4GsHzgtyGZzKO4cTM3h91u78pQFTEvG7IEvw2ky1K53sTuZW7Ou5fz1rIWGH1YfXClZG7e9773AdDV1cV1111HIJB/tS4IgrDaGfrLv2L8299OfXyt+wZg+uCl37/Uw1hIMs3Ez7jzbaxEM9saXQFwkbgJRFXmJmDibtcuQIxuSSrY2spzoyqzVBvuSGdt6rcsODvG79Mw/Urc6PF8GoqVkOmrVIbr7squZXVKAVj5ytx44qZK/Rzbg+Wq8yxYAuXNl7vriidrz015efmszeDf+c53uP322/njP/5j9Bw7uQVBEFY7M7/8JQAlV19N6Mbr+eUGjV9uUIPZAjbYE8U1FCeOumWpjRvZP6T8NnailfagO3TuInETjKpMjd8CxyhMSU332sC7u+gZPwHA+sr1szulFkDTlLgBMJP5ec7t6Wms82oi8VCNem66Yl3L6pQCsN1N7ORQ3NjJJOa5cwCcr1FCts12y48162CV74rMOvrf/M3f5KjrrD958iTvfOc7KSkp4cEHH+QjH/lIzgMUBEFYrZgjI6l229a/vY/Td7+LT/5XP9/+FYvpqNsBk+PZJdlgJ5PoPacACG/azPOuuKkOdFGSUBe+i1/Bh11xEzLVAspCkDypBE2gs4sxU7Vav6pp66I7pTy8DIiRzM9zrp9RsSVLy4lXqPJZV0UHnHcH+C0xc+OJG8fM3XAho19tAI/7QyRiKtZ2b73DKi9JwRLEzdGjR9m9ezcADz74IDfccANf+9rXuP/++/nmN7+Z6/gEQRBWLYmDSiyEurvxl5ezv+9nAOxM6OgBlUawkrlt780G/cQJsCz8lZVQW8XZKSUidtVvhwl18bs4cxNyxU3QBD3PO5pScbqZm+GaZrSQWrtwdfPidkplkh6Gl58qg2cmHq6oS3dK+UvAjCtfUHXXkh43lbnJ4SZ2o0/9fIdKqnACSty0Tqms02reKeWxpFZw21ZP8KOPPsqb3/xmANra2rhw4UJuoxMEQVjFxF9SF9/oju0AvHDueQC6EkEM94Jl6cUTN4kMM3HPRA8WOo4V4nVdm2FiQB26SNxESl1xY0HSKIxfyGsDPxSK4guqdRXrQ1Uw2Q9o0LBtUY/jtVTnK1tmnFHi5nSkKr0w08sS1W4En3++u16WdFkqh+LGG+BXVgaaQzQQpWbENT6v8k4pWIK4efWrX82f/dmf8c///M888cQTvOUtbwGgp6eHhoaGnAcoCIKwWokfUJ6QyI6dJK0kL0+oDER1PJYSN7ksNWSLZyYOb9rIwfOumTjZzNXtMZh0xU3G0kyAcDS9gFLX8+8XsmdmUiWUn9pK2JT56yj1ljtWd0O4fFGPlZoXk+fMzclIFM1nEPAFaJlQu5uW6rcBsL25SDnN3LgzbirU/J/28na0YZW5y2Zr+Uola3Fz77338vzzz3PXXXfx0Y9+lPXrVW3uG9/4Bvv27ct5gIIgCKsRx3FIHFBlqejOHRwaPoThWFRbFrpRj+GWpewct/dmQ+IV1cUT2bSJn53ZD0DAaGOd0wu2AeGK2dOJgaA7L0btaMp/WUo/dQoAf1UV+5NK5LSXrcu6JAUZmZscT/r1SA3wq1TdxO3l7QQuHFM31i1d3Dh5FTdKBrSVNsK067NaA2WprPu5d+7cyYEDBy75/Cc/+Un8/qWl3ARBENYaRl8/1sgIBIOEN29m/9F/AWB3IskA9XSFR4FpNCN3F6xscBwnvTBz4yYOHvpXALrKN+Lre1Ydarnqkq6ZUDRCAmUozueOJg9vYWagq4sL+mkCJbCjfjP0L75TysNys2W5bqn2SImbavUz7azohKOqFEn90szEkBY3Wg7FTeKMKkudr1SP2eZ35xWVNUCkImdfp1gseVjNc889l2oJ37p1K1dddVXOghIEQVjtJLyS1KZN+EIhXjj3AgB7EklmqjqxQ8pHglGcspR14QLW6Cj4fAS6Oxl8XpUkrm7ZBX0PqkMtr77kfpniRi/ARnPd7ZSaaWiFkCqd7W7YBM8rMbbYTilIZ26cPPic7EQCc0CV8oZqlM+mq6ITLjygDiwjc2MHvMxN7paVJs+eRQPG6lSJrs37NVwDWRtYgrg5d+4c73znO3niiSeorKwEYGxsjNe//vU88MAD1NXV5TpGQRCEVUfcLUlFdmzHcRxePK/WLuxOJjmxYSN28CfqoFnY7doenpk41NFBrz6EjY5jB7lp3Tb4wR+qQ62XiptwSTT1fjKef3HjZW76Kurxhx8DYENZGwy75Z4lZG7y4XPyDLqJUJSp2BgBoDNQCmYCAhGo6lz6g7srG3w5ytzYiQTaqFphMVKnfobt3tTmNeC3gSV4bn77t3+bqakpXn75ZUZGRhgZGeHgwYNMTEzwO7/zO/mIURAEYdWReEllbqI7dnJ64jQjiRFCtsPWpM7Gzduwg8rIqRVJ3KTNxJv4qeu3sZPN7KkLwgV3LsscmZtwaVrcxGcm8x6nfkJlbg4Egmj+BBo+upIz4NhQWg/ljYt+LCeP4sYrSfWV1OALu23gnp9qGZ1SAE5ATV/WchS257eZCYQZj6ot4G0TKua10CkFS8jcPPzwwzz66KNs2ZKuH27dupX77ruPW265JafBCYIgrEYcyyJ+SJVQojt38GO3JLVNT+J3NLZs3MTRkBI3viI1SyWPptcuPHVGZZWq/F1Ez+8HHKhsh7JLM/HhaHq7dnI6v5kbx7JShuKf+1RmoT7SRuicO/E3i6wNgBXwWqrzIG7cTqmzpVX4gmoWT9eUO+V5GX4bAFLiJjdC2BM3g6UxHG2EgC9Aw6gaQLhWylJZZ25s2yYYvHSHRzAYTM2/EQRBuJJJnjiBMzODr6SEUFdXuiSV0BkN1hMIhbHDKgNSrMxNesbNZl4ZVV1Tm6q2QMpMfGnWBiDo92G4SYhkIr8Tio2+PhzDQAuHeTmgyiibazYsqVMKwPY2cudwXoyHt1NqMKZ+rtWRamIjqqS2HL8NpDM3Pju34maoXLX1t5a14vfawNdI5iZrcfOGN7yBD33oQ/S7cwcA+vr6+L3f+z1uuummnAYnCIKwGkm4HaWR7dvR/P60mTiZxCxvU4ci6iLoNwGnsALHMQySbrkntHEDI6a6CL+2bRecdcVN69Vz3lfTNAxXIxiJ/O6W8mK0WtpwImpezPa6TUsXN4Hcdx15GG7mZqBSfY3Ois70wszlZm6CISB3Wb5Er8rSnC9XoqktWqemKPsCKmO3Bsha3Hzuc59jYmKCzs5O1q1bx7p16+jq6mJiYoLPfvaz+YhREARhVZGaTLxzB+PJcU6Oq86o3YkkpQ1qBL8WVtu1faamNjEXkGRPDxgGvrIyjocSOFoCxw7wpo07M8TN3JkbSHcdGYn8toJ7axdGa5vxhZW42RBbB0MvqwNZdEoBOIHcz4vx8PZKDVUrBdJV0ZH2Li0zc4Pnz8pRWWrilIp1uEr9HNt9ro+qqmvB7eqrhaw9N21tbTz//PM8+uijHDmiVOmWLVu4+eabcx6cIAjCaiSdudnBC+f2A1CtB6mybZyGbgC0qBI3fhPVUVPAi0oyY+3C944/B0DAaqGJYZi5AL4gNO6c9/6p7dp6njM3PUoUni6pxRf+BQDrCYIxA8ESNZ04C2z3Oc51KdDR9XSpp0YJvs5ABVhJCEShsmNZj695mZscaTKjrw8/MFqrhFib97hrpCQFS5xzo2kab3zjG3njG9+Y63gEQRBWNXYiQeKoEg/RnTvYP6hmxmx0dYDmXuj8UbUywG8CRmLRKwRyQaaZ+Nl+JcSaIuvTWZvG7RCMzHt/M+ADLKxkftYYeOgnlLh5MeBH85kEfWFaJ9wpug3bsu5AcoLqkperDIiH0d8Ptk3CH2S8ahQ/0Ollh+o2XjIIMVu0YI7N54PKVnKhWgmxNq+lfw1sA/dY9DP+2GOPsXXrViYmJi65bXx8nG3btvGTn/wkp8EJgiCsNhKHD4Np4q+tJdDUlPLbvNor4biehkDpRZmbQsaYMZm4Z1K9v612C/SpLM58ZmKP9ALK/C39dByHpLsw84WwNxSvG/+Qmh90uczSvI8Z8LwruRU3Xhv4QGkN/rBqre7y2uTrlum3ATS3s86fg8yNPT2Nf0JtAR+oHAOgbdJtA78Sxc29997LBz7wASoqLh3LHIvF+M3f/E3+5m/+JqfBCYIgrDZS+6S2b8e0TQ6cVx/fmFTdPp64CUfd7dom2AVYY5CJN+PGv349U47q8nlD91WL8tsAmAF3AaWRv8yNNTqKPT6Oo2kM1KnnZzmdUkDOW6o9vDbw/rIYeAszR9VQv+UszPTwh5QnJheZG28J6WQwwnRUR0OjZUTFv5bKUosWNy+++CK33XbbvLffcsstPPfcczkJShAEYdEMvAjf/iCMny12JADEPb/Nzh0cHjmMbifBjLDRTIDmTy2iDJeqMlTIBF2fKlh85ugo5jlV2nk2CJo/Do6fm9q3qOcSFpG5cYfh5XHppze8L1nTgFl6AYANlethwNsplX3mhlyXd1xSO6ViqpTXVt5G4LwSkLnJ3LiddTmIW3cnKQ+Vqd+/ptJGQmNra8YNZCFuhoaG5pxv4xEIBDh//nxOghIEQVg0P/sMvPg1OPCNYkcCzJ5M7JWkShN1aACxltQo/YhblgqZkNTzP+nXwzMTB9vaeHRQDcOL0kp4+BVlgI1ULjiC33K7jvIpbry1C+eqGlOdUuvDNcrwrPmgYWv2DxrKV1nKnXHjdh91VXSm10PkInMTzp24MfpU5uZcuRJ6beFqwIFwDEprl/8FVgiLFjctLS0cPHhw3ttfeuklmpqachKUIAjCovHabQuY/ZgPa3wc/bS60EW2b2O/2ynVEHc3Lmd0zWSKm0Qhxc1Rb+3CRvafU3/TO8o2wlk38976atC0yz6Gncrc5G+8su76bY5HqvCF3MxNQnlvqN0Iweh8d50XLaQyK7nO3HgzbgbdNvDOYAwsXXV0xZY/NyYQUb8/fhuwlxe819V1rkIJ1FavDbx2/YI/99XEosXNm9/8Zv7kT/6ExBxDm+LxOH/6p3/KW9/61pwGJwiCcFlsG7zJqgX2rcxF3H0BGGxvx19ZyXNDKnOzKel29WQMSAuVqgtWyChsWSrh+m0iGzfRP3McgKsaty84mTiT1JbqPKwx8PDMxC9H/GiaTVmwnPqRU+rGpfhtAC2sxE0ujLkejmWlSj3n6tTE5k7bFQl1m5bdKQUQiKhJwn4LJZqWgbfg83ylehLavSzWGipJQRat4B/72Mf41re+xcaNG7nrrrvYtGkTAEeOHOG+++7Dsiw++tGP5i1QQRCES5gcUDNPYEWIG2++TXTHDs5OnWU0OYzj+LkpZIHBLHETLo2SwM3cGPnfru3hlaWmWjsxRr+KD3jjulfB859TBxYwEwNYgfytMfDwMjdnq5VQ2Fi1AW0ZnVIAvpASCbnM3BgDg2Ca6L4Ak3VjAHR5ayly4LcBCESUPyZggWPqaEvIWnl4mZsL1UoktSVcYV27djqlIAtx09DQwFNPPcUHP/hB7r77bhx3XLimadx6663cd999NDQ05C1QQRCESxg+xs+iEb5YWcH/SgxzeadI/om7nVKRHdt5yi1J2fEWtobGYZo5xU3YAL1A4saxLJLHlBfkmYAfX2AGHB87yuphxM2AtbxqwcexXXGj5Unc2PF4qqunv06VotZXrodj31IHlpy5yVh5kSMMz29TWoXpV4syu8bV4sxc+G0AgtG0uDGtBEFiS36sVFmqWv3OtXtzg9ZQGzhkOcSvo6OD73//+4yOjnL8+HEcx2HDhg1UVVXlKz5BEIT5GT7OP8QqeD4S4bHkYFHFjeM4xF9S3UbRnTt5bui7AFjxDur5mTqUIW4iZSWMA34HpmYKU5bST/fiJJNo0Sg/ig8AEAu0ER501xlUd0NJ9YKPYwe9Sb/5ETf6qVPgOCRKypiuHCEArC9vgxGVzVmquAmEXe+KhdrnlQOPSWrGTXk5MEpVuIrYeVXuy1XmJlyi4g7YYBgzLHWWtTU1hTWuZtwMV8cBjdbhU+rGNVaWWlIxsKqqiquvvpprrrlGhI0gCEVj5twRXoioro+4lSxqLObQENb5C+D3E9myhWf6nwcgYnURmlKvlmcZistKUu/Hp8YLEmPKTLxhA4fG1PvrY5uy8tsAOMH8zIvx8Pw2feUN+MIqC7LecoVIefOSu3r8rjE3YAFWbgYQejNuBmKqE6urogOGXXGTo8xNyPXcBCwwllF+9bI246EIibBGdbiK0vg4oC3YIbfaWL7TSRAEoUj8cuQgpvvqO27ndxXAQnjzbcIbNjDlNzg7rVqZb67vQrMNtXG5PN1RGimJ4OU94vHClKUS7j5A/4YNjJhKQOxt3QVnf6kOzLMJ/GIcb15Mjnc0eXhrF45FK/GFxgDYMK3+pWlpfhuAgLfywkK1veeAxKnZbeCd4WqwDQiVQawtJ18j4m6QD1qgex6zJZAqSZUrkdcedrN0sbYldZ+tZETcCIKwankq3pd6P2HnbxXAYkh4m8B3bOel8y8BDrZew60NbhGhIj3jBsDn82G6H+ozhRE3npl4qKYVX0Q9d9e27EyvXWhd2G8DZGypznmIQHph5tlKdcGti9ZRed6dG7PEkhRAoCTtXbHN3Iib6Z5TAIzUKSNPp+f2qNuUs9bqoJudBDCTS/9d8TqlzpWr38k2n7s/bI1lbaDI4ubJJ5/kbW97G83NzWiaxkMPPXTZ848//jiapl3yNjg4WJiABUFYOZhJnvKlBU3cyV9b8mJITybeyTP9SixYMx28qsLdx1d56bwTw11jYMSX/mo8G7y1C8+Fo/gCU4DGJkIQHwV/GBoWJxyckDfpN0+ZG3eAX3+N+nh95frlrV1wCbmb2IMWmMvIgHg4to3TpwTDSIO7Ddwbl5Ijvw3MFjdGYun+rFTmJqZ+79q85Z5raO2CR1HFzfT0NLt27eK+++7L6n6vvPIKAwMDqbf6+vo8RSgIwkql7+wznMqYmj5TxMyNY9sk3Bk30R07+Jk7EC/m20CN4b74yvDbeHg7mvQ55oflGmtyMtWB9GNtDIDaUBvRAVc0NO0Ed7HkQqTWAeRhQLFjWeg9Stz01atS4/pYN5w7pA4ssQ0cIBJNe1eWU97xMM+dw2fomJqPgSq1O6zLW0KZI78NQDCc/rkYyyhh6q64OV+lfnBt3nLPNWYmhiy7pTz++Z//mS984Qv09PTw9NNP09HRwb333ktXVxdvf/vbF/04b3rTm3jTm96U9devr6+nsrIy6/sJgrB6Mfr6OP1r/wNzWG1dNq0kX3GntU5H4AdFnCGqnzqFPTWFFong7+7k5DPqQnxN06tg7D/Uoctkbqxk/sVN8qgqSQUaG3k52YtWCltrtmZtJgbQIrlbB3AxRn8/jq5j+AMM14zhAzYEytXwunDFnCJxsURK0pkbw1z+XCTPTDxUGsPwTRLQArRcUMIsp5mbUBAblY0wEsspS7niplr9vqXawNfYjBtYQubm85//PB/+8Id585vfzNjYGJalfrsrKyu59957cx3fnOzevZumpibe+MY38rOf/eyyZ5PJJBMTE7PeBEFYfUz84AcYZ87gzMzgzMzgT1pEDIgYUDMJbafzUyJZDHF3n1Rk2zaOTp7AIoljRbht407oV1OKqdt4yf3MgPoTbCXzb4b2JhMbHd1YQbUo8dqWnYveBJ6JFnYn5uYhc5Ma3ldaB1F18d2gu/6Yhu3LmvgbjipRFjAhqS/f5+TtlBooV6KptbyFoNeunsPMTTjgx3KHQicTyzcUX6hRj9HmbQNfYzNuYAni5rOf/Sx///d/z0c/+lH8fn/q869+9as54Nac80VTUxNf+MIX+OY3v8k3v/lN2trauPHGG3n++efnvc8999xDLBZLvbW15ca9LghCYZl+5hcA1N51F53/+QP+8P8X4s4P+jm00fV/FNFPnDITb9/Ok6dV55EV7+C1LX7wpup2vPaS+3nixtbzt4DSwzMTD9S2pczE2ys3pL0sWYib1K4jC7UCI5dxup1SZyqqXV8QdI+pxZnL6ZQCCEbcxZksz7viYfQqkThYqcqjXZE6sE2VYXK3v+eCYEDDdC+3S/VnWRMT2JOqDHU+BmEtQqWpQyAKFa25CnXFkHVZqqenhz179lzy+XA4zPR0fh3/mzZtSq19ANi3bx8nTpzg05/+NP/8z/88533uvvtuPvzhD6c+npiYEIEjCKsMxzCIP6d8LOU338SRyBg9MZsKy2YqVAUMopmAZc7qSCoU3k6pyM4dPHH6+wDUBTcRG1KCjLotUFZ3yf0sV9w4ev6VmWcmfjFcii84AWhs1nXVtlxSm1W5xzerpVoHr+smB+ipTin1mK1lrZQMuUMGl2EmBghFI3g5Mt3zmyyDeKoNXH3cqbnG3xx2SgEEfL5U5kZPLK2c5nVKTZZE0YMGHf5Ktam+Zl1O9l+tNLL+jrq6uti/f/8ln3/44YfZsiV3NcbFcs0113D8+PF5bw+Hw1RUVMx6EwRhdZE4dAh7ZgZ/LEZ440ae7n8agNfEE1zwqSuL39QgBz6KbLF1neThw4CaTHx8QgmdqxuvglM/VYc6L83aAFhBdcVyjPxmbhzbTnlungyo56gx2kbJoJtVWsQm8EwCJervaCCH82I8km6nVF+NujzlqlMKIJSjriMPb8bNuRolmbo8kVqXu5IUQNCvYblXayO5tN9xPTXjRpXmWn3uc7EG28BhCZmbD3/4w9x5550kEgkcx+EXv/gFX//617nnnnv40pe+lI8YL8v+/ftpampa+KAgCKuW6V+oDEjJNVej+Xz87OwTAOyLJ/i5rw44TMAAjASEywsaW/KVV3AMA39lJedjPpKM4Dg+3rb5Wnj0U+rQfOLG3dHkGPltYzf6+rBnZiAY5EjpCEFgZ/22JZmJAULevBgTHCOJlrvEDfoJteOqv04Jhg0lDZAYA19w2SbdcCSErYHPWf5sIcdxsM6eQQPO1Suh1DWtOqaoz+0LfU3TUpkbY4nmc89vM1ShHqjbKyeuwU4pWIK4ef/73080GuVjH/sYMzMzvOc976G5uZnPfOYzvOtd78rqsaampmZlXXp6eti/fz/V1dW0t7dz991309fXx1e+8hWAVEfWtm3bSCQSfOlLX+Kxxx7jP//zP7P9NgRBWEXMuH6bkquvYUKf4MCw6kbaMBPm+Qo1ZVWJm8LMi8kkZSbesYMfnPg5AE6yhb2NITjnllPmzdy4awyM/G3XhnRJKtnaASWqNX1n3TbY74qvxQ7vc4m44iZogm5MESY34zjM0VGssTFsNAbr1UqKDbabsqjbvOhW9fkI+n2YfncTe3x5mRtreBgtPoOFxrnqSUCjc7g3HWuOsfwa4GDpS8uUeZ1Sg+Xqd60z6W0DF3GT4r3vfS/vfe97mZmZYWpqaslzZp599lle//rXpz72vDHve9/7uP/++xkYGKDXXUoGoOs6//N//k/6+vooKSlh586dPProo7MeQxCEtYVjGMy4TQMl117DTwd+gY1Dl24wZTSytbsZnoSgqWHr0wUf3pU4kJ5v8+NTSoQ1hDYRPqtKZ9RvnXcXkiduyNMCylSMrrjpr27FH1Hxbi1pgbHTgLaoTeCZhEuVoThkgq5PEV7g/GLxOqXOlVRilat5Meun3Q7XZZakAEKBtLgxluhd8fAWZl4oKccMzFAZjlF5yp3Fk+PMDZAqS5nLzNxcqHZLaJPeNnARN5dQUlJCSUnJwgfn4cYbb8Rx5m/fvP/++2d9/JGPfISPfOQjS/56giCsPhIvv6xavysrCW/YwM+eeQBQJanhSDttzQ0ARHSHRHKcpf9FWhrpycQ7OHbqYdDg1Yvw2wDYQbd7J8/iJnlEiZuXIrHUrqbNnqG2diNEYlk9XtT13Cx319ElcbolqbPl1eA7TUAL0DmsfC3L7ZQCCPjSXUf6MqdCpxZmVpQAM3RFG8E5AOHYrB1iucIrS5n60sYGpKYTVytR1+bNuLmSPTd79uxBW6TZ7HJt2YIgCNkynSpJXQ2axlN9TwGwLx7Hat5MSbm6MIcNiCfGCipurKmpVLYhuaGLmVPKg/H2zfvgB3+rDl1G3HhrDLQ8LaD0SLjbwJ+NKONyc2kb5Zlm4iwJlURxcMtS+vKNuR7e2oWzVcr02hnrJHjSjbNh+7Iff7Z3ZbmZG7dTym0D7/S7iyfrN+e0U8rD9qmylGNkL24cx0l1S52vdNCcAPWWBaV1EK3MbaArhEWJm9tvvz3PYQiCIMzNTMpMfA2nJ07TP91PwIFXJ5Kc27yLqWk1QC1sQCK5/PbebEgcfBkch2BzM/8+eARNc8CsZm9tRXpdwBzzbVKElBM3X9u1Aezp6dQ8ltMN6sK4s24bnPbMxNmVpADCJRESQMCG5DIWOV6MtzCzr0aJgw3lHTD+mLoxB2UpSHtXzGWKG8PN3AxWuR4WL/uWB78NgO13p1kvYWyANTamDOXAhRjErFJVvl2jJSlYpLj50z/903zHIQiCcAmz/DbXXMPD/SprszuRpMRx6Ni4i+PHJzGBiA4JvbATyOMHXDPxzp08luG38fW6k9Prt0Fpzbz3d9w1Br48doInjx8HxyFZUcVk1QWCwJbqzfCUKu8tNXPjOT/0eO6e88Rxr1NKXcDX+908XGV7zjIMqfJOcnkt7J7nZqhWPU7ntDJA58NvA2D5lLixjezFjdGndopNV5RiBJI0Gq7Xaw2uXfBYsufm2Wef5bA722Hr1q286lXZq39BEITLET94ECcex19VRXjDep7+8WcBeG18BksL4K/sIFp+ikncspRe4MyNN5l4x3aOjv0QAnBVw55F+W0ANG/Sbx7FjWcm7qtuwe9OJt4aqIDkhJpOW78t68cMR9MW4uR0bsSNnUhg9vejAeebValrvecvWcayzItJdR0tc+WFfkZlw4bq3DbwUfXc5jtz45jZ/7J4JamRyjCQpNNdm7QW1y54ZC1uzp49y7vf/W5+9rOfpZZXjo2NsW/fPh544AFaW9feGGdBEIrDTIbfxnQsfjGoPt4XT6BXdBD1B4hWlCpxY8JEDrMIi8GbTGxs2MTM8c+jAb+yeR9895/UgQXEjc8VN4F8Zm7ctQsHI1X4QkcA2DLlZhma9yxponM4EsLSwO9AYjo3nhv99Gk0x2EiWMJ4xQUANky4G7ZzLm7AMpaeubHGxrDH1XN4rtrArwVoHT6lbsxT5iYtbpaSufEG+LnlPsMtJa7hslTWXZPvf//7MQyDw4cPMzIywsjICIcPH8a2bd7//vfnI0ZBEK5QMv02+8/vZ8acIWwG2aQbRBrUIsqou7QQYNq7aBcA49w5zIEB8Pl4mCSaP4lmR9hb1QDnVVabjusu+xipNQbe6og84M24OValShEtZS3EvHUGWc638QgH/JiuJlruvBgPb3jf2YoqHM0kGojScu6YujFHfhtIixt7GVOhU23g0VL0oEZLpI6gY0OkEsoachHmJSwrc+OKm/6YEkYb465oXKMzbmAJmZsnnniCp556ataOp02bNvHZz36W66+/PqfBCYJw5eLoOjMvqI3aJddczVP9PwCgayaqXpW5f5gjZen+qPhU4TI3CTdrE17XzSMDLwJQF9qIv9edb9Ow/bJ+G8hYY2ACZgL8ZZc9ny2O45Bw1y6crleliK01W+GIu/Mqy8nEHkG/aqkOG8uf9OvhrV04W6l8SOtiXfhOPKpuzEEbuIftX7p3xSPVBh6LAkm6g+5an/oteemUArC9/U9m9tOs9T5VluqvUE6p7uQMaP6s9omtNrLO3LS1tWHM8UthWRbNzc05CUoQBCF+8OUMv82GVAv4NXH3lavrF/D5/ejuy7Rkjkoki4ovNZl4J6+MKe/NnvrF+20A/GWVgCducrujCcAcHMSemMD2+RloVMJva2w9DLmdXEswE4NqqfYyN8udF+MxdVRlaVI7pcK1asN2tCqnG7Ytv7usdDniJtUGrp6ELm9MUZ78NgC2f+niJlWWqjTB0WgyTajqXPbE55VM1uLmk5/8JL/927/Ns88+m/rcs88+y4c+9CH++q//OqfBCYJw5TLzi2cAVZIaTY5yeESVem5Nuvt7MsyQelC9WtZnCrd+wZtMnFi3ibhPrZF504bXZCVuoqXuMDwTLCN3LdWpGN2S1ECsAad0AIAtBMGxoKxxWaLBdDMg5jIn/XpMHVNlqeEmdfFeb7ttTY07cpoNsd2uI5ZRljK8TqkqFWtX3P3Z1W9dVmyXw/HEjZXdwEfHcVLdUudiGiVGhCCs6ZIULLIsVVVVNWuI3/T0NNdeey0Bd+mbaZoEAgF+/dd/XWbiCIKQE2YylmX+vP/nODjYiUa2W79UBzL+OBtBH8QtjHhhtoI7jpOaTPx0tBSfMQaOxmtibXD+CKAt6LcBCLviJmxCMjmZ8wGEnpn4aFktvrDK1myZdMVhlpvAL8YMePNilrYOIBPHttHOuoKhSQnUDXG38y2HZmIAO7D0DIiHV5YaqlXfe+eYEo7U5zNz4/WwZxe3NTKCE4/jaBrDFdCcdL//NdwpBYsUN/fee2+ewxAEQUjj6Dozzyu/Tek11/BUv+o+Kp9uwocD4Qo1XdXFCPgAa9ntvYvFOH0ae2ICLRTie4ZaRFkT6qS07zl1oGE7lFQv+DglZcpQHDIgqedD3KjMzalq9ciNpY1UD3pm4qWVpDxSXUdLXAeQidHfj9/Q0X0BzsTcnVIjyieSc3HjigRnOeImNeNmBtDoHFFt4cvdWn450pmb7AY+eiWpRGUJZiBJ27RbjhNxoxZZCoIgFIr4gQM4iQT+6mqC69bx5HNqKN76pGu4rVk/K+tghPyAgZUojLiJuyWp8JYtHJp4GSpgd93urEpSANEy9f2ETEjmYQCht3bhdL16rrZWb4X9rkl3iWZij1yKG2+FRV95JbZvjFgoRl2P23GWw04pWHoGxMOanMQaUdmvoSqIUEKVbUFJDZTVLXDvpeO4cWtZlqU8cTNaFQKSbDbd0u0aL0sta4FuIpFgYmJi1psgCMJyyWwBPzF+gtHkBRw7yNvL3OFxF73qNILuq/EljKZfCt5k4pnuTRhB1eVzc/e1WYubsNvpFTIhkcytGdpOJtF7TgFwxi31bClrhYmzoPnUjJtlkGqpzoG4SXriplI9H+vLWtH0SfCHc34R9spS2hKXlXpZm6nSKPGwRpOmsm/5zNoAOO48omzFje4O8BuoUPfbZo6pG9bwjBtYgriZnp7mrrvuor6+ntLSUqqqqma9CYKwSpk6D/e9Bn7yqWJHwnSG3+Ypd+WCNdPFtaWj6sBFFzwr6LXu5HEaXgbeZOJDsUZ8EWXWfFV5O1x4BeW32beoxwmXuusXHEgkcvviUD9xAiyLiVAJYzVqA/RWy8121W2B8PLazi1XJORCUOonXHFT7XZK+dVwQxq2gj+47MfPxBMJ2RpzPQx3MvE5t2W9CzcTlEe/DYDjelx9SyxLnS1z/UGGAaFyKKvPbYArjKzFzUc+8hEee+wxPv/5zxMOh/nSl77Exz/+cZqbm/nKV76SjxgFQSgEx/5TDZ878I2ihmHrOvEX9gPKb/NIz5PqhplNtFjuiPuadbPuY4bcllZjaResbHAMg4S7euaH/gSaZlMWqKXpnDLv0rg4vw1ApKw09X5iIrcDCBNHVEmqp6IBf1hN/N067g5vW+Lwvkxy0VLtkcrc1CtxusHrZMpxSQoyRcISMzeumbg/pr7/DYZrqM5jGziQmiStZS1ulPjur1A/p1bTVDul8jSPZ6WQtbj57ne/y9/+7d/yq7/6qwQCAa6//no+9rGP8Rd/8Rf8y7/8Sz5iFAShEAyqbAR64WbFzEXipZeU36amBrujhYPD+wHYU3cN/hHVcn1xSt1yxY1mLN0kuliSx47hJJP4yst5SlMp/911u9IlqcttAb+ISDSE7V5j4jmerpw2E1eA5lAfrac2ZSa+etmPbwXcUmAOnvOkm7kZqHd3Sk0OqxtybCaGtLjRlriJ3Ztx01epBNjGGbf7LE9rFzycoMpgZS1u3LLU+RhEzRBRx1nzJSlYgrgZGRmhu7sbgIqKCkZcY9VrX/tannzyydxGJwhC4UiJm9zPW8mGzJLUC+dewELHNip4x4ZuiHszbmZnbuxwBADNWNoFKxvibkkqsW4TTlRd6F7benVa3HQtflJ7JBjA8NYYTOd26adnJu6tU3/mt1Rvhn7VgbZcMzGA7YobbRldRwDm6Cj2mCo3Dtar52D9OVfE5kPcBJUQzra842F404lrlI9p/YTKjOTbc8MSylKO42D0p2fc1Bmukl7jnVKwBHHT3d1NT48y0G3evJl/+7d/A1RGx1ukKQjCKsNx6Dt/kFvamvl/I/kXCJdj5hdqjk3pNdfw8MknALCnN3JTnXvxr2iBUOms+zhh17tSCHHjmol7atvxu+JmT1kHXDhKNn4bAL9PS4mb5EzuMmaO45B0y1KnG5Xhd0ukTmXlQmVQt+lyd18UnrhZzrwYAN29ngyVlpMMadRHa4lNDACa8tzkmoDKgCxV3KTawKstcDTaDBNKahdctbFs3GnCviyqadaFCzjJZGrGTbtX7qsVcXMJ/+N//A9efFHtUfmjP/oj7rvvPiKRCL/3e7/HH/zBH+Q8QEEQCsBYL98MOwwEAvw4GgKrMF1HF6P8Nu4+qWuv5ckzqgW8q+wqKobV3525LsxORHXZ+AsQtjeZ+MlwCM2fIOSLsHHMffXeuEOtC8gCI6BeTRs5WmMA6qJmjY5ioTHQrLIiW73yUfMe8PmX/TW88g5L7DrySLoLM/ti6me4IVyrbqjuhnD5sh57LrRlZG7smRnMc8qcPVgFZWaJmvab55IULC1ur1NquiqC5dfYbLovEK6AslTWizN/7/d+L/X+zTffzJEjR3juuedYv349O3fmPoUoCEL+cQZe4oel6uIy7fOp0lS0suBxJF58ESeZxF9by1hDKcPGaRxH4+2bboCjH1WH1t98yf20kozt2nnEnp4meVyVTH5WpjIt22q2EzitOrrozH55sDfp14gvf9KvR8KdTNxfVotRqszEW8bUsMHlDu/zsL0yyTLFje4uzOyrVo+3znEvSzlclplJuiyV/X31M0os6CURpqMmGxNurPk2E7M0ceOZiUeqAoDBRm/GzUVl3bVI1uLmYjo6OujoWLubRQXhSuDQmSfpdQ2L05qmyhdFEDee36b0mqv5z5M/AcBOtHD7xkZ4zBUQG2+75H4+b7u2AVhmqrMk1yQOHQLbxqyuZbx6iCBwTdOr4Kf3qwOLnG+TiRnI7Y4myDATV8VAG6U6Uk3DgOupyoGZGDIMrks05nokT7qZmzqVdtvg7WnKQ6cUgC+o/FlLEjeumXi4JgpMst50U4V5bgMH0IJqxlM2ZSmvDbyvXMXZbpjoJU2ELirrrkUWXZZ67LHH2Lp165yD+sbHx9m2bRs/+clPchqcIAiF4eFz6UW4Mz4fTo4Hyi2WmWfSw/u+e+xxAGr9O2g49xO1Ibp245yvOv1lqhQUMAAzf/ulvMnEfY1d+Etcv015BwwfI1u/jYeZmvSbu63gSW8yca26IG6p2oh27oi6MQdmYsjMgOQmc9PfoETNhlGvxJenSkBYPSf+JZSlvIWZA5XqZ7Zddzvc8m0mJi3K/FmIMq9T6myZ+t1qNQ3M6rWftYEsMjf33nsvH/jAB6ioqLjktlgsxm/+5m/yN3/zN1x/ffZpWUEQCsv000+nsiQ4Dr4Xh3inBrYGT2/xoSdGCRc4JjuZJL5/PwDRa67m6JOfAQ1e3/FaeOW76tAcWRuAoCtugiZgxPPi1YC0mfiX0Wp8oRfQ0NjptXA37VxStssMqteYdg73Yk0dUkKmt0G9Yt8aqAQciLVBeUNuvognbpZRCrSTydQFeKA+gYaP7guqLTxf4sYXcv1ZS8rcqAF+Z2LqZ7UtUZg2cABfeAnixs3cnItphC0/MdshWbcxH+GtOBYtbl588UX+8i//ct7bb7nlFv76r/86J0EJgpA/rMlJzvzWB3GS6UxBpmTY1msx/dbhgoub+Isv4ug6/rpa9gcnsbQpHCvMHbuugy//tjq06U1z3jdaHgPUAkozOUkgT9NXvcnEL1SpV/3dsfWUn3G3lC/BbwPpSb92jlZHOIaB2XMSDRhqVx6LrV5WqGX5w/tShLzyztLLUvqpU+A4TIXDjJeYNIZqiNqnobQ+dyLsIvyh7EWCh1eWOlM5A/jUtN/S+kUPbVwOvpDqCFySuKnUqHfbwIP1a99MDFmUpYaGhggG5x+DHQgEOH/+fE6CEgQhf0w9+SROMkmgvp6q976Xk69r5Qev0jjhZqurpmA6MVrwuLySVOnV1/D1g2q5Y9TexLr4EUiMQaQSWq+Z877RCpW5CRuQSIzlJT5zZCR1sehpVaLhVQ17st4ndTGW13WUo9URyZ4eNNNkJhBmsNpduzA6oG7MkZkYSIubZXhuvIWZZ2OloGlsCLgZtzz5bQB8EeU3WYq48WbcDFZpBK0gVbZdEL8NgN8dd+BfZBXQse3UjJvzMWh3J0n7aq+MzM2ixU1LSwsHDx6c9/aXXnqJpqamnAQlCEL+mPrRjwCIvf3t1H30bj75unG+fIufwW0q+xFNwkwxxE3GssxfnnsGgKtqr4WjP1AHNtwyr1G4tKISgIgOiWRuJ/16JA6orM1ITTPJSiVydpd3wvBxtYiyfe+SHteb9IuRI3Hjdkr1VNbgaDaxUIymPreNPkd+GwBtCWWSi/HWLpytUs/BZtsVSnkUN4GoEjeBLOO2dR1jQInEwSqo0YNoUBC/DYA/nF05zTx/HscwsH0aI+Ww2XR9dFfAjBvIQty8+c1v5k/+5E9IJC5tV4zH4/zpn/4pb33rW3ManCAIucXWdaaeUJPEy2++iWeHnmXYihOzLJJ6FwAlOkzlSSDMG1cySdydn5XYsY0J5xgA797xRnjlYXVo09x+G4BIhVoCGTYgnsztAkoPbzLxgfL0ssw9cde83Lg0vw2A7S39zNHqiOnDym9zuka90t8a60abGgLND027cvI1APxuBiSwDE3mLczsr3NXGUy5HpY8tYEDBJaYuTHOngXHwYwGmSiBDk+MFihz44myxcbtZRknK0PYPo1OU0cnqHxXVwCL9tx87GMf41vf+hYbN27krrvuYtMmNUjryJEj3HfffViWxUc/+tG8BSoIwvKZeeYZ7OlpAnV1RHbs4OFn/g8AN8/EOR5ezxvYT8iE4cnCZm7iL+zH0XUCdXV89cIraJqFz6rhhlhQdSL5AnPOt/GIlJcyA0QMmInnR5jFDypxc7imFE2zqI3W0tLvtlcvsSQFYKdaqnOz9HP85UMA9DUpj8UWb8N243ZwzbS5wJdlJmEuku504v56t1Pq/Cl1Q746pYCgNzbABGxr0QMN9dPKbzNeGwVthm2GmwkpUOYm4G5xDyzy18Qzap+rVB+3GSYXQi0052CA42pg0eKmoaGBp556ig9+8IPcfffdOI5KH2qaxq233sp9991HQ0N+DGCCIOSGyUeUl6XspjdgYvHIqUcAuG1qmid3XgffURvBp8cLK24yS1KP9qqpxOvKrkI76mZtOvZBJDbv/UsqyvDm+8a9V/85xHGclJn4eIu6uuyp34P20uPqwBLNxAC2t/QzR+LGOn4cP9DfrLJKW71sew5LUgCBiHuxXWLmxrHt1OqF/joLzfHTnpiCYImaTpwnglHl6wlaYBkJ/OHFzXxJt4Grj3earoguUOYmmFFOsy0Dn39+DyykMzdnywzAR7tpcK6sg+Z8B7pCyGrSVUdHB9///vcZHR3l+PHjOI7Dhg0bqKrKbty4IAiFx7FtJh97DIDym27m5/0/Z1wfp8a02Bj3U3bDa9DvgZCZ+w3VC+GJm+Crr6Zv6u/QQvCW9TfCS19UBzbO3SXlUVKRvkBNT+Re3Bh9fWqdgc9Pb4sSfrsrumHkH5TfpmNpfhsAxx3O5jeWL27M0VH8w6qxo6dRTSbeOqzal3NqJgYC7lTobL0rHkb/AE4igeX3c64SaompVQYN23OyHmI+wiVKJAcsMIyZRYsb3TUTnypXYrHLMKCsMet1G0slnCHKDH2a8AJlUD3VBg4hx0etZXOyvCvfYa4Yst4tBVBVVcXVV1/NNddcI8JGEFYJ8RdfxLpwAV9ZGaXXXsPDp1RW5JbpGc6G1rG9tZJkSP1JSE7lbs/RQtiJRMpv81QshhY6D46Pd6zbA95ag8v4bQCioSC6+1ItPpl7z41nJj4Za8IpU+n+PUm3dbtp12WzSgsS8ubFLH/pp2cmHiyNMRO2KA+W0drvNoLkOnPjiQQTNRU6S/Qe5bcZrinD9ml0224monF7rkKck3CZitvvgJ5c/CZ2b2HmmUoTzVuYWaCsDUC4JD1jzkgsHLdxNi1uGk0NDTBi+cuIrTSWJG4EQVh9eF1SZa97Hbrf4bFelcV50/Q0oRZlNPXEjTlTOHET378fxzAI1Nfz9THlF6kJbKCi9xlwLKjdtGCZwufT0N1rY3xq8ResRcfolqReqa5DC8wQ8UfYfE7tmFqO3wYAb6N5LsSNO5n4VLUqGW0pa0cz4xCOQU1uu2RCZZWAyiTYS5gK7S3MPOvulNpquOWzPPptAKKlZan3jZnFZyg9cTNYpREzgirLVCC/DVwkbuILTxD3ylLnKzXaDXfOUY5/B1YyIm4E4QrAcZyU36b8jTfz076fMmVMUWVq7ErqdG57DQB6SF1ozETuVgEshFeSilx9NYfGngPgta3XwdGFu6Qy8bZr6zPTOY/Rm0x8vFEpqG212wguY1nmLLzunRx0gie8nVJ1qqyzRVPt2rRcBb7c/rkPl1YCaiq0rme/rsNbu9Bbpb7xHdND6oY8dkoBhKJpU3VyZnFZPscwUjNjBqug1SshFjBzEypJl88Wytw4lpVqWz8fg3WGerESbNiUvwBXGCJuBOEKQD95Ev30abRgkNLrr+fhHiUcbpuaxgdE2narc2ElbpxEbqblLgZvDUR/1xaciCqr/NfNN8AxZXZeyG/jYQTzk3VyTJOE24F0olVlKPbE1sPIyWXNt/HwRdyuoxyIG68sdaZRZUG2eksoc+y3AYi65Z2gCYksyjse3gC/3loV45aZEfV81m/NXZBzEAqHUu8b8cXFbQwMgGlihvyMlcFmVywUMnMTCofwXFnGzOXjNoeGwDSx/BojZWph5ohTRkV1fiZ3r0RE3AjCFcDko6okVbL3NSTDPh4/8zgAvzI9ge0LqtIPYLp/+J1kbgbKLYQdjxN/UWVFHgpaaP4EQUrZEZ9SU4mj1dA291TiizGC3nbtS2dxLYfkiZM48TgzgTBDTWri7x5P+zXthsil+/aywe8aRZczLwbUq/XkMTUfqLdFlVu2nFfZkVxtAs+kpEyVd3yAscgMSCbeAL++WgefHaDZtNRi1GA0l2FeQjjox3D9yuYiyjuQNhOP1URwNI3thisu6gqXCQkF/Fhe3InLx+2VpEYrAzg+jVbD5KTTTE1p6LL3W0uIuBGEK4BJ129TftPNPHn2SRJWgrBeyjZdx1e/GQLqj54ZURcWLZmbgXILEd+/HwyDQEMDDydUSWV79avxH/2hOrDhlkV3zphBdc7OcUkt4ZakjlU1QXQYgF1eB9Jy/TaAvyQ34kY/3YuTTJLwBzlXbVISiNJx3vUF5XKnlEsomhYh+vRYVvc1R0exRlRXW381VCXD6mKUx8nEHiG/D9P9lUpOL1LcuDul+itV7qTTMJmJ1C95cONSCGbEbSQun530OqUGy9X/43bT4KTdRGWJiBtBENYIxtAQiZdeAk2j/A2v5wc9ap3B5qlyNT4+w8BpueLGp+dm5spCeCWpxPbdJENqsu5bNtyYtd8GwHTXGDg53K4NED+guo2O1alMRXesm1ivWg+xbL8NECxJl3ewly4qPTPx6aoKHJ/G5pJm9Qe+qhNKa5cd58WES9PiJpmFMRdIzbeZriolGdJY75mp82wmBggF0iIhsdiylGsmPlWhhHOXYRCvLOyOplmibIGMk9cpNRRz8KPRaFr0BVoIBa6cS/6V850KwhXKlDvbJrprF/FYhCfP/gSAW6ZdEZDxatmOuqWG3OqDefGWZT5f1YIvqrIhryttUfuafEFYd9OiH8t0zdBOjhZQesRfcs3EzarstadyI4z2uH6b1yz78YPu0s+gCZhLzzp5ZuLTtcr0vBX3VXqOW8A9woF0eUefzs5z4/ltButUjLu9Mk8BMjeZGRA9vjh/lleWGqqEiOWnyraxawprzg0GtFRZSo9fvjsttQ08ptFsaQSA4XB7niNcWYi4EYQ1jue3Kb/5Jn585seYjoGVrOctmtudknlBcU2iAd0BZ/mtyZfDnpkh7s6PeTA4g6Y51EfaaDrzrDrQeV1WfhYr5PaC52gBJagZPMmjyqR7ql35Snbb7kCd5j3L9tsAhMuqASVujCV0HXl4ZuLeBvX9b512syl5MBMDhIM+DPepSGTpuUm6nVKnK5V56VVJNXCwEJmboD8tEhYq73ik28ChyQANCDRty1OEcxPw+bDcK7a+QNypNvAYtOnKgzZe2pnP8FYcIm4EYQ1jTUww/YwqoZTffDP/fuw/APBPbKHGUK2iNKSHpvnKVBYhYGjLyiIsBs9v49TVc6xCeRpe3359elHmIrukPCxvGF4OS2qJw4fBshgJlzFaNwjAnjFXFObAbwNQUq7ETdjIbqjcxSTdzM2ZZvUYW4c8v01+xE1mmSSRbebGnXFzokpdpDcYBlS0QGlNTmOcC03LFDcLz+dxLAvjjMoqDlZpbDDUfUpaCytuZomy5AKZm9ReKTXjxnI0jArJ3AiCsEaYeuJJME1C69cx3Rjjl0NK6NwYaFEHKttnmSL9sToAgjqg535eTCbTbkmqr3MrgTLV5fO6hl3Q+7Q6kIXfBsAOqTUGWg7WGHh4k4mP1dbh+CyqI9W0pzJLy/fbAJSWqexP2IR4cmxJj2FNTqZerfc2mAS1EJ2TF1RpL0+lnnCGdyWZ5Wwhb2FmXw2ErCA1ll2QkpRHuuto4c46c3AQxzCw/BoXKmCL2wYebsxvy/rFaJqWytyYlxFljmliDCkBfj6m2sDPOnVUlJXNe5+1iIgbQVjDZHZJPXr6UWwsrEQzv9Y0t4EzGlOvnMM6OMncrzHIxBve9+PSGL7QGH4tyKvHR9VU4rotygibBU5YDazLZeZm2m1TP96gskK7KjeijZ4GzZ8Tvw1AuCxjqFyWXUep+7kt4KNlpUxHNToDNfhBDcQLRpYf5BxomobllqXM+OLFjZ1MpjILfTUaTUm/a2wvpLhxxwYskAGBdElqtDqE49PoMgyGtNqclCSzxRNllj5/VtUYHALLwghojJWpbeAnnSaqrqA2cCiyuHnyySd529veRnNzM5qm8dBDDy14n8cff5yrrrqKcDjM+vXruf/++/MepyCsRuxkkuknnwSg/KY38G+HvweANr2bnQH1B/viC0pppRI30STE47lfQJmKLcNv82StevW8u243JSeUGMs2awNADofheUzsV+LmdJvyhuzRXCHSvAfC5Tn5GpGyjK6jqaVtY/dKUqdqlJDZ7rhXwTyVpDxMVyQsZHDNRD91GmwboyTEeClsKtDahUxSIiG5cOlV71UlqbOVqpOtyzDoD3bmK7TLYrvPt3GZuD3heCGm4WiaagO/wmbcQJHFzfT0NLt27eK+++5b1Pmenh7e8pa38PrXv579+/fzu7/7u7z//e/nhz/8YZ4jFYTVx8zPf449M0OgoYHJ7gaOjL8AwM3ttxI87y5TvFjcVClxE9FhOj6cv9heeAFMk0R1HcMNqpxyfcteOKZWRGTrtwFwomo8fcDIjRHaGhvD16cubKe61HOxZ8J9TnLktwGIRiOpckNycmxJj+F1Sp2sVVmrnfH8mok90iJh8YMTvYWZF+rDoGm8Sh9TNxQhc2PpC7cFejNu+mIWPkdlQi6UFGe7tu3+ntj6/M+3V54cqnDQgBbTpMdppLo0XIAIVw6BYn7xN73pTbzpTYv/I/aFL3yBrq4uPvWpTwGwZcsWfvrTn/LpT3+aW2+9NV9hCsKqJNUlddMb+M7xhwEHa6ad33rtOviXw+rQRReUsqoYFlDiipu6PMXmtYAfrOvGX6oyONdpJZAch5KaJV2U/e5iwUCONkfED74MQH9pJWPRKYK+IFvPqu3lufLbAESCfvQARHWIT2Y3L8YjecQ1EzcpP8iOC6fUDXkY3peJGdAABzMLceMtzDxdpTIhW4wEdqgcX2VHPkKcEy8DYhsLixsjY2Fmg+0nCEyWb8hnePOiRJmDpc//S57ZKVVvQ9iBE04zbygNFijKlcGq8tw8/fTT3HzzzbM+d+utt/L000/Pe59kMsnExMSsN0FY6ziWxaQ736bsppt48IgqSdX5rmXL8H+CbULDDmUozqCkSrWCR5IwPbO0Esli8Pw2P60sQfPrVIWr2dinxAQbbl30VOJM/O4wvFyJm8RB10xcr0TTtsr1hMZ6c+q3AYgEfJjuy8z4VPbixrHtVLt6b6OJ5vjpTkxDtGrBberLxcuA2Iso73h4CzNPxJQgWmcYaI07cr7Y83LYPhU3xsK/LN6Mm8Eq6Ha9Lnp1YQf4eaQzN/OLstSMm0qNdvfnctJuor48P96rlcqqEjeDg4M0NDTM+lxDQwMTExPE56n53nPPPcRisdRbW1tbIUIVrnSMBMTzJw4WIv7iS1jDw/jKyxnf0spA8giOo/He7W+D/V9Th3a/+5L7lVUrgeADJsbP5yU2e3qa+EFVFnu5S/2R3teyF98SphJnEijPGIZnLd94M7VfZWmON6k/k3v8roG05SoI567zJODPnBeT/Zwbo68Pe2YGK+BnoBoarHKCoPw2mpazOOfCdjexX+5iezFJtyx1thbKjCAVtoOW503gF2P51c/UXkDcOI6TMeNGY72uMmNaAbeBZ7KYjJPepzw352PQZhpMO2HOaVWsq5NuqTXF3Xffzfj4eOrtjDuvQBDyhuPAP7wR7t0FieJkCid/pLwrZTfcwJcOqKwNiS7e2xmE/ufBF4Ad/+2S+5WWRTHdvwpTI/nx3My8sB9Mk9HyGkYa1R/ifeXdMHIC/CFY94YlPW64QhXRQgY4xuKGs82H4zjEX1KZm1PtSnDs9ma55NBv42G6IsHIsqUa0mbi8/XlWH6NLd4qgzwsy7yYxYoED8e2U5mb/mqNTq+zrYB+G0iLhIUGPprnzuMkEtg+uBCDTsPgrFNLZWVVAaK8FC9ux7xcWaofgPMxjTbDpMdporWqhGgo+2zoamZViZvGxkaG3P59j6GhISoqKohmLHHLJBwOU1FRMetNEPLKaA8MvqT8I6OnCv7lHcdh8lElbspvvpmHT6uMyM6qGyk99G/q0IZboOxSR00w4CfpNlXEJ8byEt+MO1Tw2epWfBH1h3jfuNuZ1fnaJXchRWNqf1LYAGOZbezm0BCMDGNpPnpaVQZud/+hdIw5xsvcGItcB5CJZybuqVUXvqsTY+qG1vz6bSAtbriMByQTc2BAiQW/j6Eq2Jlau1DYzI3jxu0Yl9/lZbhm4pHKAJZfo0s3OWq3UltWHHOuV05z5hFljq6r313gXCW0GQYnnSbWX2FZG1hl4mbv3r38yJ3b4fHII4+wd+/eIkUkCHNw6mdMahojPh8klmYQXQ768eMYp3vRQiF6NjYx5ZzCcXzc9epfgRf/VR3a/Z757x9SfxYSk0uflns5PL/NwdYSNM1hU9Umak+qlvWldEl5lMTUq+mwAXHvAr9EvH1Spyqr0IManaUtVI/2qoxXW+78Nh6puStZtFR7eGsXjtcqYfSqaTVJOd9mYgA74ImExZUBvbULI3VhbJ/GNiOOqQWgrrBlHstbIGlePm6vJNUXUyKo0zA46rRSVyxx44myeeI2BgfBttEDMF4CbaaacbO+XsRNQZmammL//v3s378fUK3e+/fvp9f9hbr77ru54447Uud/67d+i5MnT/KRj3yEI0eO8Ld/+7f827/9G7/3e79XjPAFYU6Mnid5b3Mjb21tZnJqsOBf3xvcV7p3L/cd/D4AJdZm9tknYWoQotXKtDsPSVfcLKVEshCZfpvDnepCvq9+D/T+XB1Yot8GoNwtFYT15YsbbzLx8QZlwtwVUisSaM6t38bDdC+22bRUe6Rm3NQbaI6PDboBNeuVoTjP2IsUCR76SdUp1et2Sq3XdUZKuiBQ2Bksjt8bUXz5zE2mmbjc0ai2bY7ZrdSWF2dmTMoIPU/c6YWZgKbKUiftJjbU52Ym02qiqOLm2WefZc+ePezZsweAD3/4w+zZs4f/9b/+FwADAwMpoQPQ1dXFf/zHf/DII4+wa9cuPvWpT/GlL31J2sCFlYPj8PDg0/SEgkz6fZyd7F34PjnGawEvu+kmfnFedUy9ofUW2P8v6sDO/3bZi4nu1ubNmeyzCAsx8/zzYFkMlVQx0qSem72mX00lrt92SfdWNkTK1ZwbHxCfuLCsOOMHlAA70ewO7/MyKnkoSQFYnjE3md06dntmJpVdOF2vUZ2MpM3EBcD2q3qatkB5x8PL3PRUGWgOdBsmU5Vb8hbffDgB9TuuWZefZp1pJu40TDSgN9BOSag4U1S8ctrC4kajynYodxxOOk2suwIzN0Wdc3PjjTfiXGbz8FzTh2+88UZeeOGFPEYlCEvHGT3Fl0MGoMTD+Ex+Oo7mwxgYIHHwIGgajzdWYcUHcBw/H7rqJvjCH6lDlylJARihAJDESeR+caZXknqxoQVf8AgRf4Sr+t2ZO8vI2gCUlJfi5T0Sy+j0cmw7lbk50aHKinsG3SWU+RI3QbfckEXXEUDy+HFwHBKxKBOlBvvG3QxKnof3eTgBV9yYi1t5oZ9UnVL9NRp1pp+I42DWF9ZMDOnMjW+BuI2MbeBd7qqG8dL8ttdfDk/caNbc4kY/m9Ep5f4u9UhZShCEpWBNTWONj2ONj/PzZ/6RfitIadzBZztMLLM8ki3ebJvonj38w+kfA9AY3E3TqUfB0tUG8AXMm2ZYDftyEjncY+Ay7Yqbl1vV13hVw1WET6g4l+O3AYhGQ+juy7XpiaW34es9PdjT0yT9AfrqTcoDZXR6fpsczrfJxHIvts4ijbkenpm4v0F5QPYZrjG7AH4bADvoipsFMiAeSVfc9NVobHAvvoGWXfkJ7jI4bsaJy8R9cRt4l2HSa9dRVl68ppRU5mYecZPqlKrUaDNNhpxKSssriUWvrAF+UOTMjSCsdi78/d9z/lN/k/q4Eviy+/5QJZy9s7CZmynXb+O//gZ6El/HF4J3bH4rPP+36sDu9yw4+8QMu9u1k7kVN9bUNAl36u+RbmVWvi7SpLrKSuuWfUEucSf9hkyYWUanl7fz6nhtBbZvgt3RenwcUvGFSpcV43xYQdcDomf3nHtm4qPVKst2VXIKAhElYguBm7lZKAMCap2FNazGC/TVwC3TqsW+vH133sKbD2cRcVujo9hTUzia6jzqHDY46qwrWqcUgO2K4PkyZZmemz2GyUm75YrM2oBkbgRhydiJBCNf+od5b28YA3Mwf8snL8YaH2f6F78E4JsVpfhCF9CcIP/fpnXQ99y8s20ueRx3rIIvuTgfxWKJP/8cWBYDJVWMNqk/wvvGXW/MhluXPaE24PdhuC9Q45NLbwVPuPNtjjeqC8lVuvs85KkkBWAHsvOueHhm4uO1STRHY6OhQ9Oughl0naD6OosRN8ke5bcZjwVJhlTmptepo7q2Pq8xzklQ/aL4rPltEfpp1QY+XKFhBNQ28GNOK7XlRdzR5L+8V8hIlaU02kzjiu2UAhE3grBkJn7wMNb4OIHmJja99CL//P/exLv+0M8/3qlzrkr98dQnlzdMLhumnnwSTJPQ+vV8bUKJnE0V11Ly8rfVgfVvnHO2zcXYEZWd8Ou5WUDp4fltDjTVg2ZQX1JP94mfqBuX6bfxMILuluqZpbexe5mbk23qZ7f7/Cl1Qx7FjeOWdxbq3pl1H8ch4a1dqNOo1UOEHQpmJgYgJW4W/l3x/DZnqtWFeb1hcMLXjd93+UxiPnAWIW48v81AJamFmUftVrpr85O9WwyXy9zYuo557hzgzbhRbeAbRNwIgpANo19Tawyq3vkuzhkj/GDgJ9g+jdeMVzAVUn887Zncm3Lnw+uSGn/VPqaDzwHwvh1vW9Rsm0ycUtU26s/Rdm2PKXdZ5qE29WfnuurtaKOn1FTi7tfn5GsY3qTf6aW1sdu6TvLIEQBOtCbw4Wf7yFnwBaHt2pzEOOfX9USCsTjvCqhBg/b4OLZP42wtbPE6rQowvC9FSGUxfIuopiUzxE3Q0Wg3TPqj6/MZ3bxobmbr8pkbJW6GqqDFsgkBR51WtjQVcRCs1+VlXxq32a/8NokgTEbT4uZK7JQCETeCsCTiBw6QOHAALRik8r/+Kl899FVMbK6JJzif3I5Rqko7TjxHWxwXwE4mmfqJyoI8UB7FFxwjQJSbLdKzbTYuLjviK6sEIJBd485lsaamSLysJvwe3TAGwD5PPHW9LmezY0y368hawjA8UGUexzCYiUY4VwntWhURx8mr3wbACS2+vOPhlaRGG0owAxqv0V0TdQEzN1pQiRv/ZUSCh7d2oa9Go8NShs+R8uLsaNLczI3/MhmnWWZiPYntaJxwmtnUWLyZMSmv0BzPt3427bcpcRyqbVvKUoIgZMfo1x8AoPy224iXh/jGsW8A8L7xCUo23oBdpv4AaonFX6yWw/RTT+HMzOBraOC7ftVa/ZrG1xE58KA6sOMdi/Zh+MtrAAjpgJ2b+OPPPYdmW/SXVnGh9jwaGq/xWsAXKboWg+GJmyW2sXuTiU80lICmscdySyZ5LEkBqQyIP4vMTeKIEjcna1Upa4eewIjULGtWULZoYTXk8HIiwSPpDvDrq4GNCZVZm6nemr/gLocrynyXqQLqGW3gnYbBGaeOsrKKohqK8StRps0hbjwz8fmYyooZjp/JcHPRpikXGxE3gpAl1tgYE//xHwBUvfvdfOPoN5g2plmn6+yd0XnTm2/HKq8EIJDIbWlnPrypxGe2vApfhfKMvHv9G+CIinOuDeDzEapqUP/qwDIXUHpM/VztkzrYpKbmbqvaROWZZ9WNG3M3hNPrOlrqjJ6EO7zvlUZVZ9k76U6YzrO40UJKJCzGu+LhZW6O1uhoDmzSDcym/G8Cz8QfKVH/LmAVsnUd44wyu/bVamzUk4w6ZUSqCyfEMvF5YnKO8o6H4RqK1QA/wy1JFXnS72UyN2lxo9Yu9DoNdDXE0Ar4+7CSEHEjCFky9q1v4ySThDdvJrBzG189/FUA3jc+yfnyrdTV1EKlMu4GExoY2Y/UzwbHsph6TM2KeaA8ii8wScRXxt7hs2Al1eTfpt2LfrxoZSMAER3MHG01P/8ztV7hlW71R3lvqAYcW7Us5zDTkBI3Wc6L8fDMxMdaVWbh6vGBvPttAIioMqY/i07wxFElbnrroE4PEHUcQp353wSeiS+sxE1gAXGjnzoFtk0i7GOsFDboBi/bHTTEIvkPcg60kPt8zxO3N7cK1EiHLsPkmNPK5iKWpAC04PxeIa9T6lylRqvrt7kSF2Z6iLgRhCxwbJvRB1RJquo97+bh0w9zbuYcZaaft0xNU7NNGWMD1UogBJPkfXlmfP9+rJER7NIynmpUr95u6XwjwUwjcRav3ipqlTCLJmEmvvw5PdbkJP5jbpZhg2qNv27UfdwclqQATK/rKMt5MaB8QV5Hz4lmKDVKqLVsNe03VJLLMC/BF1Z+nsAiMzd2MonecwqAUw0a23UloP1thRU3/ogX9+XPeX6bszUOaBrrDYNDTicNFcURN/7w5cWN3nsGgJEySIY0OnWDo3YrmxuLaCYGtIDb5TVHxikzc9NuGpx0mtnQIOJGEIRFMP2zpzB6e/GVlVHxlrfw5YP3A/Cr4wlCQHj9DQCU1DQBEI2DOZPfWTdel9Sx7p34KpVp9621O6DvWdD8apdUFlRUKc9NSRKmZ5a3owlg5rnn0BybvrJKhiqmKQ2UsrNHlanYtLypxBdju11q2hLETeLgy+A4TFaXMlGqsdVw/zzm228D+KKLEwke+okTYFkkSoOMlsHV+iQ2mlrsWUCCUZXJWDBz06NE49kaKHU0mkyLQ3YHdUWaGeN3M07zZcr0Xq8kBeW2Q41tq8xNkctSaQP3pbfp/a6huFItzDxxBXdKgYgbQciK0a9/HYDYf/kvPDP2IsfHjoEV5P+ZGsTR/KnyRaxeiZvyOExO9ectHsdxUn6bh6pK0AIzVISquPqMMsay4RYoy25IWmlVDICADdMT55Yd44w7WPDlZnVhuKaim6A+CaX1Ob8Y20sw5nrED7hm4iYlkF6XcEVpAcSNv0Q9N8FFipuEO5m4t14DTWNLUmcw1A6RwmYWglH19RaKO3kivXZhvW6gAYecjqJlbgJexmkeUebNuBmq0ujSdWxHo0cr/rRfX6osNfvzdiKBdV69EDkXg3bDpMdulLKUIAgLY/T1MfX44wBUvftdfOnAPwLQNt5Khe2gNe1KXVxiDUpQlCVgYnoobzEljx3D6O3FDgTZv1G1Ar+56xYCXpfUImfbZFJamX51OjW8/Ni9fVKHOpUPZp/uCo+Ntyx7KvHFOBHXmKtnL268ycQv1yu/zb6ZYTWDp/Wa3AU4D6ESV1AuUtykJhPXqO3am3Wdc+UFWrmQQahsceImvTAT1icTJJ0gp7QWakoLM0n5YvwLiBtvxo1nJu516mmtqyLszpkpGqG5W+8Nd8bNTAj0sEO9ZdEfaKOlMlrwEFcKIm4EYZGM/uu/gW1Tsvc19FTq/HLoGRzHx3s8v3DGK/yKhloAyuIwNjWYt5i8XVIvN23ErFbD594UrIfJgaxm22RSFg2RcK85k6PL89xYk5MkD6lS2WHXb7OvT+2XWu6izLlwPKPoUjI3B1Wn1NFmm4AVYL1hqJkxefbbAARLK9W/ixU3rpn4dL1Gk+Wn1HGYqtuTp+jmJ1xaDagsn5Gce7aQY9up1QtnazQ2GDpHnDbqY6X4ijCdGCAYVRmNecWN1wZeCZ2umXhTkf02AIF5ylJpMzG0mBaTTinVdY1Fe35XAiJuBGER2LrO2DfULJuqd7+bv9uvsjbmxA7+S+CUOtR5fep8pStu/A6Mnu/LW1ye3+axlko0f5K6aD27Tzylbsxitk0m4YAvJW6mx5bnF5p59lmwbfrKKxitsGmNNtA+0gv+MKzLzVTiTFLelSybpYxz5zAHBnB8GicboTMRUH8cC1CSAgiXqRb5kKnEwEKkylJ1GtvdmTFaawHXLriE3ZEHAMnpsTnPmIODOPE4lk9dfNfrBofsDrY3xwoS41yE3TJgwJ77+Z69DVy1gRe7UwpA87xCF4U8a8aNadLjNLG+vvjxFhPZCi4Ii2Dyh/+JNTJCoKGB6Wu38aOH/gCAndo+Sqe/C5oP2l+TOl9SFk1tqB4fzs9mcKO/n8TLL2NrGs9vUS3bt7XdiO/Rz6oDSyhJAWiahh7SAIfkMrZrQ4bfpqUEmGFfoFLd0PW6vEz81UrcV+RZzIsBSLhZm7HGMpKhONdNuR1uBRI3kZg7ONEEPTFBuKRy3rPmhQtYw8M4Gpypg/8yEWfGCVPWtqMgsWZSWlGbet+YHoXqpkvOJN1OqYEqsPwaG3SD7zqd7GjNv7ixLAvDuFTphkti2E0q1qnxMYLRdHbOmp7BCAahqQma/LSNBnm8dAs3N0RIJPI71mEhImU12E1N+MPMimVmdBS7qYnpTo1NgQRnSjewo6mk6PEuhVAohC8H5WoRN4KwCLw9UpX/7R187sBXcLAxp9fxiU0heAq1iTnDzKlpGjMRH6Epm5nR/HRLTf7oMQAO13QwU38cDXiz6c+YbbNryY+th3yAhT41tawYvWWZL3erksW+MdegnKNFmRfjd70rwSwzN958myMNKt9/fXIMxx9Ca8u/3wagtDJt+k5Mnr+suEm4fpvzNQH0IGzRdQ44XXRXF/6VeqS0goSmFkvqU2NznvH8Nn01GtW2WgtwyO7g1jyKG8dxGBwcZGxs7phKozGsj30UgN6+fnz+tJfGMQysj30UW4MPlYNlmrzRqaLGmaCnZ+kLWXNBy4ZrsD62lRDQ45b6AMxdu3A2bWJXBEIBG9OO0lpizDqzWvD5fHR1dREKLc+PJeJGEBYgcfgw8RdegECA4O1v5juPqtbq9aG3sGnKbWme4xV+IuKHKRt9Ij9/EL0uqac7atB8Z2kta2XbK+pz2c62uRg9qMSNOb20HU0A1sQEicNqxcKR7il8+LnmjBIRuZ5v4xEsW5q48czEB+sTaI6fHUkdrX0fBAtjyIyWVeJVGpKTI9Aw/9mkW5I6UWsBfjbrOv/qbODqIphzw0E/kwEIG5CcGZvzjLd2ob8GNiTVjqYjTntey1KesKmvr6ekpOSSKb1xXU99LtDeSiCU7tqyJicxAD0IkRh0GCa21sq6uvKiT/udHB8hGLqAA0S7ulKf1/1+7ESC4RhUahZjdjW1NbWEg0U2QGeJbdv09/czMDBAe3v7sp5vETeCsACpPVJvvJkvnvkhFgmsRAP/97XXoH3zj9Shrbdfcr9EJAgY2FNLFwjzYY2NMfNLVfJ5bqvKrtzWcA3agXuXNNvmYoxwADCwl5HWnnn2ObBt+mPljJbH2RZupNw5BY07INa6rPjmI1jmlneyEDeO46TMxMebNJqSAUocp2AlKYCSkghjPuUBSUwOX/as1ynVW6fRamlU2A69JVuKYh4NBXwYfiVu9Jm5p1mnB/ipNvAep5Ga6iqq8iTGLMtKCZuampq5D/kC2D4fGhAIBghG0uLGmJzE5/NhBCEacNCcENFQCdFo8TuPkskIIbdkEw6H0xd/y8bx+bDDGmW2zYgTpbysBN8qXL1QV1dHf38/pmkSdBecLgUxFAvCZbAmJxn/7ncBqHjXf+NfX1HlqU3Rt7LtxJfANmHdG9QU24vQS1RngzOTw/XaLlNPPAGWRU9FAxdaTgFw26R7cVnCbJuLMd1heE5i6bF7JakDLeoidoO38ToPXVIe4ZjygIQMcMzFxW709mKPj2MFffTWw7VJtxRXQHETDvrQveHK85R3PBJHVebmdD1sdc3Ew5WF99sAhAN+TDfuxNTc4ibZ47WBa6w3dA47HexoyV/WxvPYlJTM3+Xm82k47nX/YkOxo6vfGyMAYcchSZDICsmAaJleFEf5yhzLwrFUm53pcwg6DvjDq1LYAKlylGUtMBlyAUTcCMJlGP/2QzjxOOEN6/knetAZxTYq+KvXvAH2K6HDDX80530N94+rFs9+Wu5CeF1Sz3TWomkW3bFuNh76gbpxiUbiTKywO+Y9sbQdTQDTv1Alu0PrlFi4bkBlHPLltwEorXL3YhmQiI8t6j5xtyTV3xTG8mvsS05i+goz38YjEvRjuC9SZybH5j3nGAb68eOAagPfmkwy4FQXbQFl2M3cACSmLy2/WhMTqeFy/TVqp9Qhu4MdLZV5j+1yJQ1N08ATN87si2hK3Pgh5DgkCBEJroxLpU9Lx+F44sYVc7YGfg1MAoSCq7cok6vS38r4iQnCCsRxnPRE4ne9i3869BUANpe8iQ1H3KxN9+uhfe6limapMhj7E8t7BXIxdiLB5E9+AsCzW1TJ67aKjWjLmG1zMZa7yFFLLi12a3yc5GE1d+dwp0nICbNtehzKGqApf/NYyquVWcXn8P9v77zjoyqz//++09MnvUAaEFLoBIgBVBAUBF1w1UVFwbLqqqy6fFfFhlhZ8be6ti+WXcWvoljWtiyiCIiFJlWK9E5IgfRMn/v8/rgzk0xIIJAyQ7zv12temnufO/c8c5l7z5znnM/B2kJ1Za8y8dYEpZN4f5ud6tj+oO849VyjToPTGwGpab4XmX3/foTTic0ocTwK8uwONsndSQmQWJtBq8HtjThZTnZuvMnEJyLAapTo7nCyTWTQtwMqpU6FUguoIORmnBudpERuhAFToMX7PEiaBonPQok4eZ0bl8cZs6MPvNhgEKA6NyoqzWBZswbH/v1oQkP5tGsIds1RhGzg2YLxsGm+MmhE01EbAKIUgTN9G1dj1q1cBTYbpaFRHMpQGvyNPa6IeNHnqrPStmmM7O1S7Tg758ayfj0IQVlsBJXhEv3cYWgBeo5pc1XihoRG1T80rVUtc25sW7z5NmB2aUlyu3GnDWsX+5rDoNXUL+/UNd+J3ZtMfCBOICSJXIeTTXIPks2BaWOg0Ui4PM9Rh7XupP3eMvCjsRIpThfhQgRc4waU6IB3WUpusCwlZNnnLNRHboJpWaqBHR67G0ealGU09dGufgIqKs1QMV9ZdoqcMIE39igRnJ4ho+mx/R0lapN5oZ+2TWO00UoUwWDDdyNqC2q+/RaA1enxoBHkmLPIbFgl1RZ4Rc4cZ6YX48WyxpNvk6rcYkbXebuAt1++DUBYqLF+maT69E0/hdOJzaOgvCdZYqAngTo8e0R7mdgkktTASag72Unw4lUmPpQg0cUtMMsym+QepEQFLtnV7bHbaTk5cd7hrZSKgR5OJ2UiitDYFKJCzz5RtC1ouPLRMOfG6yjIEiAJtAKEzoi2g5K1Z82ahSRJfq+cnBzffofDwb1PPUXX4cOJionlyiuvpPio0nrBpQUDgn1HS7nmyomEhoaSkJDAfffdh8vV9kvjwY7q3KioNIGzuJiaZYqOzNJeWdh0OxBCw9ODJ8LG95RBp4raAIY4pSLIZAPszf8aPxOE203Ft4pdG3KVZZSxhkSPtk0eJPdvk/NIniU1/Vk6N95+UpvTlXybkVXFoDNBtxFtYl9zhOi12D3Pzbqq0zs39t27EXY79hAtxTFwnq0GO3pCMpt3WtsLl055gDqbiIB48WrcHEyQyLVZcQuJLSIzoN2q3R673U20X/BFbuIkshwOtskZ9G7HZOKWIkGTCcV+ycQIHOgxdXD+Sq9evTh27Jjv9eOPP/r23X/ffSxasYL3/v53ln69iKKiIv5w800AuHSgdbm5YcrNuJxOVq5cyTvvvMO8efOYOXNmh84hGFCdGxWVJqj86GNwuzENGsQ/TnwDQI/QYeT++hHITkVhN33oKd8jIiEVgDAb2NqoeaZ1wwY01ZXU6E3syDoGwNijSm5La7VtGqKLUNoB6M+iWMpdWYl9h2LT9jSItJtIdruVSFc792kKMTRIzK06vXii1bsklSQhJIn+dju79Lkdmm/jxevcuGzNSwd4l6UOJiidwHeJVKLN0SQHNHLTvN2+hpkxnrYLIp2+weDcSFKDnJsmnBstGATYMXT4kpROpyMpKcn3iotTKgCrqqqY9/bbzL7/PkYUFDCgfz/efvttVq1fz9rNm3Fq4fvvVrJn9y7mz3+P/v37c+mll/Lkk0/y6quv4vDMbdasWfTv35+33nqLtLQ0wsPDufPOO3G73cyZM4ekpCQSEhJ4+umn/eySJInXX3+dyy67jNDQUHJzc1m1ahV79uxhxIgRhIWFMXToUPbu3duhn1dzqM6NikojhNNJxccfAbBh0HnYjBsAeHTglbDhXWVQMxVSDYlO6gJAhBWqq4vaxLbjXy8B4Oe0eGQN9DVn0eXIBkXbpk/rtG0aoouKB8BoP/Njvfk2FYnhVIVLDLV7Kq7asUrKi0GrweFxbmwtaB3hTSbemezGJDRkOZwciRrYjhY2jzcCIlubdm5cFRW4ShQn+XA85DkcbJS7k58e3WE2NoV3WUq2+/9jEQ4HjsNKTtiROIksp7dSquOdGyEEFofL/+WSsbhk6hpsq62zYnHJVAsZ2eGmwqlFburYM3h5q5payu7du0lJSaFbt25MnjyZQ54+V+vXr8fpdDKiUIkqClkmJyeH1ORk1mzejEsr8fO6X8jO7UViYr0K5JgxY6iurmbbtm2+bXv37uWrr75i8eLFfPDBB/zrX/9i/PjxHDlyhBUrVvDss8/yyCOPsGbNGj/bnnzySaZMmcKmTZvIycnhuuuu4/bbb+fBBx9k3bp1CCGYNm3a2V6mNuXcrRdT+W3gtMLeZdDj4jZJlG0JNd9+i7vsONq4OGZL25EkmdSQvuTvXKREbTLOh4zTJ5yaExOwAaF2qKoqonXKM8oNunrJt2iBjb2UNfSxwhMJyboYIk4ha3uGmMzKexkdgNsF2pbfKuo8N8RNqcov4sssnq7o7aRK3BBJknDqPH2xak6vDO1VJt6bLNHH7kAH1CR2/JIUgOx1buxNe5T2XbsBKDErlUe5dgdfiCwGZQTaufHY7fAP8zkOHQK3G4sBqsMEGSeUyE2vADg3VqebvJlfn2LEtlPs29Gqc29/YgyhhpZ9fwoKCpg3bx7Z2dkcO3aMxx9/nPPPP5+tW7dSXFyMwWAgKioS3CDLboTbTUJsLCXHjyM0gqLSChIS/e8DXkenuLjYt02WZd566y0iIiLIy8tj5MiR7Ny5k0WLFqHRaMjOzubZZ59l+fLlFBTUV4PedNNN/OEPyo+oBx54gMLCQh599FHGjBkDwD333MNNN93Uqs+rrVCdG5Xg5qv7YcP/wWUvwKCbO+SUFe8rycO7B1+ALWIxEnBf3yvh49uVARc+0KL3iUqIwVsoVVV2uNV22XftQltyDLtGx6asUiQ0XLJ/vbKzrRKJPYTFK0tqIQ5wWMsxnIEooLdZ5qauNiRZy2CbDZL6QmRKm9rYHC5P5MZhOXVfLNliwe7RjNmTLHGNtQ670KNNG9zeJjaJW6cE0mV702uBDZWJE11uYj3JxDcGOHLjdcpEI+fG7l2SioU0lxuXbESK6UZUSGCTiYOZSy+tT7jv27cvBQUFpKen89FHH52kkNywskuWQC8JZDS0JPc5IyODiIj6PK3ExES0Wq1fw8rExERKS/0rDvv27eu3H6BPnz5+22w2G9XV1URGRhJIVOdGJXix11K39d/8GBrCiJJtGDvilLt3K20NtFqei6lF0jpIMGYwYu9KcDsgfThknt+i94oKN7HfqERuKkqOtto2b5XUpq5x2A3HGRTZjcT9yyEkus2jIlHxiiNickJtdQkxLXRu3JWVvofw9jSJ7ja90sogu32rpBri0nn6Ylkspxxn274dZJnKSC0VERL9j9lZL2eRmhDTMYY2wuvc4GhaONG2y5tMDLl2OzUihBJDGjlJgX2IyFot4EI0srthw8wsh50dIo28roH5bEP0WrY/McZvW+We7Rgd4DCHEJWSiZBlbJ5cscPx0N3l5KCuO93iw1t97rPFbDbTs2dP9uzZw8UXX4zD4aCippr40EiEkBEOB6UnThCfEIdBCGLiE9mw1T/SVOJZykxKSvJta9zWQJKkJrfJjao8G47xiu01ta3xcYFAzblRCVrk7V9yd0wYf02M59PKU4WN2w6vaF9Rr3zKktcBMC3vSqQN7ygDRrQsagOg1UhYTcqXvfbE6St3Toe3UebP2cpDZKzNU97Z52rQta3rFxFT/xCqK2+5Y2ZZtw6EoDwplKowiUusnqTeDliS8uLSe26wp+mL5VUm3pUkowH62u2skXNJi2nfpOfmcHuF15xNOzcNk4nzHA5+kbvRLy2mw8qUm8MXuXH6lxvbGzg3PTz5NoFKJpYkiVCDzu8VotcQqtMQolP2hUhC+VuvIdSgQa8zYg41nHTcmb5ao7hbW1vL3r17SU5OJj8/H71ez3erlWVfIcvs2L6dw8eOMXBgP/QC+uUPZtvWrX4RlyVLlhAZGUleXl6rP8dzCdW5UQlaPvjlddaGKFUr+xwV7X4+d20dVZ9/AcAbKRFo9NVE6mO57PBWJWqTNlTJtzkDbCblgWWvbJ39zqNHsW//FTcSG/Mq0UoaRu9XnK+2XpICiAgP8fU6qjtxrMXH1Xn0bTZ0VR7QI201yGGJbVai3hJcnl/KwnbqbGjbVsW52ZMs0cMpEy4EP0u9SYjoiBjhyQiP3ZLjZE0S4XZj363k3ByKlxRlYhH4ZGLwRm5AaqSl4vAJ+CltF7aJ4CgD9yK8TofsaWPQoFLK6Gu70LGVUn/9619ZsWIFBw4cYOXKlVxxxRVotVquvfZaoqKiuOWWW3j42edYsXYtGzZu5o/TplHQrx/9BvXDIATDRowmLy+PG264gc2bN/P111/zyCOPcNddd2E0BubfdaBQl6VUggLZaqXslVdwn1B+6ddayqgrKuVOScJihJJBp86faAuq//MlssVCVXwKW3J+RQvc3HMi+q+eUQaMeOCMS63tJiVk76ppXrukJdQsVbRtfk2Kpia0mqGhqcQ6DrSptk1Dwow67HowuKCmvGVKv1DfLPOXrm5CXXp6Opxoeo9tV1Xixshe56aZxFwv3sjNnhQYYK3DJvSUm/sEpLs2gKxTbseS82RVaMehQwibDbsOiqMh74iD9+QeTE0PzDJPQ4Qn4iQ1iNwIIRrk3Ej0sDp5SU7n4S6BXULzw9dbyuPc2Bs3zDQQ1sHOzZEjR7j22ms5ceIE8fHxDB8+nNWrVxMfr1QvvvDCCzirK7juL3/B7nRy8QUX8MKMGb7WCzpTGAsXLuSOO+6gsLCQsLAwpk6dyhNPPNGh8wgGVOdGJSgoe+llyt9+22+bEiNRbjzLjLLSBbedOt0KIah4X1Ek/ig9A23IWozaEK4uOaQI5KUVKjotZ4g9xADYEXWt68HgXZJam608+MZWeSJB/a5tl88kVK/FblDK2Gsry1p0jKuiwi/f5jyrXQkNd2C+DYDbFwFpvumnq7wc5xGlZcW+JInrq+2sl3uSEmfuCBObROiVakDJdbJz412SOhwPsbJMvFtms+hB/zRzR5rYJLLPuam321VSgrBYcGmgIkomuVrGEZNNhCl4kol9Bdqi6chNjdATq+vYxY0FCxaccr/JZOL/PfYILz/4CM64CAy1ToTNRrEWNEKDXq+nS3o6ixYtavY9Zs2axaxZs/y2zZs376Rx3333nd/fjUvaMzIyTto2YsSIMy59by/UZSmVgGPbsYPy/1OaUsbccjOHrh/BeyM1fDRCYl8XJaPfWCOBrfmGgq3Fum4d9t17cOqNrMhXIhV/yBxH5EZPD6kLzzxqA+D0VDhoLGehhufBVVGh5LIA6/Nq0aDloqPbFG2bvm2nbdMQjUbCYVDma6tq2ZKa18bSRCPVYRKjbZU4JcNZOYWtQfYkOJ6q6adtqyLeVxQjYTFJDLDbWS3nkhEb1iE2NoXw2K11npyM6Wu7EK/k2xwRccQlpRFuDPzvU+GNOLnq7fYmE5eYIV12c0CkkJ3aWjGENkbyhW4AkB1KpM8buXFpjei0wfuIFLLwOWRuLbiEHlMHO2PBjPpJqAQUIcsUz3oc3G4ixoyh7tYreShtNV+ep6Fnj1qWdBkOQHgNuGvaRgivKbyJxEtTs3DEHEAjabmhshJcNkgtOOu2Aa4wpdJC04rO4LXfrQC3m4NxkZSZJQZrY4mSBfQYDRFJp3+Ds8Tr3DiqT68XA/X9pDZ0USImhVYbx2LPa3dV4sbIBiUConE230/HuyS1OwUS3DLJLjer5TzO6xbAZR6DkhOhcZ3s3Nh2NGi7YHewSe4RcH0bHx7npqHd9r2eZGJP24XtIjDifS3CE2hoGLnRC9AGQKW6JXjbRuB2+3rWaTRqN/DGqM6NSkCp/OQTrJs2oQkNJW7GfTz848M4hIvhFiuRdX24ZJSyOBVdA+Xle9rFBldZGdXfKMq/Xw/yLPt0vZDkjYrDc7ZRGwAizADorWdfGlmzVCkBX9NDsW1ipSfBtx0SiRviMCi3B9cpGjk2xJtvsy0d0h0ScW4Za+bF7WZfcwij8lDSNBEB8eJVJt6bLNHfasUu9GyVenBe99gOsbEpJI9zo3WeHNa372xQBh4kysRefBGnhpGb/d5KKXyVUsHm3HidBEkIhBD1mjFacAs9xiDpBN4Y778OjWf50q0BPeBAj1HtBu5D/SRUAobrxAlK//48APH33M27ZYvYemIr4W6ZWcfLSb/oVnJ69wQgrgZKK9qnZ0nFxx+Dy8X22K4c6aac48Y6lxK16ToEul901u8tRSl9YYy2s1uHlq1W6n78CYCf82xohJaRJ4rAZG73XBaXQbm5u0+jFwOefJtdSl7I9jSJkRZlCTGi72XtZ2AzeJ0bXRNOAii5AzZvT6lkiQF2B+vknuR2jSMygDkhklFZwtS5/O1219TgPKqU4x+Kl+jli9wEPpkYAE+ukMZdb7e3YWZRjEQPh5NfA6RMfEp8P1g8jo0QCEDriYK0Rp+mXfE6ZZ4cJ28ysVMyoAuwLEAwoTo3KgGjdM5zyFVVGHNzKRs3hFc3/S8AD5WXE6aLpfewy0nsngYoQnhHj7W9cyNcLio/VPpILe4bjiTJFMQPJHfzv5UBZ1Eh1RBDrEcMz4Zvbf9MqFu5EmGzUWkO5WACDHSEECZEu2jbNMbllYy3nr7BlFeV+GiCjppQiWFWK1tFN5K6ZLaniU2iMSlOgtbRdOTGebQId3k5Lg0cTIQBNjur5TyGZ8V3pJknIXntbrSa5i0BPxEBeqNMjAtOROTQxRy4ZpkNkZpybjzNE4/ESWQ5nNRF5wVFfpAf9b6NXzdwgyAgZeAtRzHcuwzo9Dg3aI2t0tTpbKjOjUpAqFu9hqovvgBJIn7mw8z46RHcwkWvWgOX1VoIG3QdaLSEmSOwGpUvbPmRQ21uR83y5bhKSqg0hvHzwIMA3OgygMsKXQZB91Gten9TYgYAITYQzua7PTdr37dKldTqHoAkMalaqfBp7yUpAJfRk5hrO30ytK8EPNWNUSgJuptDzwtIWbUUoiQF65splrJ5lqQOJoBWCz0dDlbLuZyfFddRJjaJ1qTY3ThyU78kpejb7BSp9M5ov1yrM8W3nOax211Tg7tMqbCrMcu4XVFkpKUFzL7m8SYU18sGeCulHBgwBGlyrm85zaPP4/LkCGn0vy0dm9MRnFdPpVMjOxwUP/44AOZrJvG2WMWeql3gCuHFEweRAKnftb7x1eHKLz7L8RNtbkvFfKX8e0lOMm6Dkx6RmQz75T/KzhEzWl1mbU7qBigl1XVnmBAtXC5qly8HYHVPG1pZy4i6GojPhZQBrbKrJcge0S+NvfnEXC9e52Z7mkS+zY5RwLHEEe1pXrNowxQtFX0zy1LWBktSfWx2XMLAHn1P+qeaO8rEJtGFKMnn+kYft+2kfJssBgVJvg2AxuBZBvTY7a2UKg+HLhonv8rpQSXe58Pz3Zaorzpy6ZQoiKw1ojlHoiAuLUhCi1EfZJGxABMUzs2rr75KRkYGJpOJgoIC1npulE0xb948JEnye5lMwZnVrtI05W+9hWP/frSxsZRPvZR/bnkTgGEnupMoO5UHd0KOb3xtpBJ+d1e0TgivMfZ9+7CsXo0bieUFyi/NGyUzkssKKQOVaqRWEpvSBVDE8KqOHzijYy0bNii9msKN7EiVGFwnMAmhRG064MYre9ShtacoqQZFM8a7dLI9TWK4pY5iEY0ptf0dsKbQhSgP0mYjN78okZs9KRL97XbWyT3J75aEPsBlv7pQRfagsXPj1bjxKRPL3ckPAvE+LxpPrpDWsyxl9ykTK/k220RG0CUTAw1Kwf0rpQyyQGsI4mdKo6++Ugauw6QmE/sR8E/jww8/ZPr06Tz22GNs2LCBfv36MWbMmJO6kTYkMjKSY8eO+V4HDx7sQItVWoPj0CGOz30NgNj7/8rda55AIOOs7sOzRs91bBC1AbBFmQHQ1Jy9VkxTnPB0//45NYXjsXUkmGIZt02pmmLEg23iQJjjonF7vmVVx/ad0bG1HuG+dd0lZI3E9XXF7aptcxKe5R1dM7krXrz5NocSJGpCJYZarSx1D6RHYmDUaA0RyoPf0IRzI9xurNu3A0qlVH2+TWCXpAAMoWbA37kRsoxtV31PqVyHgx26bHKTI5p4h8CgMSql/o0jN0Wx0MPhZIdIp1dKECkTe2ng3Pg0brQghD6I823gJO9GAw4MGIN0GS1QBPzTeP7557n11lu56aabyMvL47XXXiM0NJS33nqr2WMkSSIpKcn38rZeVwluhBAUP/kUwm4ntPA8XojaQantILIrnHuTLyOqYhtodND7Kr/j3LFKfoG+tu2UL2WLhRP//gyAZUOUG9tkfRJ6p0WJHGW1TQlzdJiBOs+PwIriwy0+TghBzRKlBHxlDwcGt5ahVhv0GNWu2jYNkUI9yzv2U3/uvhLwVEh0C7o5XXwrD6RHQuu6KZ8tpkilnNvoPFlV1b53L8JiwWpQypT7ecT7hvcIAucm3AyA3q04YQDOoiJEXR1OLdRFuQl3GonumhNU4nI6b66QJ8DXsGFmltNJbXQeYcGWTAz1y1JC1Hc01yol1cHs3IhGvo1WI3CgD3jkMdgI6KfhcDhYv349o0fXh/81Gg2jR49m1apVzR5XW1tLeno6qampTJgwgW3bmu8Ybbfbqa6u9nupBIaar7+h7ocfkPR6im67ki8OKPku2VzH7SUvKoNyfwdh/lojmpTuAITWAva26TFVtXAhOmsdRRGRbM6qIFQXwlU7vld2Xtj6XBsvJr3W1xm8uqy4xcfZd+zAWVSEy6Blc6bERXU29NAhicRetOGe5R3HaZybn736NhJDLXXYhIG19CY9NjDdtU1mRQlXK8Bl9297YduiiPftTZLo7nKicxsoDs8NmCPWEFNE/b97b0dzbzLxkTjo6Xbxi9yd/IzAafE0hdakfHZe58a2V9GjOhoLiXYt8ak9A2XaqfF8x7Vu/MrAA10pdfToUa6//npiY2MJCQmhT58+rPOofwPMefFV+l9+OXFDhpAybCiTr76VDZu3+lVKlZeXM3nyZCIjIzGbzdxyyy3U1rZ/f75gIqDOzfHjx3G73SdFXhITEykubvpBkJ2dzVtvvcUXX3zBe++9hyzLDB06lCOePjGNmT17NlFRUb5Xampqm89D5fS4a2speUZpQBl58438eec/QBLorYP4wPwrUtkOCE+CS+ecdGxUep7y3xqwVbW+YkoIQdl7imP1dT8jQpK4ytiFSEed0oSy55hWn6MhNo9zY6sob/Ex3iqpLd20OPQSV9RV4DREQc+O69Ok8zxsjadYDXSdOIF9t/Iw254qMdRq40e5N9ld4wP2SzIiuj6yZavy74vlVSbemwz9bUq+zXlZKUFRQhseVe+02OoUnSDbjh1Afb7NRtGD/GDRt/GgD/VUp7mU3BXnYeVebDXLHHOn0aerOYDWnQLPNdd4fPd6vRhjwPRiKioqGDZsGHq9nq+++ort27fz97//nejo+gTy7pkZPP/QQ/z873+zaP7/kZ6awuRrrqGsrP7f+uTJk9m2bRtLlixh4cKFfP/999x2222BmFLAOOfiWIWFhUyZMoX+/ftz4YUX8umnnxIfH8/rr7/e5PgHH3yQqqoq3+vw4ZYvDai0HWUvvYSrtBR9Whr3JRVjl0oQrkjeyy7EuGU+IMHv34Dwk7VGkrorv/xia6D0+M5W22LdtAn3rp3YtVq+H1SOVtJw/R4lb6RVasTNoHQGB1dVy6OG3kaZK7u7CHNpGGKzIff6PXSgJLwxSomAnMq5sfysfG4HEqAuROI8q42l8kAu7Z3cESY2SURUHC7Pnc1SWeK3zxu52ZOiiPetlnMZnhUckZDQ0BgcnoCBrVqpDPQmEx9MUHpKbRY9GBAEzTIbYgwxA4qTYN+/H8ntxmqAOKOiTNy3axAmEwOS5P/48/aUQhc4vZhnn32W1NRU3n77bYYMGUJmZiaXXHIJ3bt39425cuLlXFRYSGZqKj1yejD7sb9SU1PNL55E+V9//ZXFixfzz3/+k4KCAoYPH87LL7/MggULKCpSKjbnzZuH2Wxm4cKFZGdnExoaylVXXYXFYuGdd94hIyOD6Oho7r77btzu+oKCjIwMnnrqKaZMmUJ4eDjp6el8+eWXlJWVMWHCBMLDw+nbt69fpClQBNS5iYuLQ6vVUlLifwMqKSkhKalleQV6vZ4BAwawZ0/T0vxGo5HIyEi/l0rHYt22jYr3lAaUGyZdxmb7YgD+2GUKeauUknAuuA+6Nd1gMbGHEm0LcUBJ0a+ttqfCk0j8Y5aZuhCJsaYuJNtqIKlvu6j+Oj2qt3Jty6q9HEeOYN+xA1mC9T0kLq2rQQcYB93Q5radirA4RYAwxAGyu+mKqYYl4L0cdsyyzFL3AMb0CpwOS0hIOHaP0LCtsr4wQbbZfMm5exokEw8LgnwbgJCwcJye1BRHrRLl8ysDtzuoje0XUBXlpjCE199TbduV7+fRGE/bBZFBXnIQODdCgKPO/+WyKXpWnpdLtmJwWNFJ8sljW/M6A/HOL7/8kkGDBnH11VeTkJDAgAEDePPNN/0HNfC7LG4n8977lMioKPr16wfAqlWrMJvNDBo0yDdu9OjRaDQa1qxZU3+sxcJLL73EggULWLx4Md999x1XXHEFixYtYtGiRbz77ru8/vrrfPLJJ36nf+GFFxg2bBgbN25k/Pjx3HDDDUyZMoXrr7+eDRs20L17d6ZMmRLw7uABzfIyGAzk5+ezdOlSJk6cCIAsyyxdupRp06a16D3cbjdbtmxh3Lhx7Wipytki3G6lMaYsIy4axZPi30iSIEN/AfcenA+OWkgbqkRMmiE+1sxhE4TZoHR/6/pLuU6coGax4lx9U6CE/qceVHRP2kLXpikcIUbAglR3eqVfqK+S2pmmozYUxh+r5ZghneSUgW1u26kIj1ecSo0AS3Up4dEnR2PqvMnEaRJDLTY2y92IT04nLUD5NgChRh0OPYTZ6yMgALZffwWXi8pQINRNzAktjoS+JEQER9mvyRjis9teU4FsseA8pCzDnogTuEtj6dk7I7BGNkFIWL3zYtmhVKIVxUr0dDg5EJ1HiCEIknOdFngmxW9T43idV++5zbOvHioCQ8u6ze/bt4+5c+cyffp0HnroIX7++WfuvvtuDAYDU6dO9YySWLRiBVPvuw+LzUZiQjz//WoxcXGKk15cXExCgn8Hdp1OR0xMjF+6h9PpZO7cub6o0FVXXcW7775LSUkJ4eHh5OXlMXLkSJYvX86kSZN8x40bN47bb78dgJkzZzJ37lwGDx7M1VdfDcADDzxAYWHhGQUp2oOAL0tNnz6dN998k3feeYdff/2VO+64g7q6Om666SYApkyZwoMPPugb/8QTT/DNN9+wb98+NmzYwPXXX8/Bgwf54x//GKgpqJyCyo8+wrZlC1J4OPd2t4H+BDo5hvciDHBsM4TEwJX/BG3zfrZGI1ETrtwgq4+1rjN45b8/RTid7IqPYH8KDDEkkFtXBUl9ILt9HGS3JydBa21GeKURPlXiLJlYt8RAm50DXSd2iLZNQ8xxqcieU9aVnZzr5Dp+HMeevcgokZuhVhtL3QMZ2zuw6rkhBi0OpSMAdRXHfdu9/aT2pkj0dzhYL/ekICtwy2eNMel1uLwdL2oqsO/ZA0JQGQopOie/iO4MCiJ9Gy8hoVE4vctpnjL7o7ES6Q43kam9A2jZuYcsywwcOJBnnnmGAQMGcNttt3Hrrbfy2muv1Q+S4MLBg1n9ySd8+vm7jBwxghuuu/aU8ilNERoa6rfclZiYSEZGBuHh4X7bGr9v3759/fYD9OnT56RtZ2pPWxPw+rxJkyZRVlbGzJkzKS4upn///ixevNj3AR06dAiNpt4Hq6io4NZbb6W4uJjo6Gjy8/NZuXIleXl5gZqCSjO4ysooff4FAL4aNpRjccsAeK775UQte1IZNHEuRHU57XvVhRvhuAXnicqztke43VQuWADAN4OVKMrNRZ5+Ve2Qa+M7b7iiSaKznloMD5QGlJb16wFYlyUxrrYKISQ0/a9pF9tORURYCMUGJZJgOX4UGhW9ePNtDiUARkFfu52Z8kBeCLBzY9JpcfichErfdqs33ybI9G28GPUa37KUtabKtyR1yJNvs0nuwS1BpEzsJcQUQbVOKWG3exKgj8aBsCeQlxokn68+VImgNKCivBhTcX2Sf1mMwCiHE5+U1rZtQ/Qtj2ImJyef9CzLzc3l3//+t+9vIUmEh4bSPS0Nc2wqQwZfxIUXXMC//vUvHnzwQZKSkk5yLFwuF+Xl5X6RFL3ef3lTkqQmt8myv85VwzHe3KSmtjU+rqMJuHMDMG3atGaXob777ju/v1944QVeeOGFDrBKpbWUPDsHuaaG6rRuvNVLeWCPjr+Y0StfVgacdxdkj23Re1kjwwALVJ2+Q3Vz1K74HmdREXUmA6vy3HQVEQytOQSJfSB7/Fm/7+mQIpQHUks6g9cu/w5kmYOJGsrMEpcetbBC7sfAHj3azb7mCDfqsBkV56b2xMnViw2XpIZYbZSJGKyxeWQFuKxao5Fwee619poq33arV5k4Ga6w23lKymNaZvBEQow6jS9yY6utxH5MydE6mAB5dgf/NuXSNTo4mmU2JMQUzgnvylONYrMrUmZfbTf6BEsysSSdtDQkGcNBV9/vTWsUuORoNKbA/fsdNmwYO3f6F03s2rWL9PR0398Nk521GqVhpizL2D39sQoLC6msrGT9+vXk5+cDsGzZMmRZpqCgoANmERwEfFlKpXNSt3Il1QsXIjQanhwcBsYqonSJPH1sC9gqFaG80bNa/H7OaOUXoKHm9H2OmqPiAyWR+Ns+Ek69xO0VxUpu3oX3g6b9vgq6aGX929QC58ZbJbUmC7q4BL0dDr4LGY051NBu9jVHmFHnW96pOXFyiNmrTLw9XVmSWuYewNjeyUFRVu3SKzY4a2sAcFdV4fQomR9OgnSbhL5rPqGGoPh9BygPLZfHSXDU1WLbWV8GnmWXicgYEBSfbWMMRpPPbgC3BOYwBzvIIC85eAs4GlZLubRgQCDpA+s8/uUvf2H16tU888wz7Nmzh/fff5833niDu+66C4C6ujqe+tvzrN28mf3FRWzftI3p997L0aNHfTkvubm5jB07lltvvZW1a9fy008/MW3aNK655hpSUlJOdfpOhercqLQ5st1O8eNPAPB1Th4He/4KSPzDnEvo4bVgiICr3gLdGTywE5TkVtNZqhQ7Dh2i7ocfEBJ8m+8izKVnfFU5JPSCnMvO6j1bijGuKwChp2kKLlss1P34IwBrsyUura2mWoRSldo2aslnil6r8VUdWav8m5a6yspw7PXk26RKDLPa+FYOfL6NF5fO49zUKcJl1q1Kvk2xGTK0DjbL2QztGRy2NsQbuXFaarF6lniK4wV1jhT6ZQafvaAUhrga+Igl0dBddlJtzglqpV9JU2+bUwt6IdAZAttZe/DgwXz22Wd88MEH9O7dmyeffJJ//OMfTJ48GQCtVsvuffu4dvp0Boy/jMlT76GqsoIffviBXr16+d5n/vz55OTkMGrUKMaNG8fw4cN54403AjWtgBA8P1tUOg0n3vwnjoMHqQqL5P1RiqDXtUkXMGjVu8qA370IMd3O6D1D0nKAb4ioAeGwIhnO7BdWxYIPAdjaPYSSaCfTKioVxd92jtoARCYrSXthNnA5bOiaacpX+9NPCLudUrPEoXgYW2ThS/eF5KSerP3TUTgNEiCwV1f6bffm2xxMhGidi1inlgPh+UHTINEbufEq/fqUiZMl+nvybcZkBe5zbQ63Tvm8tcdOQE0tbgkiI5xsru0dVJ3AG2LUaf0iN96GmcfT+gfMppbg59zowCTrMAVBZ+3LLruMyy5r+geXyWTirf97k+NCiUgmOzSExPU8qSItJiaG999/v9lz3Hjjjdx4441+22bNmsWsWbP8ts2bN8/v7wMHDpz0Xo1LvjMyMgJeBg5q5EaljXEcOMAJj6DiG8PisYXX0iW0C9N/+RoQMHAq9L7yjN83Lkspg46pgaryvWd0rGyzUeVJyPtvfzt6t4brqsohIU9p99DOxKTlAkpJdXXx7mbH1XqqpNZmQabLTU+Hk0/cF9AvgHkLToNyi3DV+Eu31zXQt/GqEo/skxY0yyZuTxNB2aqEy7zKxHtSJAbYHGzR9w4aR6whbk/EybRP0f46Ggs93U62aXqSF4zNJwFDg1whUGwOt4eTlXb6QoFAomkUuXELwznRWbvhd0wWerVhZjOon4pKmyGEoPiJJxBOJ+uTu/DzwANIaHjWKmGqK4X4XBj7t7N67+QeSvTD5ISyw7+c0bHVi77CXVVFZYyRjd0lrqypI0KIDonaAMTGxvmWd6qKmnZuhMtFjSd5/ueeGi6trWWP3IWS8F4MCWDSq8vj3Mh1/gKEljWKc7PVk2/zbYBViRvj9i6H2B0IIbD8shlQnJssG0R2G4I2QBL7p8Lr3EQcqgDqK6WcSQOCtjGiViPhbhA4KI6BansQt13wIEkaXxNKoQUnhqD9jBsieVT8dELg1hjbtrKrExH8V1LlnKH6v4uoW7kKh0bH2+OrQZK4KaoX/fatBF0IXD0PDGcn7pYcb6bWsxJVvGfLGR3rTST+b18nSBpuqS5HxOdC7oSzsuVMMYfUdwavOnawyTGWdeuRq6qoDoGdXWFMnYVP3BfwhyFpAe0A7XUShKW+AaWztBTH/v3IwO6uMMRqY7NpCPlBtGwiN3BuXCUlyMdP4JZARLvY7epJYRDm2wDInl/hOruSOH8wQSLZpiO1W69THRZw3A0iN3KUm90ik5ykiMAZ1AI0Gg1uj18gaQVyANsunAkGSY9BCMyyjNAGNkcomFGdG5U2wV1dTfHs2QB8PDie0ngr3UNTuGuzogbMuOcgIees3z/MqKM6XLnxlB/a1+LjrFu2YNuyBbdOw7J+EhfXWklyu5EuvK9DojYAESYdVq9zU3K0yTHeKqn1WRI9nU7SHW6+kIczaXBgG726jMpTS7LVqyv7+kklQg/JwV53Nwb2yg2qSIjsyZ3QOFy+EvDD8dBLtrNazuX8IGm50Bi31v8zPBYnqLRnBF2zzMY0jNxERjipigruZGIAjaSh1AylUUpJdaArpVqKVtKS5XSS6Haj6cBec+caqnOj0iaUPP8C8okTHImM5L8XlKKVNDx97CgG4YY+V8OA61t9jrpwZW3HVlp2mpH1ePtIrcyBmlCJW6srqI7oDnkTW21PS9FoJOyezuCWJkqqhRDULP0WgLU9JcbUWfhe7ktedjZdzIG94cpGpaJNY69XV/aVgKdJFFptfBsEqsSNEQbl34rG4fIpEyv5Nnb2hg8gPYDtIU6F0Pk7BHqziy1yFgPTgicq1hRep6wiDNI0Tgxd+gXYotMjSRrsBonaEAmDAH0zif5Bh6eEXRZSwKu7ghnVuVFpNdYtW6j8UKlG+telLlw6iVs1cfQqP6xURY1/vk3Uf60RyoNelNe0aLyrooLqRYsAWDxQIt/iIMfhhAvuB03H/qq0m5SvmqOi/OR9v/6Kq+gYNj38kiExtq6OT9wXcu2QtA61sSmEUbnha+31+kJ1nuZ72zz5Nqv0gynsFhydtb0Iz01f63D78m32Jkv0tEF81pCgXX6QG0Q7ak3Q1eCgLKoPUaHB1SyzMbLH7KOxEkl2LWmZWYE1qAVIGgkJT1WP0AZ9pMmH595lQ49Jd47YHABU5+a3gtMKy5+BfSva9G2Fy8XuBx5GEoIVPc1s6+YgxxjHbXvWgdYAV70Nprap8nBEKe+jq7KdZqRC1aefIex2DiRp2J0Ct1ZXckjTlcj8q9vEnjPBYVKWSdzVtSft8/aS2pwpket2EOE0siVsKCOzA1+qLEIUh1JnV6TUnSWlOA8cQAaOpMiYbRGk5wzBEGwVGx7nRueQsWxVcrRKEmVK7N2DUt/GS8PIzcEE6OVwYMocEkCLWoY3cnM0Ftz2JPqmmgNrUAuQJIlQWaATAmTDOePcyLpQDsvxHBEJGM+B6q5AoX4yvxGqFz/Ay5tfY+1Xd7fp+1a8/wH6fbupNeh5b2wNOknL0wd2KBoyFz8JKf3b7FwiRuk3Zqo9fY8mIctUePpILR4APZxuhlptrE//Y4dHbQCcJs8v77qTlfxqvlWWpH7uKTG2zsJ/3IVMHNI9oInEXqQQT18sh+Lc+PJtkqCfsPOdeyCXBFGVlBfJpDhl8cfdSHVW7DqID3ewVvRiaPfgzLcBEA169ByKlwi3RdK7W+AjeKfjcKoWixE2Z8FxZybZQZ5MDIpzk+p0k+V04tYYgypn7FRIElQQjltrRNtBeYPnIoFXLFJpc2SbDcfB+qqcfdv/zXM7llCij+SbEDv/sVZASOvX8J0lJZT840UA5o/QUBUmuNsq6GmzKL2aCm5v9Tkaok/pBqwjvOb0AlF1P/2E8/BhLCaJH3tJPFZZxT45GfOQjm9ACeAOCQFq0Vocftsdhw5h37ULtwQbusPM4xb+JF/IKwFOJPaiDVMeUgaH8plbGvSTGma1sVjK58WegY8wNUYKUfoIGT0f9/4k6Oe0szV2MDFhHd/KoqUIXf0t+UgCdLV3pyAjuPNtAPZkG3ivv0yew0F1dS7Gc2C5RAJkJLQIhPYcybcBQg1awgw6IkOCe6ky0KjOTSfDsnEjR/58N+7jx33bJOB+ANys7amh/MIfiMlpvXhdyey/gaWOnUkhLBvooLcmnJuO/QqRXWHCK23eZTsysy/wEeYacDos6E9RVl4xX1HnXN4HzBrBpbV1zJBv5IlugXkQi7AwoAy91b83Vs1SpVP69jSJHMlBjTOR6KzCgCcSe9F5m356nISa1asAxbm5yiKzPGvESeqowYDW5N8kcU+yRKEVjvcP8saBDRNEzS72SblcHROcyc8N0aFFSIoysTYl+JOJQYncONBhFE6ks5SoCARajYbuAW5Oey6gxrQ6EVX/+Q+Hpt6I+/hxpPAwLJFGKsKUCoZaz3e3/17Bhl1LWn2u2u+/p2bxYtySxD/HOdBJOp4+tBudpIWr/gWhbV+6mpJ7HgBGF5zYv7HZcY4jR6ldoeQWfTNAw/VVVRySkznSZRxhxsD481KEooZrsMp+271VUt4lqU/cF3BtQfpJxwcKQ5SSKGyyK5E696HDyBLYEt3sdvZidN/gXDLRh/nnee1PhjpbN4ZlBW++DYBkUKJKMhAb4UBOyQ/a5OeGpLgUZzzf6iQps0+ArWk5+0lhp+iK0RAc0Ty3282jjz5KZmYmISEhdO/enSeffNKvnYEQgpkzZ5KcnExISAijR49m925/cdDy8nImT55MZGQkZrOZW265hdrak/P9OjOqc9MJELJM6Qv/oOi++xEOB5oLC3ngL4nceJebO/+sZetkCwtueYzaEA0GNxzYvKFV55NtNoqfeBKARflaDiZK3F1ZTTenC0Y+BGnntcW0TiIlMZZqj5NWunt9s+MqP/wQhOCXDInqaLiqupaXXVcwtm/g5OC1kR4nwVbv3LhOnMC6QXHSNvSAi2qt/BQ6KigSib2ERSvOgN4NdT/+BMD+RBgorHwn8rkoJyGQ5jWLPtx/KUcT62KT6M2gIF/ikcOViNPROMiU3SR62o4EOyPtsSw7dITMmnj6pAVX5dyp0Gp1uNAFTfTx2WefZe7cubzyyiv8+uuvPPvss8yZM4eXX37ZN2bOnDm89NJLvPbaa6xZs4awsDDGjBmDzVZfaDF58mS2bdvGkiVLWLhwId9//z233XZbIKYUMFTn5hxHrqvj6D33+Po5nbh6JNcO3cw+1yHiXG7+dayU/mn38P/unMSxrkoipftgRavOefy113AeOUJ5hI6PLxD0ckjcUHECuo2A4dNbO6VmiQs3UuOJxpbt29nkGNlup/KTTwD4Ol/iqpoaytyJrA8fGdDSamNMCuDfGbz2u+9AltmXBD0Mdra5ejNySP+gSCT2EhZb7xBWL1OquralSxRa7FgyRhFhCs51f2O42ff/NSbIMNmpTS4M+ooYa9d4Xr9UwyuXa9HbEhiQGZzOY2OE1ki8W2YnGfRMDP5kYi/psaF0iw/HECQ5QitXrmTChAmMHz+ejIwMrrrqKi655BLWenLdhBD84x//4JFHHmHChAn07duX//u//6OoqIjPP/8cgF9//ZXFixfzz3/+k4KCAoYPH87LL7/MggULKCoqApSGmGazmYULF5KdnU1oaChXXXUVFouFd955h4yMDKKjo7n77rtxu+sLODIyMnjqqaeYMmUK4eHhpKen8+WXX1JWVsaECRMIDw+nb9++rFu3rsM/u8YEz11U5YxxHjvGgetvoGbJt6DXs2zKIO7o8QNOHPSxyHx89Bh5qaMZcuVfkCQJay+lpDSqSCDXniwm1xLs+/Zx4l9vAfDWxTJuvYY5JUfRhsXDFW+0q+qvViNRG67chGqLDjc5pubrr3FXVHA8AjZ3h+uranjFNZE/X5Ib0AdbWKLiWIU4QDgVQTxvCfjPWRrG1ln4VD4/4IrEjTFHJWHz+C+1PymRm52pEgZrCkP75QbQslMTYq6Pfu1Jkci2CbrmBn9JtUEfytL+Gg4nQoUji94pwdfcsyn2RBRQJiLZYh4dfLIAKE6BxWk56SVjR9I4mtzXVq8z6ZA9dOhQli5dyq5duwDYvHkzP/74I5deeikA+/fvp7i4mNGjR/uOiYqKoqCggFWrlHy4VatWYTabGTRokG/M6NGj0Wg0rPFoVAFYLBZeeuklFixYwOLFi/nuu++44oorWLRoEYsWLeLdd9/l9ddf5xPPj0UvL7zwAsOGDWPjxo2MHz+eG264gSlTpnD99dezYcMGunfvzpQpUwLeGVxNKD5HsW7ezOG7pimJw9Fm5kwIZ13yJoSQGFUZyfOVW9BEpCD9vj6xN2PE5fD5QnochX27F9NjwJQzOqcQguJZj4PTyYYeWtb2hAdPnCDN5YZr34CIxPaYqh/WcD3gxl12shge1CsSfztAwyVWK1ZnHFtjxzBnQGA7FJtTevr+31pehik8itqffgRgQxb8sQ6+6j4uaBKJvURGxFNkVBqWSjY7sgSmeAc/lg3lptz2v95nS3hEHC4N6GTYmwy9rRkMC2J9Gy/xhniwwUCbnbroAUHpKDTFzpiLmLWnB9dlBmcOltVlpeD9wCSTr7luDaH6liUsz5gxg+rqanJyctBqtbjdbp5++mkmT54MQHFxMQCJif7fvcTERN++4uJiEhL8I346nY6YmBjfGACn08ncuXPp3l1pSnzVVVfx7rvvUlJSQnh4OHl5eYwcOZLly5czadIk33Hjxo3j9tuVStiZM2cyd+5cBg8ezNVXK/phDzzwAIWFhZSUlJCUFLjv3LnxzVHxo+o/Czl4wxTcx49Tm5bEXZOcrEsuRnKZeKpcx4uVW9AiIf3+db/E3t4XDMGmhzA7bFn11Rmft/rLL7GsXYtTr+FfF8NAm5Nramph+F+g+0VtOcVmcUQoOQmayrqT9tm2b8e6aRMuDSztJ3FjVTWvuK5g+pi8gC/1xMWlUusphKk6tleJgjicFJshPczGCud5XH1ej4Da2BRh4RG+juYA+xJhkGylNHkEseHBK/0eHhZd34k9QWa/1I+85LYRk2xPkkOS+eJIES+UlmHqFvyRJi9jeyeRnRjBVfldA23KOc1HH33E/Pnzef/999mwYQPvvPMO/+///T/eeeedNj9XaGioz7EBxUHKyMggPDzcb1tpqX+Uv2/fvn77Afr06XPStsbHdTRq5OYcQsgyZS+/zIm5rwHwa3YSz1xWht0gEW+L4t3je+jitEJIDPzuZci8wO/4sFATRckhdDtkpXLbrjM6t7uykpJn5wDw0TCoiZR45mgZousQGPlw20ywJXZExwInMFU7T9rn7f69JlsiT2vDaIthX8p4xvQKfIQhOjKa4hAIt0NN0V7k5dsBT5WUxcKnptG8HkSJxF4iQgzYGxSSKPk2JjSDCwNnVAuICI3mxx4SPYoE4fF2nOahaM4BkTaNMZxuThdlIoqeWcG77NeYC3vGc2EQ6h15CdGFsOa6Nacf2E7nbin33XcfM2bM4JprFD2uPn36cPDgQWbPns3UqVN9kZCSkhKSk+vFM0tKSujfvz8ASUlJJzkWLpeL8vJyv0iKXu+fLydJUpPbZNm/wrPhGG8lX1PbGh/X0ajOzTmCbLFQNONBar75BoAvBkfz/qgyhCRxmSWEJ0q2KKrAPS5WNGYimg4HVmR0g0PbCD1iOaPzlz7/Au7yco7ESSwcIvFI+QmiRSjaq94Cbcf9M9LGdQF2EVbjr1Lsrq6m6j//AeDrfA1/qazhVfcU7hubFxSltJGhBl9n8Moj+3F/p+jbbMqCcbVR9Bo2KuDRpaYw6jQ4GgRoDncVJFn7MaZP8KkSN8QUGsFbl0lYJA33HxcYerVPBV9bY0scwMeuC/hB7ssTQd4J/FxCkqQWLw0FEovFgqZR3qJWq/U5CpmZmSQlJbF06VKfM1NdXc2aNWu44447ACgsLKSyspL169eTn58PwLJly5BlmYKCINd5akNU5+YcwFlczJE778K2fTsurZa5lxj4oX8NOlnP7BNVjK05BLoQGPMUDLrllOJ5IUPGwffb6HoU6sr3ERbT7bTnt2zcSOVHHwHw5hgN59ltXFlTx6GL3yTd3LEJsKGp2cByomqUHCCv41L1+ecIm51D8SDHO0k5GklZ5kSG9ggOqX2TXovN49yInzZCTR1VoZAcbWdR8WgmB0GTzKaQJAmn50eZW4LYODsHuJDkqODKDWpMSEgIiS43B/U6tJY0hvUMfPSuJcSbo5jq+hN5yZGYQ4NDe0Wl47j88st5+umnSUtLo1evXmzcuJHnn3+em2++GVC+j/feey9PPfUUWVlZZGZm8uijj5KSksLEiRMByM3NZezYsdx666289tprOJ1Opk2bxjXXXENKSkoAZ9exqM5NkGP95ReO3DUNV1kZVSEGnrvSza5UJ+kuI/97bD9pLhekDITfvwFxp+/E23fM77A9/xwxtbB15QIKLnvolOOFy6UkEQPL+0oc7govHSnnP6bL+d2wP7TJHM+EhCylAkDvBkvJUcKSuiKEoPx9RZH464Eabqyu5FX39Uwf26vD7TsVDpMECMI27AVgXZbEJRYLX2dMDLpE4oa4DIrd+5Kgr8tF+aCLA23SaQkx6Hi2uBqrzsVq3cV0jQ7+X+0AuckR/GvqIHqoCrS/SV5++WUeffRR7rzzTkpLS0lJSeH2229n5syZvjH3338/dXV13HbbbVRWVjJ8+HAWL16MyVTfQmL+/PlMmzaNUaNGodFouPLKK3nppZcCMaWAIYlA12t1MNXV1URFRVFVVUVkZHAnGFb9978UPfQw2O0cjDUy5w8uyswSV1hkHio9igkNnP8/cOH9oG2Z3ogsC769qA+pxW62/j6Nq5/5+pTjT7w9j9Jnn6UmBO69TcuMunK6Vcfzy9hPuG7o6Z2ptmb3sXKOXzYMcx2EvPEMGRdcQd3KlRy6+RYsBnj0DnjlmJMXer7Py9cHV0Lm/El9GLi5vv3CC1dKXK2NgWv+zcV5wRtZmDe5NwXr3XxWKNEjPZHB0xaSGRd2+gMDzOHHskiVSnk5ex5/vvaKQJuj0kHYbDb2799PZmam3wNf5dzgVNfvTJ7fauQmCFESh1/hxNy5APzcXc/LE1zIBi3PlJVyea0FYropujKpg8/ovTUaibIu0aQWH0fsOXbKsc5jxyjzePvvjdSQL6yMrHFztbiXjwZmnNXcWktSdAT7wsFcB6V7NpNxwRWUe8q/v+8t8QdrNW/I13LvmLyA2HcqnCYdoDg3Nj3EJdhYUX0xs4IwkbghmweY2BZjpTjLhdF6Pn84BxwbgAelezA7irmsT3AnP6uoqLQ9wZfB+BtHtljYO+1un2PzRYGG/3eVTJJOw4dHjyqOTf5NcPsPZ+zYeHFmDwAg/ogTcYqM9pJnnkFYrezoCht7yTx2opxHnTdz7aUjiQyQMm2ESU9duJJnU3lgL87iYmo8yrk/DoDCKhOa/tfSPT74wvrukPrM3I3dJc63uUgYfEVQJhI3RB9iYvEgDYNkG2G9xwXanBbTY+BIjna9lAt6BkfelYqKSsehRm6CCGdJCVum3krIgd04NRJvXCqxoq+GS+uszCo7TmhoHFz9KvQc06rzdB09Fd5fQlI5HNv5Aym5F540pmbZcmqWfItLA2+O0fJQ+QmW24ej6TeJKYWBbexoDdcCLhzFxVR+9BGSLNiaJjHUUMe78tX8+eLgLKEVISFAFQBbuoO+Np8rz+v4pb0z5SJ7MoNs+0mpTiIuP/giYs0x63fBlXOloqLScQT3T8bfENYtW9gx8UpCDuymKkTiies0rOyj4ZHj5TxbWkZoz3Fw5+pWOzYA+f36UOzpbbdj8fsn7ZctFoqfegqA/w6RyAmz0qPGzPy4u3n6ij4BL622e8TjNMerKFugLEktHShxUZWe8IIpwVvJE6703HFpIDbZysEuwZ1I7MUSmssfampZbbyY7HOob5CKispvFzVyEwRUL1rE0RkPoXPYORQn8ezVGvThMu8WldELA/zuFRhw/SlLvM+E6DADxclGkk7Yqdr8y0n7j8+di6uoiLJIWHqe4N2SGqZpnualG4YFRfdcd1QkUEfqzhokN5SHK87Cl+VXcvfInECb1yy29C4cit/NLxkSuU4Tkee33lHtCA51u5YLD6Zz+XnDAu7YqqioqLQE1bkJIEKWOf7q/3L81VcBWN9d4qUJGgpcVp46eoKoLkPgitchJrPNz12blgpb9xBxoNpvu23XLo6/9TYS8NYlGmZUn+Blx2SmTZlAWmxwlNNK0fHAMXQeHb+l/SXG1GrYev5NRIcFrzZIlLkLf/2jjhi3m6uPjmBCzrnR8fnmC3rQLTGKsb2CvzeTioqKCqjOTcCQrVaKHnyImsWLAfjPEIn3R0jcXVXJjTVWNCMeUXo2adonUmIacDEs2kNSiYy9uhJjpBkhyxTNmoXkdrO2p0RSshVbcR+SL7qDEdnB8yA2JmYASsTJLUFltoOfrFdw9/k9T3lcoOkR2ZOHD5aTbXfy84Drgj6R2EukSc/v+v12xL9UVFTOfc6Nu2snw1lSwsHrb6Bm8WJcGpg7TsPiCwX/LC3jZn0Kmj8uhQv+2m6ODUDf86/mRCRoBez5dj4AVZ99hn3DRmx6+HKkYEqZhsWZD3PnyOBKejWn5+Gt8fq5p8RIN6SOupUwY3D76qLLIAZWRbHZMoLxwwcF2hwVFRWVTovq3HQw1i1b2X/11di2baM6BJ68Voulp4OPjhYzqN9NcPsKSOnf7nbkdk2kKFnJnzi84mtcFRUUzfkbAB+dr2GavZKXQ+7n6euGBV3Dwa5d+lAcrfz/tr5udrqv4A8FwddRuzF9e6QxPf51ioY+fk4kEquoqKicqwT3T91ORvXixRx9YAbY7RyOgzlXaZhINdeU6Yi59t+QdVGH2WLQaahKjoCd1Wh3HKJozrNIVbUcSABDtoV1J37PX+66NmB6NqciKbkbf78cdBYNoyJdRI68A4Mu+P30cKOOhX8+P9BmqKioqHR6gv+J0AkQQlD26qscvfcvYLezoZvEc5Nhlv04OdV90N2xCk0HOjZe3N0UzZKkw3bqPvsCgM9GQ0F5V/KufIieQVr2G2+O5Pc6G4PjaqiUJ3LZwLZPuFZRUVHpaL7//nsuv/xyUlJSkCSJzz//3G+/EIKZM2eSnJxMSEgIo0ePZvfu3X5jysvLmTx5MpGRkZjNZm655RZqa2v9xvzyyy+cf/75mEwmUlNTmTNnTntPrcNRnZt2RrbZOPI/0zn+8isALBwssfhyF/9bVs0XdX8k7sb3MMcFpq9Qav5Eakyg8ySwfNtfYoLBwa6BzzK+X5eA2NQSdFoNu92TCTteQK/xd6MNsmUzFRUVlbOhrq6Ofv368aqngrYxc+bM4aWXXuK1115jzZo1hIWFMWbMGGw2m2/M5MmT2bZtG0uWLGHhwoV8//333Hbbbb791dXVXHLJJaSnp7N+/Xqee+45Zs2axRtvvNHu8+tQxG+MqqoqAYiqqqp2P5ejpETs/P1EsT07R/ySmyPuvjdPPPtimvj+kQJx56ufi/1lte1uw6k4crxKfDwuR2zPzhGr++eIZ+ZkiMdfek04Xe6A2tUSth2tEt9sKw60GSoqKkGG1WoV27dvF1arNdCmtApAfPbZZ76/ZVkWSUlJ4rnnnvNtq6ysFEajUXzwwQdCCCG2b98uAPHzzz/7xnz11VdCkiRx9OhRIYQQ//u//yuio6OF3W73jXnggQdEdna27++pU6eKCRMmiKefflokJCSIqKgo8fjjjwun0yn++te/iujoaNGlSxfx1ltv+Y7Zv3+/AMSHH34ohg8fLkwmkxg0aJDYuXOnWLt2rcjPzxdhYWFi7NixorS0tNl5n+r6ncnzW43ctBPWbdvY9fuJuLftoMYEf58kMTapCnHidxwa/wEv/+l3ZAS4AWFKTAR7c3WUh8PHl4DZPpK7brrxnChRzkuJDOpO2ioqKsGDEALZYgnIS/FTWs/+/fspLi5m9OjRvm1RUVEUFBSwatUqAFatWoXZbGbQoPpqzNGjR6PRaFizZo1vzAUXXIDBUK8JNmbMGHbu3ElFRYVv27JlyygqKuL777/n+eef57HHHuOyyy4jOjqaNWvW8Kc//Ynbb7+dI0eO+Nn52GOP8cgjj7BhwwZ0Oh3XXXcd999/Py+++CI//PADe/bsYebMmW3ymZwKNaG4HahcvJgj99+H1uHiSCx8PEFmqs3AUvPfufP235ESJJUykiQRn9aLD25Zx/knosm54Tliw42nP1BFRUXlHEJYrewcmB+Qc2dvWI8U2noB1OLiYgASE/1/1CUmJvr2FRcXk5Dgr0mm0+mIiYnxG5OZmXnSe3j3RUcrpagxMTG89NJLaDQasrOzmTNnDhaLhYceegiABx98kL/97W/8+OOPXHPNNb73+utf/8qYMYr6+j333MO1117L0qVLGTZsGAC33HIL8+bNa/XncTpU56YNEUJw+JUXqHv1TbTApkyJfaOsDKobRtW4J3hyUGbQyddnDn+MsoVvEjbmFvqlxwbaHBUVFRWVIKBXr15oNPVR/MTERHr37u37W6vVEhsbS2lpqd9xffv29TsGoE+fPn7bGh/THqjOTRsh22xsn34H2mWrAfg6H6L7uggxP8oVt08mPiI4IyIjB+YycuDzgTZDRUVFpd2QQkLI3rA+YOduC5KSlPYnJSUlJCcn+7aXlJTQv39/35jGjoPL5aK8vNx3fFJSEiUlJX5jvH97xwDo9f4yIJIkNblNlmW/bQ3HeH/MN97W+Jj2QHVu2ogfXn2AhGWrcWngy4sEiSmZdLnkRaYOCO6WACoqKiqdHUmS2mRpKJBkZmaSlJTE0qVLfc5MdXU1a9as4Y477gCgsLCQyspK1q9fT36+sgy3bNkyZFmmoKDAN+bhhx/G6XT6nI4lS5aQnZ3tW5LqDARF5uirr75KRkYGJpOJgoIC1q5de8rxH3/8MTk5OZhMJvr06cOiRYs6yNLmqerZhxX9YfHv3MT3/yNX3fsFo1XHRkVFRUWlhdTW1rJp0yY2bdoEKEnEmzZt4tChQ0iSxL333stTTz3Fl19+yZYtW5gyZQopKSlMnDgRgNzcXMaOHcutt97K2rVr+emnn5g2bRrXXHMNKSlKf7jrrrsOg8HALbfcwrZt2/jwww958cUXmT59eoBm3T4E3Ln58MMPmT59Oo899hgbNmygX79+jBkzptk1uZUrV3Lttddyyy23sHHjRiZOnMjEiRPZunVrB1vuz2Xjb0Ez4gqGTvo3t/3xr5hDg7c7tYqKiopK8LFu3ToGDBjAgAEDAJg+fToDBgzwVRfdf//9/PnPf+a2225j8ODB1NbWsnjxYkwmk+895s+fT05ODqNGjWLcuHEMHz7cT8MmKiqKb775hv3795Ofn8///M//MHPmTD8tnM6AJNqqTu0sKSgoYPDgwbzyiiJyJ8syqamp/PnPf2bGjBknjZ80aRJ1dXUsXLjQt+28886jf//+vPbaa6c9X3V1NVFRUVRVVREZGdl2E1FRUVFRCTg2m439+/eTmZnp99BXOTc41fU7k+d3QCM3DoeD9evX+9XtazQaRo8e7avbb8yqVav8xoNSo9/ceLvdTnV1td9LRUVFRUVFpfMSUOfm+PHjuN3uU9btN6a4uPiMxs+ePZuoqCjfKzU1tW2MV1FRUVFRUQlKAp5z0948+OCDVFVV+V6HDx8OtEkqKioqKioq7UhAS8Hj4uLQarVN1tw3rLdvSHM1+s2NNxqNGI3BqTGjoqKioqKi0vYENHJjMBjIz89n6dKlvm2yLLN06VIKCwubPKawsNBvPCg1+s2NV1FRUVFRUfltEXARv+nTpzN16lQGDRrEkCFD+Mc//kFdXR033XQTAFOmTKFLly7Mnj0bUHpVXHjhhfz9739n/PjxLFiwgHXr1nW+du0qKioqKmdNR6jgqrQ9bVXAHXDnZtKkSZSVlTFz5kyKi4vp378/ixcv9iUNHzp0yK+/xdChQ3n//fd55JFHeOihh8jKyuLzzz/363mhoqKiovLbxGAwoNFoKCoqIj4+HoPBEHQ9/VSaRghBWVlZk60ezpSA69x0NKrOjYqKikrnxuFwcOzYMSwWS6BNUTlDJEmia9euhIeHn7TvTJ7fAY/cqKioqKiotCUGg4G0tDRcLhdutzvQ5qicAXq9Hq1W2+r3UZ0bFRUVFZVOh3dpo7XLGyrnJp1e50ZFRUVFRUXlt4Xq3KioqKioqKh0KlTnRkVFRUVFRaVT8ZvLufEWh6kNNFVUVFRUVM4dvM/tlhR5/+acm5qaGgC1gaaKioqKiso5SE1NDVFRUacc85vTuZFlmaKiIiIiItpc2Km6uprU1FQOHz7caTV01Dl2DtQ5dg7UOXYO1Dm2DCEENTU1pKSk+In7NsVvLnKj0Wjo2rVru54jMjKy0/4D9aLOsXOgzrFzoM6xc6DO8fScLmLjRU0oVlFRUVFRUelUqM6NioqKioqKSqdCdW7aEKPRyGOPPYbRaAy0Ke2GOsfOgTrHzoE6x86BOse25zeXUKyioqKioqLSuVEjNyoqKioqKiqdCtW5UVFRUVFRUelUqM6NioqKioqKSqdCdW5UVFRUVFRUOhWqc9NGvPrqq2RkZGAymSgoKGDt2rWBNqlVfP/991x++eWkpKQgSRKff/65334hBDNnziQ5OZmQkBBGjx7N7t27A2PsWTB79mwGDx5MREQECQkJTJw4kZ07d/qNsdls3HXXXcTGxhIeHs6VV15JSUlJgCw+c+bOnUvfvn19olmFhYV89dVXvv3n+vya4m9/+xuSJHHvvff6tnWGec6aNQtJkvxeOTk5vv2dYY5Hjx7l+uuvJzY2lpCQEPr06cO6det8+8/1ew5ARkbGSddRkiTuuusuoHNcR7fbzaOPPkpmZiYhISF0796dJ5980q8fVIdcS6HSahYsWCAMBoN46623xLZt28Stt94qzGazKCkpCbRpZ82iRYvEww8/LD799FMBiM8++8xv/9/+9jcRFRUlPv/8c7F582bxu9/9TmRmZgqr1RoYg8+QMWPGiLffflts3bpVbNq0SYwbN06kpaWJ2tpa35g//elPIjU1VSxdulSsW7dOnHfeeWLo0KEBtPrM+PLLL8V///tfsWvXLrFz507x0EMPCb1eL7Zu3SqEOPfn15i1a9eKjIwM0bdvX3HPPff4tneGeT722GOiV69e4tixY75XWVmZb/+5Psfy8nKRnp4ubrzxRrFmzRqxb98+8fXXX4s9e/b4xpzr9xwhhCgtLfW7hkuWLBGAWL58uRDi3L+OQgjx9NNPi9jYWLFw4UKxf/9+8fHHH4vw8HDx4osv+sZ0xLVUnZs2YMiQIeKuu+7y/e12u0VKSoqYPXt2AK1qOxo7N7Isi6SkJPHcc8/5tlVWVgqj0Sg++OCDAFjYekpLSwUgVqxYIYRQ5qPX68XHH3/sG/Prr78KQKxatSpQZraa6Oho8c9//rPTza+mpkZkZWWJJUuWiAsvvNDn3HSWeT722GOiX79+Te7rDHN84IEHxPDhw5vd3xnvOUIIcc8994ju3bsLWZY7xXUUQojx48eLm2++2W/b73//ezF58mQhRMddS3VZqpU4HA7Wr1/P6NGjfds0Gg2jR49m1apVAbSs/di/fz/FxcV+c46KiqKgoOCcnXNVVRUAMTExAKxfvx6n0+k3x5ycHNLS0s7JObrdbhYsWEBdXR2FhYWdbn533XUX48eP95sPdK7ruHv3blJSUujWrRuTJ0/m0KFDQOeY45dffsmgQYO4+uqrSUhIYMCAAbz55pu+/Z3xnuNwOHjvvfe4+eabkSSpU1xHgKFDh7J06VJ27doFwObNm/nxxx+59NJLgY67lr+5xpltzfHjx3G73SQmJvptT0xMZMeOHQGyqn0pLi4GaHLO3n3nErIsc++99zJs2DB69+4NKHM0GAyYzWa/sefaHLds2UJhYSE2m43w8HA+++wz8vLy2LRpU6eYH8CCBQvYsGEDP//880n7Ost1LCgoYN68eWRnZ3Ps2DEef/xxzj//fLZu3dop5rhv3z7mzp3L9OnTeeihh/j555+5++67MRgMTJ06tdPdcwA+//xzKisrufHGG4HO8291xowZVFdXk5OTg1arxe128/TTTzN58mSg454fqnOj8pvnrrvuYuvWrfz444+BNqXNyc7OZtOmTVRVVfHJJ58wdepUVqxYEWiz2ozDhw9zzz33sGTJEkwmU6DNaTe8v3oB+vbtS0FBAenp6Xz00UeEhIQE0LK2QZZlBg0axDPPPAPAgAED2Lp1K6+99hpTp04NsHXtw7/+9S8uvfRSUlJSAm1Km/LRRx8xf/583n//fXr16sWmTZu49957SUlJ6dBrqS5LtZK4uDi0Wu1JGe0lJSUkJSUFyKr2xTuvzjDnadOmsXDhQpYvX07Xrl1925OSknA4HFRWVvqNP9fmaDAY6NGjB/n5+cyePZt+/frx4osvdpr5rV+/ntLSUgYOHIhOp0On07FixQpeeukldDodiYmJnWKejTGbzfTs2ZM9e/Z0imuZnJxMXl6e37bc3Fzf0ltnuucAHDx4kG+//ZY//vGPvm2d4ToC3HfffcyYMYNrrrmGPn36cMMNN/CXv/yF2bNnAx13LVXnppUYDAby8/NZunSpb5ssyyxdupTCwsIAWtZ+ZGZmkpSU5Dfn6upq1qxZc87MWQjBtGnT+Oyzz1i2bBmZmZl++/Pz89Hr9X5z3LlzJ4cOHTpn5tgUsixjt9s7zfxGjRrFli1b2LRpk+81aNAgJk+e7Pv/zjDPxtTW1rJ3716Sk5M7xbUcNmzYSVIMu3btIj09Hegc95yGvP322yQkJDB+/Hjfts5wHQEsFgsajb9rodVqkWUZ6MBr2Wapyb9hFixYIIxGo5g3b57Yvn27uO2224TZbBbFxcWBNu2sqampERs3bhQbN24UgHj++efFxo0bxcGDB4UQSimf2WwWX3zxhfjll1/EhAkTzqmyzDvuuENERUWJ7777zq8002Kx+Mb86U9/EmlpaWLZsmVi3bp1orCwUBQWFgbQ6jNjxowZYsWKFWL//v3il19+ETNmzBCSJIlvvvlGCHHuz685GlZLCdE55vk///M/4rvvvhP79+8XP/30kxg9erSIi4sTpaWlQohzf45r164VOp1OPP3002L37t1i/vz5IjQ0VLz33nu+Mef6PceL2+0WaWlp4oEHHjhp37l+HYUQYurUqaJLly6+UvBPP/1UxMXFifvvv983piOuperctBEvv/yySEtLEwaDQQwZMkSsXr060Ca1iuXLlwvgpNfUqVOFEEo536OPPioSExOF0WgUo0aNEjt37gys0WdAU3MDxNtvv+0bY7VaxZ133imio6NFaGiouOKKK8SxY8cCZ/QZcvPNN4v09HRhMBhEfHy8GDVqlM+xEeLcn19zNHZuOsM8J02aJJKTk4XBYBBdunQRkyZN8tOA6Qxz/M9//iN69+4tjEajyMnJEW+88Ybf/nP9nuPl66+/FkCTtneG61hdXS3uuecekZaWJkwmk+jWrZt4+OGHhd1u943piGspCdFANlBFRUVFRUVF5RxHzblRUVFRUVFR6VSozo2KioqKiopKp0J1blRUVFRUVFQ6Fapzo6KioqKiotKpUJ0bFRUVFRUVlU6F6tyoqKioqKiodCpU50ZFRUVFRUWlU6E6NyoqKioqKiqdCtW5UVFRUVFRUelUqM6NioqKioqKSqdCdW5UVFRUVFRUOhWqc6OioqKioqLSqfj/P+oIXa+XuloAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# number per line = total / 4\n", - "# 0 - (num-1), num - (2num-1), etc \n", - "# \n", - "num = int(len(parametric.results) / 4)\n", - "# print(num_per_cable)\n", - "\n", - "# num = num_per_cable / 10\n", - "# print(num)\n", - "\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[0:num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[num:2*num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[2*num:3*num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[3*num:4*num])\n", - "plt.legend([\"500mm\",\"630mm\",\"800mm\",\"1000mm\"], loc = \"lower right\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "0846621f-977c-4334-a263-4fda8b6ad271", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "80\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Cable Cost ($)')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "num_per_cable = int(len(parametric.results) / 4)\n", - "print(num_per_cable)\n", - "\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[0:num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[num:2*num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[2*num:3*num])\n", - "plt.plot(np.arange(num), parametric.results.cable_cost[3*num:4*num])\n", - "plt.legend([\"500mm\",\"630mm\",\"800mm\",\"1000mm\"], loc = \"lower right\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "# plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4acefb99-f145-44b3-85e0-ae270faf3bfd", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a2185809-c073-4e06-8616-27a5386df5e3", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/define_configs.ipynb b/define_configs.ipynb deleted file mode 100644 index 40b9c58e..00000000 --- a/define_configs.ipynb +++ /dev/null @@ -1,326 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "23ea6c69-4587-48a5-a1ac-b03074bde7c5", - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy\n", - "import pandas as pd\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "id": "0fb9f171-4f25-4d8c-b12b-b5606a9d3afe", - "metadata": {}, - "source": [ - "### Example: Bay State Wind" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0fc89ffb-5881-4c91-bff1-446a29d0b18d", - "metadata": {}, - "outputs": [], - "source": [ - "base = {\n", - " \"site\": {\n", - " \"distance\": 65,\n", - " \"depth\": 43,\n", - " \"distance_to_landfall\": 33\n", - " },\n", - " \"plant\": {\n", - " \"capacity\": 2277\n", - " },\n", - " \"turbine\": {\n", - " \"turbine_rating\": 15\n", - " },\n", - " \"install_phases\": [\n", - " \"ExportCableInstallation\",\n", - " \"ArrayCableInstallation\",\n", - " \"OffshoreSubstationInstallation\"\n", - " ],\n", - " \"design_phases\": [\n", - " \"ElectricalDesign\"\n", - " ],\n", - " \"array_system\": {\n", - " \"cables\": [\"XPLE_630mm_66kV\"],\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dc607c35-6e45-498b-8434-76c465f4c04c", - "metadata": {}, - "outputs": [], - "source": [ - "standard_base = {\n", - " **base,\n", - " \"export_system_design\": {\n", - " \"cables\": [\"XPLE_500mm_220kV\"],\n", - " }\n", - "}\n", - "\n", - "backbone_base = {\n", - " **base,\n", - " \"export_system_design\": {\n", - " \"cables\": [\"XPLE_500mm_220kV\"],\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "54233cfc-8237-40c0-96e6-9c287e997b5c", - "metadata": {}, - "outputs": [], - "source": [ - "standard_configs = []\n", - "backbone_configs = []\n", - "\n", - "for i in range(10,100,10):\n", - " \n", - " sconfig = deepcopy(standard_base)\n", - " sconfig[\"site\"][\"distance_to_landfall\"] = i\n", - "\n", - " standard_configs.append(sconfig)\n", - "\n", - " \n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5a8763bf-df12-41ae-9b52-b5bfb52145cd", - "metadata": {}, - "outputs": [], - "source": [ - "# standard_configs" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "61d1f971-66c5-43ea-8622-850135382a13", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import load_config, save_config" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "c0840454-6ef6-43f7-a65b-9d6ece99b13e", - "metadata": {}, - "outputs": [], - "source": [ - "# for config in standard_configs:\n", - "# dist = str(config[\"site\"][\"distance_to_landfall\"])\n", - "# filename = \"bay_state_%sm\" % dist\n", - "# print(filename)\n", - "# save_config(config, \"C:/Users/sbredenk/ORBIT/shared_transmission_configs/%s.yaml\" % filename, overwrite=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8f599f36-f68e-4f22-87a9-3497ff54b771", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on function save_config in module ORBIT.config:\n", - "\n", - "save_config(config, filepath, overwrite=False)\n", - " Save an ORBIT `config` to `filepath`.\n", - " \n", - " Parameters\n", - " ----------\n", - " config : dict\n", - " ORBIT configuration.\n", - " filepath : str\n", - " Location to save config.\n", - " overwrite : bool (optional)\n", - " Overwrite file if it already exists. Default: False.\n", - "\n" - ] - } - ], - "source": [ - "help(save_config)" - ] - }, - { - "cell_type": "markdown", - "id": "bfb4726a-4123-4177-9663-55e9628afb07", - "metadata": {}, - "source": [ - "### Save Base Cases" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6e3c934e-8993-47fd-b7d8-387d5c36c4d0", - "metadata": {}, - "outputs": [], - "source": [ - "base = {\n", - " \"site\": {\n", - " \"distance\": 65,\n", - " \"depth\": 43,\n", - " \"distance_to_landfall\": 33\n", - " },\n", - " \"plant\": {\n", - " \"capacity\": 2277\n", - " },\n", - " \"turbine\": {\n", - " \"turbine_rating\": 15\n", - " },\n", - " \"install_phases\": {\n", - " \"ExportCableInstallation\",\n", - "# \"ArrayCableInstallation\",\n", - " \"OffshoreSubstationInstallation\"\n", - " },\n", - " \"export_cable_install_vessel\": \"example_cable_lay_vessel\",\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " \"design_phases\": {\n", - " \"ElectricalDesign\"\n", - " },\n", - " \"array_system\": {\n", - " \"cables\": [\"XLPE_630mm_66kV\"],\n", - " },\n", - " \"export_system_design\": {\n", - " \"cables\": \"XLPE_630mm_220kV\",\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "632b2056-28e7-45ee-9a87-b055c2d9792e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[15, 15, 12, 15, 15, 15, 15, 8, 11, 11, 12, 12, 15, 15, 15, 12, 14, 10, 12, 12, 15, 15, 15, 15, 15, 15, 15, 15, 15]\n" - ] - } - ], - "source": [ - "df = pd.read_excel(\"C:/Users/sbredenk/ORBIT/osw_project_details.xlsx\",sheet_name=0)\n", - "proj_name = df['name'].to_list()\n", - "cap = df['capacity'].to_list()\n", - "turbine_rating = df['turbine'].to_list()\n", - "distance = df['distance_to_site_(km)'].to_list()\n", - "distance_to_landfall = df['distance_to_shore'].to_list()\n", - "print(turbine_rating)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "bd832314-03dc-4b90-8254-93c38269d836", - "metadata": {}, - "outputs": [], - "source": [ - "# help(pd.read_excel)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "1761dd4e-3b43-4d60-8435-0eca1a9753b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'site': {'distance': 668, 'depth': 43, 'distance_to_landfall': nan}, 'plant': {'capacity': 400}, 'turbine': {'turbine_rating': 15}, 'install_phases': {'OffshoreSubstationInstallation', 'ExportCableInstallation'}, 'export_cable_install_vessel': 'example_cable_lay_vessel', 'oss_install_vessel': 'example_heavy_lift_vessel', 'feeder': 'future_feeder', 'design_phases': {'ElectricalDesign'}, 'array_system': {'cables': ['XLPE_630mm_66kV']}, 'export_system_design': {'cables': 'XLPE_630mm_220kV'}}\n" - ] - } - ], - "source": [ - "# Save base config for each project\n", - "base_configs = []\n", - "filename = deepcopy(proj_name)\n", - "for i in range(0,len(proj_name)):\n", - " filename[i] = \"%s base.yaml\" % proj_name[i]\n", - " b_config = deepcopy(base)\n", - " b_config[\"plant\"][\"capacity\"] = cap[i]\n", - " b_config[\"turbine\"][\"turbine_rating\"] = turbine_rating[i]\n", - " b_config[\"site\"][\"distance\"] = distance[i]\n", - " b_config[\"site\"][\"distance_to_landfall\"] = distance_to_landfall[i]\n", - " \n", - " save_config(b_config, \"C:/Users/sbredenk/ORBIT/shared_transmission_configs/%s\" % filename[i], overwrite = True) \n", - "print(b_config) " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "29eca601-511f-41ec-ad6c-7ca673324c00", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Bay State Wind', 'Park City Wind', 'Vineyard Wind', 'Beacon Wind', 'Mayflower Wind 1', 'Mayflower Wind 2', 'Liberty Wind', 'Sunrise Wind', 'Revolution Wind (CT)', 'Revolution Wind (RI)', 'South Fork', 'Empire Wind', 'Empire Wind 2', 'Atlantic Shores Offshore Wind 1', 'Atlantic Shores Offshore Wind 2', 'Ocean Wind 1', 'Ocean Wind 2', 'Garden State Offshore Energy', 'Skipjack', 'MarWin', 'CVOW Commercial', 'Kitty Hawk', 'Vineyard Wind South', 'Mayflower Res', 'Ocean Wind Res', 'Hudson North WEA', 'Hudson South WEA', 'Momentum Wind', 'TBD SC Lease']\n", - "['Bay State Wind base.yaml', 'Park City Wind base.yaml', 'Vineyard Wind base.yaml', 'Beacon Wind base.yaml', 'Mayflower Wind 1 base.yaml', 'Mayflower Wind 2 base.yaml', 'Liberty Wind base.yaml', 'Sunrise Wind base.yaml', 'Revolution Wind (CT) base.yaml', 'Revolution Wind (RI) base.yaml', 'South Fork base.yaml', 'Empire Wind base.yaml', 'Empire Wind 2 base.yaml', 'Atlantic Shores Offshore Wind 1 base.yaml', 'Atlantic Shores Offshore Wind 2 base.yaml', 'Ocean Wind 1 base.yaml', 'Ocean Wind 2 base.yaml', 'Garden State Offshore Energy base.yaml', 'Skipjack base.yaml', 'MarWin base.yaml', 'CVOW Commercial base.yaml', 'Kitty Hawk base.yaml', 'Vineyard Wind South base.yaml', 'Mayflower Res base.yaml', 'Ocean Wind Res base.yaml', 'Hudson North WEA base.yaml', 'Hudson South WEA base.yaml', 'Momentum Wind base.yaml', 'TBD SC Lease base.yaml']\n" - ] - } - ], - "source": [ - "print(proj_name)\n", - "print(filename)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7fe29d7f-f3f4-4b32-b3e3-7e0227753509", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/gut_check_runs.ipynb b/gut_check_runs.ipynb deleted file mode 100644 index fc601cae..00000000 --- a/gut_check_runs.ipynb +++ /dev/null @@ -1,231 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "91b54f6c-aae3-40b8-861a-1bf35db84b75", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import ElectricalDesign\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ade5f020-f39a-457d-9210-cfd3d288412e", - "metadata": {}, - "outputs": [], - "source": [ - "config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 34, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': 98, 'capacity': 597.8},\n", - " 'turbine': {'turbine_rating': 6.1},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_630mm_33kV\",\n", - "# 'num_redundant': 'int (optional)',\n", - "# 'touchdown_distance': 'm (optional, default: 0)',\n", - "# 'percent_added_length': 'float (optional)'\n", - " },\n", - "# 'substation_design': {\n", - "# 'mpt_cost_rate': 'USD/MW (optional)',\n", - "# 'topside_fab_cost_rate': 'USD/t (optional)',\n", - "# 'topside_design_cost': 'USD (optional)',\n", - "# 'shunt_cost_rate': 'USD/MW (optional)',\n", - "# 'switchgear_costs': 'USD (optional)',\n", - "# 'backup_gen_cost': 'USD (optional)',\n", - "# 'workspace_cost': 'USD (optional)',\n", - "# 'other_ancillary_cost': 'USD (optional)',\n", - "# 'topside_assembly_factor': 'float (optional)',\n", - "# 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - "# 'oss_pile_cost_rate': 'USD/t (optional)',\n", - "# 'num_substations': 'int (optional)'\n", - "# },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "9072176e-a61b-4c00-997a-85bec06f786e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - }, - { - "data": { - "text/plain": [ - "{'Export System': 357979500.0,\n", - " 'Offshore Substation': 83517917.74312852,\n", - " 'Export System Installation': 132656741.80730619,\n", - " 'Offshore Substation Installation': 3126797.6636225265,\n", - " 'Turbine': 777140000.0,\n", - " 'Soft': 385580999.99999994,\n", - " 'Project': 151250000.0}" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project = ProjectManager(config)\n", - "project.run()\n", - "project.capex_breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3bc09aff-2233-43e7-8c5c-6dfdb37d221f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'export_system': {'system_cost': 357979500.0,\n", - " 'cable': {'linear_density': 42.5,\n", - " 'sections': [53.034],\n", - " 'number': 15,\n", - " 'cable_power': 40.01037362112721}},\n", - " 'offshore_substation_substructure': {'type': 'Monopile',\n", - " 'deck_space': 1,\n", - " 'mass': 1698.496367544677,\n", - " 'length': 44,\n", - " 'unit_cost': 3807000.0},\n", - " 'offshore_substation_topside': {'deck_space': 1,\n", - " 'mass': 3172.5,\n", - " 'unit_cost': 79710917.74312852},\n", - " 'num_substations': 1}" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.phases[\"ElectricalDesign\"]._outputs\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "94ba321a-3a46-4cb6-a466-2c93397d6d3a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "electrical system: 23003179.295933507\n", - "structure: 54308250.0\n", - "facility: 6000000.0\n", - "land assembly: 206488.4471950132\n" - ] - } - ], - "source": [ - "elec_cost = (\n", - " project.phases[\"ElectricalDesign\"].mpt_cost\n", - " + project.phases[\"ElectricalDesign\"].shunt_reactor_cost\n", - " + project.phases[\"ElectricalDesign\"].switchgear_costs\n", - ")\n", - "print(\"electrical system: \", elec_cost)\n", - "\n", - "struct_cost = (\n", - " project.phases[\"ElectricalDesign\"].topside_cost\n", - " + project.phases[\"ElectricalDesign\"].substructure_cost\n", - ")\n", - "print(\"structure: \",struct_cost)\n", - "\n", - "print(\"facility: \", project.phases[\"ElectricalDesign\"].ancillary_system_cost)\n", - "print(\"land assembly: \", project.phases[\"ElectricalDesign\"].land_assembly_cost)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ca180f7b-6a49-44b1-a082-316783101acd", - "metadata": {}, - "outputs": [], - "source": [ - "design = ElectricalDesign(config)\n", - "design.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "38e3babe-2b1d-4fec-afa6-e1b212ccb904", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "40.01037362112721" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "design.cable.cable_power" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb3857d3-6cd8-49e4-b40d-885ea746b19d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/hvdc_comparison.ipynb b/hvdc_comparison.ipynb deleted file mode 100644 index feca9925..00000000 --- a/hvdc_comparison.ipynb +++ /dev/null @@ -1,727 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "6672f27a-8604-4f5c-b885-028ab3425360", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f16c0c3a-d546-4d1a-a8cb-204c7d16a060", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 50\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - "# 'export_system_design': {\n", - "# 'cables': 'XLPE_500mm_220kV',\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a1bb5c31-9881-46d8-bb20-b40ecb487ab9", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - " 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1627fd49-5e96-45c8-8d40-05f3b2bab6ba", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - " 'num_substations': lambda run: run.num_substations\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "514e6a20-be60-4048-9094-d49f49a69a5e", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - }, - { - "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", - "
export_system_design.cablessite.distance_to_landfallplant.capacitycable_costoss_costnum_substations
0XLPE_1000m_220kV1510015317000.02.818467e+071
1XLPE_1000m_220kV1520015317000.03.488367e+071
2XLPE_1000m_220kV1530015317000.04.102442e+071
3XLPE_1000m_220kV1540030634000.05.468484e+071
4XLPE_1000m_220kV1550030634000.06.138384e+071
.....................
795XLPE_1200m_300kV_DC3001600506043400.04.106711e+082
796XLPE_1200m_300kV_DC3001700506043400.04.324526e+083
797XLPE_1200m_300kV_DC3001800759065100.05.774874e+083
798XLPE_1200m_300kV_DC3001900759065100.05.841864e+083
799XLPE_1200m_300kV_DC3002000759065100.05.908854e+083
\n", - "

800 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", - "0 XLPE_1000m_220kV 15 100 \n", - "1 XLPE_1000m_220kV 15 200 \n", - "2 XLPE_1000m_220kV 15 300 \n", - "3 XLPE_1000m_220kV 15 400 \n", - "4 XLPE_1000m_220kV 15 500 \n", - ".. ... ... ... \n", - "795 XLPE_1200m_300kV_DC 300 1600 \n", - "796 XLPE_1200m_300kV_DC 300 1700 \n", - "797 XLPE_1200m_300kV_DC 300 1800 \n", - "798 XLPE_1200m_300kV_DC 300 1900 \n", - "799 XLPE_1200m_300kV_DC 300 2000 \n", - "\n", - " cable_cost oss_cost num_substations \n", - "0 15317000.0 2.818467e+07 1 \n", - "1 15317000.0 3.488367e+07 1 \n", - "2 15317000.0 4.102442e+07 1 \n", - "3 30634000.0 5.468484e+07 1 \n", - "4 30634000.0 6.138384e+07 1 \n", - ".. ... ... ... \n", - "795 506043400.0 4.106711e+08 2 \n", - "796 506043400.0 4.324526e+08 3 \n", - "797 759065100.0 5.774874e+08 3 \n", - "798 759065100.0 5.841864e+08 3 \n", - "799 759065100.0 5.908854e+08 3 \n", - "\n", - "[800 rows x 6 columns]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric.run()\n", - "parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "markdown", - "id": "541a0f21-04e4-4125-8d2c-0fa20a7eb357", - "metadata": { - "tags": [] - }, - "source": [ - "# Varying plant capacity for given distance to shore" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "470c2710-2fd8-418a-bcc0-61bca7825eaf", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "400\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHACAYAAABeV0mSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABC0UlEQVR4nO3deVyVdf7//+cRWVUWF0CQwN3ccUMyt4kRtbGcKT8uTZrbtFmWlWaLllNpORqf1LSZXHKmxSWzz7ccG0PNjdERxbLU1NxSwBUQQUF4//7w55lOgHL04IGLx/12O7cb57re13Ve73Mh19P3tdmMMUYAAAAWUcXdBQAAALgS4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFgK4QYAAFhKpQ43GzZsUL9+/RQWFiabzaaVK1c6vY6lS5eqbdu28vPzU2RkpKZPn+76QgEAQKlV6nBz4cIFtWnTRnPmzLmh5f/5z3/qgQce0COPPKLdu3fr3Xff1dtvv63Zs2e7uFIAAFBaNh6ceYXNZtNnn32m/v3726ddunRJL774oj7++GNlZGSoZcuWevPNN9WjRw9J0pAhQ5Sfn69ly5bZl5k1a5beeustHT16VDab7Rb3AgAAVOqRm+sZM2aMkpKS9Mknn+jbb7/VgAED1Lt3b+3fv1/SlfDj4+PjsIyvr69+/vlnHTlyxB0lAwBQ6RFuSnD06FEtXLhQy5YtU9euXdWwYUM9++yzuvPOO7Vw4UJJUnx8vFasWKHExEQVFhbqxx9/1IwZMyRJqamp7iwfAIBKq6q7CyivvvvuOxUUFKhJkyYO0y9duqRatWpJkkaPHq2DBw/qd7/7nfLz8+Xv76+xY8fqlVdeUZUq5EYAANyBcFOC7OxseXh4KDk5WR4eHg7zqlevLunKeTpvvvmm3njjDaWlpalOnTpKTEyUJDVo0OCW1wwAAAg3JYqOjlZBQYFOnjyprl27XrOth4eHwsPDJUkff/yxYmNjVadOnVtRJgAA+JVKHW6ys7N14MAB+/tDhw4pJSVFNWvWVJMmTfTAAw9o6NChmjFjhqKjo3Xq1CklJiaqdevWuvvuu3X69GktX75cPXr00MWLF+3n6HzzzTdu7BUAAJVbpb4UfP369erZs2eR6cOGDdOiRYuUn5+v1157TYsXL9bx48dVu3Ztde7cWa+++qpatWql06dPq1+/fvruu+9kjFFsbKxef/11xcTEuKE3AABAquThBgAAWA+X9AAAAEsh3AAAAEupdCcUFxYW6sSJE6pRowaPRwAAoIIwxuj8+fMKCwu77r3kKl24OXHihCIiItxdBgAAuAHHjh1TvXr1rtmm0oWbGjVqSLry5fj7+7u5GgAAUBpZWVmKiIiw78evpdKFm6uHovz9/Qk3AABUMKU5pYQTigEAgKUQbgAAgKUQbgAAgKVUunNuSqugoED5+fnuLsOSPD09izxpHQAAVyHc/IoxRmlpacrIyHB3KZYWGBio0NBQ7jUEAHA5ws2vXA02wcHB8vPzY+frYsYY5eTk6OTJk5KkunXrurkiAIDVEG5+oaCgwB5satWq5e5yLMvX11eSdPLkSQUHB3OICgDgUpxQ/AtXz7Hx8/NzcyXWd/U75rwmAICrEW6KwaGossd3DAAoK4QbAABgKYQbAABgKYQbi3jooYfUv3//ItPXr18vm82mTz/9VB4eHjp+/Hixyzdu3Fjjxo2zv09KSpKHh4fuvvvuYtvn5eXprbfeUps2beTn56fatWurS5cuWrhwIefRAADcinBTSXTr1k21atXSBx98UGTehg0bdODAAY0cOdI+bf78+XriiSe0YcMGnThxwqF9Xl6e4uPjNW3aNP3pT3/Sli1btG3bNj3++OOaNWuWvv/++zLvDwAAJeFS8ErC09NTDz74oBYtWqQXXnjBYd6CBQsUExOjFi1aSJKys7O1ZMkSbd++XWlpaUWWSUhI0IYNG7R9+3ZFR0fbpzdo0EADBgxQXl7erekUAADFYOTmOowxysm77JaXMcalfRk5cqT279+vDRs22KdlZ2dr+fLlDqM2S5cuVbNmzdS0aVP98Y9/1IIFCxxq+fDDDxUXF+cQbK7y9PRUtWrVXFo3AADOYOTmOnLzC9R80ldu+ewfpsTLz6v0m+iLL75Q9erVHaYVFBTYf27evLk6d+6sBQsWqFu3bpKuBBljjAYNGmRvN3/+fP3xj3+UJPXu3VuZmZn65ptv1KNHD0nS/v377T8DAFDeMHJjIT179lRKSorD6/3333doM2LECC1fvlznz5+XdOWQ1IABA1SjRg1J0r59+7Rt2zYNHjxYklS1alUNHDhQ8+fPt6/D1SNKAAC4EiM31+Hr6aEfpsS77bOdUa1aNTVq1Mhh2s8//+zwftCgQXr66ae1dOlSdevWTZs3b9bUqVPt8+fPn6/Lly8rLCzMPs0YI29vb82ePVsBAQFq0qSJ9u7dewM9AgCg7BFursNmszl1aKi8q1GjhgYMGKAFCxbo4MGDatKkibp27SpJunz5shYvXqwZM2aoV69eDsv1799fH3/8sR555BENGTJEL7zwgnbu3FnkvJv8/Hzl5eVx3g0AwG04LFUJjRw5Ulu2bNG8efM0YsQI+/QvvvhC586d08iRI9WyZUuH13333Wc/NPXUU0+pS5cuuuuuuzRnzhzt2rVLP/30k5YuXarOnTtr//797uoaAACEm8rozjvvVNOmTZWVlaWhQ4fap8+fP19xcXEKCAgossx9992n7du369tvv5W3t7fWrFmj8ePH67333lPnzp3VsWNHvfPOO3ryySfVsmXLW9kdAAAc2EwlOzs0KytLAQEByszMlL+/v8O8ixcv6tChQ6pfv758fHzcVGHlwHcNAHDGtfbfv8bIDQAAsBTCDQAAsBTCDQAAsBTCDQAAsBS3hpsNGzaoX79+CgsLk81m08qVK6+7zPr169WuXTt5e3urUaNGWrRoUZnXCQAAKg63hpsLFy6oTZs2mjNnTqnaHzp0SHfffbf9MQNPPfWURo0apa++cs+znwAAQPnj1lvv9unTR3369Cl1+3nz5ql+/fqaMWOGJOn222/Xpk2b9Pbbbys+3j2PSAAAAOVLhTrnJikpSXFxcQ7T4uPjlZSU5KaKAABAeVOhHpqUlpamkJAQh2khISHKyspSbm6ufH19iyxz6dIlXbp0yf4+KyurzOsEAADuU6FGbm7E1KlTFRAQYH9FRES4uyQAAFCGKlS4CQ0NVXp6usO09PR0+fv7FztqI0kTJ05UZmam/XXs2LFbUeot99BDD6l///5Fpq9fv142m02ffvqpPDw8dPz48WKXb9y4scaNGydJ6tGjh2w2m2w2m7y9vRUeHq5+/fppxYoVxS67bt069e3bV7Vq1ZKfn5+aN2+uZ555psTPAgCgLFWocBMbG6vExESHaWvWrFFsbGyJy3h7e8vf39/hVRl169ZNtWrV0gcffFBk3oYNG3TgwAGNHDnSPm306NFKTU3VwYMH9emnn6p58+YaNGiQ/vSnPzks+9577ykuLk6hoaH69NNP9cMPP2jevHnKzMy0n/gNAMCt5NZzbrKzs3XgwAH7+0OHDiklJUU1a9bUbbfdpokTJ+r48eNavHixJOmRRx7R7NmzNX78eI0YMUJr167V0qVL9eWXX7qrCxWGp6enHnzwQS1atEgvvPCCw7wFCxYoJiZGLVq0sE/z8/NTaGioJKlevXrq3LmzmjVrphEjRuh//ud/FBcXp59//llPPvmknnzySb399tv2ZaOiotStWzdlZGTckr4BAPBLbh252b59u6KjoxUdHS1JGjdunKKjozVp0iRJUmpqqo4ePWpvX79+fX355Zdas2aN2rRpoxkzZuj9998v28vAjZHyLrjn5eIHto8cOVL79+/Xhg0b7NOys7O1fPlyh1GbkgwbNkxBQUH2w1PLli1TXl6exo8fX2z7wMBAl9QNAIAz3Dpy06NHD5lr7MCLu/twjx49tHPnzjKs6lfyc6Q3wm7d5/3SCyckr2qlbv7FF1+oevXqDtMKCgrsPzdv3lydO3fWggUL1K1bN0nS0qVLZYzRoEGDrrv+KlWqqEmTJjp8+LAkaf/+/fL391fdunVLXSMAAGWtQp1zg2u7eufmX77ef/99hzYjRozQ8uXLdf78eUlXDkkNGDBANWrUKNVnGGNks9mK/AwAQHlRoe5z4xaefldGUNz12U6oVq2aGjVq5DDt559/dng/aNAgPf3001q6dKm6deumzZs3a+rUqaVaf0FBgfbv36+OHTtKkpo0aaLMzEylpqYyegMAKDcYubkem+3KoSF3vMpgVKRGjRoaMGCAFixYoIULF6pJkybq2rVrqZb94IMPdO7cOd13332SpPvvv19eXl566623im3PCcUAAHdg5KYSGjlypLp27ao9e/ZowoQJxbbJyclRWlqaLl++rJ9//lmfffaZ3n77bT366KPq2bOnJCkiIkJvv/22xowZo6ysLA0dOlRRUVH6+eeftXjxYlWvXp3LwQEAtxwjN5XQnXfeqaZNm9oDSXH+9re/qW7dumrYsKH+8Ic/6IcfftCSJUv07rvvOrR77LHH9K9//UvHjx/X73//ezVr1kyjRo2Sv7+/nn322VvRHQAAHNjMtS5XsqCsrCwFBAQoMzOzyA39Ll68qEOHDql+/fry8fFxU4WVA981AMAZ19p//xojNwAAwFIINwAAwFIINwAAwFIINwAAwFIIN8WoZOdYuwXfMQCgrBBufsHT01PSlXu8oGxd/Y6vfucAALgKN/H7BQ8PDwUGBurkyZOSJD8/P56d5GLGGOXk5OjkyZMKDAyUh4eHu0sCAFgM4eZXQkNDJckecFA2AgMD7d81AACuRLj5FZvNprp16yo4OFj5+fnuLseSPD09GbEBAJQZwk0JPDw82AEDAFABcUIxAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFMINAACwFLeHmzlz5igqKko+Pj6KiYnRtm3brtk+ISFBTZs2la+vryIiIvT000/r4sWLt6haAABQ3rk13CxZskTjxo3T5MmTtWPHDrVp00bx8fE6efJkse0/+ugjPf/885o8ebL27Nmj+fPna8mSJXrhhRduceUAAKC8cmu4mTlzpkaPHq3hw4erefPmmjdvnvz8/LRgwYJi22/ZskVdunTRkCFDFBUVpV69emnw4MHXHe0BAACVh9vCTV5enpKTkxUXF/ffYqpUUVxcnJKSkopd5o477lBycrI9zPz0009atWqV+vbte0tqBgAA5V9Vd33w6dOnVVBQoJCQEIfpISEh2rt3b7HLDBkyRKdPn9add94pY4wuX76sRx555JqHpS5duqRLly7Z32dlZbmmAwAAoFxy+wnFzli/fr3eeOMNvfvuu9qxY4dWrFihL7/8Un/+859LXGbq1KkKCAiwvyIiIm5hxQAA4FazGWOMOz44Ly9Pfn5+Wr58ufr372+fPmzYMGVkZOjzzz8vskzXrl3VuXNnTZ8+3T7tH//4h/70pz8pOztbVaoUzWrFjdxEREQoMzNT/v7+ru0UAAAoE1lZWQoICCjV/tttIzdeXl5q3769EhMT7dMKCwuVmJio2NjYYpfJyckpEmA8PDwkSSVlNG9vb/n7+zu8AACAdbntnBtJGjdunIYNG6YOHTqoU6dOSkhI0IULFzR8+HBJ0tChQxUeHq6pU6dKkvr166eZM2cqOjpaMTExOnDggF5++WX169fPHnIAAEDl5tZwM3DgQJ06dUqTJk1SWlqa2rZtq9WrV9tPMj569KjDSM1LL70km82ml156ScePH1edOnXUr18/vf766+7qAgAAKGfcds6NuzhzzA4AAJQPFeKcGwAAgLJAuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZCuAEAAJZS1ZnGGRkZ+uyzz7Rx40YdOXJEOTk5qlOnjqKjoxUfH6877rijrOoEAAAolVKN3Jw4cUKjRo1S3bp19dprryk3N1dt27bVXXfdpXr16mndunX67W9/q+bNm2vJkiVlXTMAAECJSjVyEx0drWHDhik5OVnNmzcvtk1ubq5WrlyphIQEHTt2TM8++6xLCwUAACgNmzHGXK/RmTNnVKtWrVKv1Nn2t1JWVpYCAgKUmZkpf39/d5cDAABKwZn9d6kOSzkbVMprsAEAANZ301dL7dmzRwsXLlRKSooLygEAALg5Tl0tNWXKFPn6+uq5556TJK1bt069e/dWjRo1lJmZqUWLFumBBx4ok0IBAABKw6mRm+XLlzucUPz666/rySef1OnTpzV79my98cYbLi8QAADAGaUauVm8eLGMMTp8+LBSUlJ05swZGWO0efNmde3aVYsXL1ZhYaF++uknLV68WJI0dOjQMi0cAACgOKUKN5GRkZIkLy8vhYSEKDIyUikpKfL391fPnj1ljNGlS5dks9kUFRWlUlyABQAAUCZKFW66d+8uSWrXrp2++OILTZgwQatXr1bfvn3VrVs3SdJ3332niIgI+3sAAAB3cOqcm+nTpyslJUVdunTRkSNHNGXKFPu8RYsWqXfv3i4vEAAAwBmluonfrxV3k77U1FT5+/urWrVqLiuuLHATPwAAKh5n9t9OXQp+VXE36atbt+6NrAoAAMClSnVY6pNPPin1Co8dO6bNmzffcEEAAAA3o1ThZu7cubr99tv11ltvac+ePUXmZ2ZmatWqVRoyZIjatWunM2fOuLxQAACA0ijVYalvvvlG//d//6dZs2Zp4sSJqlatmkJCQuTj46Nz584pLS1NtWvX1kMPPaTdu3crJCSkrOsGAAAoltMnFJ8+fVqbNm3SkSNHlJubq9q1ays6OlrR0dGqUuWmH1VV5jihGACAiqdMTyiuXbu2+vfvf6O1AQAAlKnyP9QCAADgBMINAACwFMINAACwFMINAACwFKfDzZQpU5STk1Nkem5ursOzpgAAANzB6UvBPTw8lJqaquDgYIfpZ86cUXBwsAoKClxaoKtxKTgAABWPM/tvp0dujDGy2WxFpu/atUs1a9Z0dnUAAAAuVer73AQFBclms8lms6lJkyYOAaegoEDZ2dl65JFHyqRIAACA0ip1uElISJAxRiNGjNCrr76qgIAA+zwvLy9FRUUpNjbW6QLmzJmj6dOnKy0tTW3atNGsWbPUqVOnEttnZGToxRdf1IoVK3T27FlFRkYqISFBffv2dfqzAQCA9ZQ63AwbNkySVL9+fXXp0kVVqzp9c+MilixZonHjxmnevHmKiYlRQkKC4uPjtW/fviLn9EhSXl6efvvb3yo4OFjLly9XeHi4jhw5osDAwJuuBQAAWIPT59zUqFHD4cngn3/+ufr3768XXnhBeXl5Tq1r5syZGj16tIYPH67mzZtr3rx58vPz04IFC4ptv2DBAp09e1YrV65Uly5dFBUVpe7du6tNmzbOdgMAAFiU0+Hm4Ycf1o8//ihJ+umnnzRw4ED5+flp2bJlGj9+fKnXk5eXp+TkZMXFxf23mCpVFBcXp6SkpGKX+b//+z/Fxsbq8ccfV0hIiFq2bKk33njjmldoXbp0SVlZWQ4vAABgXU6Hmx9//FFt27aVJC1btkzdu3fXRx99pEWLFunTTz8t9XpOnz6tgoIChYSEOEwPCQlRWlpascv89NNPWr58uQoKCrRq1Sq9/PLLmjFjhl577bUSP2fq1KkKCAiwvyIiIkpdIwAAqHhu6FLwwsJCSdLXX39tP5E3IiJCp0+fdm11v1JYWKjg4GD99a9/Vfv27TVw4EC9+OKLmjdvXonLTJw4UZmZmfbXsWPHyrRGAADgXk6fFdyhQwe99tpriouL0zfffKO5c+dKkg4dOlRkFOZaateuLQ8PD6WnpztMT09PV2hoaLHL1K1bV56envLw8LBPu/3225WWlqa8vDx5eXkVWcbb21ve3t6lrgsAAFRsTo/cJCQkaMeOHRozZoxefPFFNWrUSJK0fPly3XHHHaVej5eXl9q3b6/ExET7tMLCQiUmJpZ4SXmXLl104MAB+8iRdOUwWd26dYsNNgAAoPJx+vELJbl48aI8PDzk6elZ6mWWLFmiYcOG6b333lOnTp2UkJCgpUuXau/evQoJCdHQoUMVHh6uqVOnSpKOHTumFi1aaNiwYXriiSe0f/9+jRgxQk8++aRefPHFUn0mj18AAKDicWb/fcM3q0lOTrZfEt68eXO1a9fO6XUMHDhQp06d0qRJk5SWlqa2bdtq9erV9sNbR48eVZUq/x1cioiI0FdffaWnn35arVu3Vnh4uMaOHasJEybcaDcAAIDFOD1yc/LkSQ0cOFDffPON/eZ5GRkZ6tmzpz755BPVqVOnLOp0GUZuAACoeMr0wZlPPPGEsrOz9f333+vs2bM6e/asdu/eraysLD355JM3XDQAAIArOD1yExAQoK+//lodO3Z0mL5t2zb16tVLGRkZrqzP5Ri5AQCg4inTkZvCwsJiTxr29PR0uIoJAADAHZwON7/5zW80duxYnThxwj7t+PHjevrpp3XXXXe5tDgAAABnOR1uZs+eraysLEVFRalhw4Zq2LCh6tevr6ysLM2aNassagQAACg1py8Fj4iI0I4dO/T1119r7969kq7cJfiXD8AEAABwF5fdxK+i4IRiAAAqnjI5oXjt2rVq3ry5srKyiszLzMxUixYttHHjRuerBQAAcKFSh5uEhASNHj262LQUEBCghx9+WDNnznRpcQAAAM4qdbjZtWuXevfuXeL8Xr16KTk52SVFAQAA3KhSh5v09PRrPhSzatWqOnXqlEuKAgAAuFGlDjfh4eHavXt3ifO//fZb1a1b1yVFAQAA3KhSh5u+ffvq5Zdf1sWLF4vMy83N1eTJk/W73/3OpcUBAAA4q9SXgqenp6tdu3by8PDQmDFj1LRpU0nS3r17NWfOHBUUFGjHjh0KCQkp04JvFpeCAwBQ8Tiz/y71TfxCQkK0ZcsWPfroo5o4caKuZiKbzab4+HjNmTOn3AcbAABgfU7doTgyMlKrVq3SuXPndODAARlj1LhxYwUFBZVVfQAAAE5x+vELkhQUFKSOHTu6uhYAAICb5vSDMwEAAMozwg0AALAUwg0AALAUwg0AALCUGwo3f//739WlSxeFhYXpyJEjkq48WPPzzz93aXEAAADOcjrczJ07V+PGjVPfvn2VkZGhgoICSVJgYKASEhJcXR8AAIBTnA43s2bN0t/+9je9+OKL8vDwsE/v0KGDvvvuO5cWBwAA4Cynw82hQ4cUHR1dZLq3t7cuXLjgkqIAAABulNPhpn79+kpJSSkyffXq1br99ttdURMAAMANc/oOxePGjdPjjz+uixcvyhijbdu26eOPP9bUqVP1/vvvl0WNAAAApeZ0uBk1apR8fX310ksvKScnR0OGDFFYWJj+93//V4MGDSqLGgEAAErNZq4+3vsG5OTkKDs7W8HBwa6sqUw588h0AABQPjiz/76hB2de5efnJz8/v5tZBQAAgEuVKtxER0fLZrOVaoU7duy4qYIAAABuRqnCTf/+/cu4DAAAANe4qXNuKiLOuQEAoOK5JefcbN++XXv27JEkNW/eXO3bt7/RVQEAALiM0+Hm559/1uDBg7V582YFBgZKkjIyMnTHHXfok08+Ub169VxdIwAAQKk5fYfiUaNGKT8/X3v27NHZs2d19uxZ7dmzR4WFhRo1alRZ1AgAAFBqTp9z4+vrqy1bthR5vlRycrK6du2qnJwclxboapxzAwBAxePM/tvpkZuIiAjl5+cXmV5QUKCwsDBnVwcAAOBSToeb6dOn64knntD27dvt07Zv366xY8fqL3/5i0uLAwAAcFapDksFBQU53MTvwoULunz5sqpWvXI+8tWfq1WrprNnz5ZdtS7AYSkAACoel18KnpCQ4Iq6AAAAylypws2wYcPKug4AAACXuKkHZ168eFF5eXkO0zjUAwAA3MnpE4ovXLigMWPGKDg4WNWqVVNQUJDDCwAAwJ2cDjfjx4/X2rVrNXfuXHl7e+v999/Xq6++qrCwMC1evLgsagQAACg1pw9L/b//9/+0ePFi9ejRQ8OHD1fXrl3VqFEjRUZG6sMPP9QDDzxQFnUCAACUitMjN2fPnlWDBg0kXTm/5uql33feeac2bNjg2uoAAACc5HS4adCggQ4dOiRJatasmZYuXSrpyojO1QdpAgAAuIvT4Wb48OHatWuXJOn555/XnDlz5OPjo6efflrPPfecywsEAABwhtMPzvy1I0eOKDk5WY0aNVLr1q1dVVeZ4Q7FAABUPC6/Q/G1REZGKjIy8mZXAwAA4BKlPiy1du1aNW/eXFlZWUXmZWZmqkWLFtq4caNLiwMAAHBWqcNNQkKCRo8eXexQUEBAgB5++GHNnDnTpcUBAAA4q9ThZteuXerdu3eJ83v16qXk5GSXFAUAAHCjSh1u0tPT5enpWeL8qlWr6tSpUy4pCgAA4EaVOtyEh4dr9+7dJc7/9ttvVbduXZcUBQAAcKNKHW769u2rl19+WRcvXiwyLzc3V5MnT9bvfve7Gypizpw5ioqKko+Pj2JiYrRt27ZSLffJJ5/IZrOpf//+N/S5AADAekp9n5v09HS1a9dOHh4eGjNmjJo2bSpJ2rt3r+bMmaOCggLt2LFDISEhThWwZMkSDR06VPPmzVNMTIwSEhK0bNky7du3T8HBwSUud/jwYd15551q0KCBatasqZUrV5bq87jPDQAAFY8z+2+nbuJ35MgRPfroo/rqq690dTGbzab4+HjNmTNH9evXd7rYmJgYdezYUbNnz5YkFRYWKiIiQk888YSef/75YpcpKChQt27dNGLECG3cuFEZGRmEGwAALKzMbuIXGRmpVatW6dy5czpw4ICMMWrcuLGCgoJuqNC8vDwlJydr4sSJ9mlVqlRRXFyckpKSSlxuypQpCg4O1siRI697b51Lly7p0qVL9vfF3acHAABYxw3doTgoKEgdO3a86Q8/ffq0CgoKihzKCgkJ0d69e4tdZtOmTZo/f75SUlJK9RlTp07Vq6++erOlAgCACsLpB2e60/nz5/Xggw/qb3/7m2rXrl2qZSZOnKjMzEz769ixY2VcJQAAcKebfrbUzahdu7Y8PDyUnp7uMD09PV2hoaFF2h88eFCHDx9Wv3797NMKCwslXbnPzr59+9SwYUOHZby9veXt7V0G1QMAgPLIrSM3Xl5eat++vRITE+3TCgsLlZiYqNjY2CLtmzVrpu+++04pKSn21z333KOePXsqJSVFERERt7J8AABQDrl15EaSxo0bp2HDhqlDhw7q1KmTEhISdOHCBQ0fPlySNHToUIWHh2vq1Kny8fFRy5YtHZYPDAyUpCLTAQBA5eT2cDNw4ECdOnVKkyZNUlpamtq2bavVq1fbTzI+evSoqlSpUKcGAQAAN3LqPjdWwH1uAACoeMrsPjcAAKBsGWOUm1/g7jJumq+nh2w2m1s+m3ADAEA5YYzR/fOSlHzknLtLuWk/TImXn5d7YgYnswAAUE7k5hdYIti4GyM3AACUQ9tfipOfl4e7y7hhvp7uq51wAwBAOeTn5eG2wzoVHYelAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApfC4UQDALWeMUW5+gbvLKHdy8vhOXIFwAwC4pYwxun9ekpKPnHN3KbAoDksBAG6p3PwCgs11dIgMkq+nh7vLqLAYuQEAuM32l+Lk58VO/Nd8PT1ks9ncXUaFRbgBALiNn5eH/LzYFcG1OCwFAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshXADAAAshUexAkAZMcYoN7/A3WWUOzl5fCcoW4QbACgDxhjdPy9JyUfOubsUoNLhsBQAlIHc/AKCzXV0iAySr6eHu8uABTFyAwBlbPtLcfLzYif+a76eHrLZbO4uAxZEuAGAMubn5SE/L/7cArcKh6UAAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAIClEG4AAICl8JhaADfFGKPc/AJ3l1Hu5OTxnQDuQrgBcMOMMbp/XpKSj5xzdykAYFcuDkvNmTNHUVFR8vHxUUxMjLZt21Zi27/97W/q2rWrgoKCFBQUpLi4uGu2B1B2cvMLCDbX0SEySL6eHu4uA6hU3D5ys2TJEo0bN07z5s1TTEyMEhISFB8fr3379ik4OLhI+/Xr12vw4MG644475OPjozfffFO9evXS999/r/DwcDf0AIAkbX8pTn5e7MR/zdfTQzabzd1lAJWKzRhj3FlATEyMOnbsqNmzZ0uSCgsLFRERoSeeeELPP//8dZcvKChQUFCQZs+eraFDh163fVZWlgICApSZmSl/f/+brh+ozHLyLqv5pK8kST9MiZefl9v/vwTAopzZf7v1sFReXp6Sk5MVFxdnn1alShXFxcUpKSmpVOvIyclRfn6+atasWVZlAgCACsSt/806ffq0CgoKFBIS4jA9JCREe/fuLdU6JkyYoLCwMIeA9EuXLl3SpUuX7O+zsrJuvGAAAFDulYsTim/UtGnT9Mknn+izzz6Tj49PsW2mTp2qgIAA+ysiIuIWVwkAAG4lt4ab2rVry8PDQ+np6Q7T09PTFRoaes1l//KXv2jatGn617/+pdatW5fYbuLEicrMzLS/jh075pLaAQBA+eTWcOPl5aX27dsrMTHRPq2wsFCJiYmKjY0tcbm33npLf/7zn7V69Wp16NDhmp/h7e0tf39/hxcAALAut1/aMG7cOA0bNkwdOnRQp06dlJCQoAsXLmj48OGSpKFDhyo8PFxTp06VJL355puaNGmSPvroI0VFRSktLU2SVL16dVWvXt1t/QAAAOWD28PNwIEDderUKU2aNElpaWlq27atVq9ebT/J+OjRo6pS5b8DTHPnzlVeXp7uv/9+h/VMnjxZr7zyyq0sHQAAlENuv8/NrcZ9bgDX4T43AG6VCnOfGwAAAFcj3AAAAEsh3AAAAEsh3AAAAEsh3AAAAEvh0gbgOowxys0vcHcZ5VJOHt8LgPKHcANcgzFG989LUvKRc+4uBUB5YoyUn+PuKso3Tz/JZnPLRxNugGvIzS8g2JRCh8gg+Xp6uLsM4NYwRloQLx3b6u5KyrcXTkhe1dzy0YQboJS2vxQnPy924MXx9fSQzU3/QwNuufwcgk05R7gBSsnPy4M78AJw9OwBycvP3VWUT57u+174Sw0AwI3y8nPboReUjEvBAQCApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApfDgTEiSjDHKzS9wdxnlTk6eBb4TY6T8HHdXAVhHHv+eyjvCDWSM0f3zkpR85Jy7S4GrGSMtiJeObXV3JQBwy3BYCsrNLyDYXEeHyCD5enq4uwzn5ecQbICyEtFZ8vRzdxUoBiM3cLD9pTj5eVXAnXgZ8/X0kM1mc3cZN+fZA5IXf4gBl/H0kyr63wWLItzAgZ+Xh/y8+LWwJC8/yauau6sAgDLHYSkAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGAphBsAAGApPP7ZRUxhoXJzzru7jBuSk1cgX1288ibvgvi1sJC8HHdXAAC3HHsxF8nNOS+/v9zm7jJuiJ+kPT7//5u/uLMSAABuHoelgMogorPk6efuKgDglmDkxkV8/Woo59mj7i7jpvh6eshms7m7DJQFTz+JbQugkiDcuIitShX5VQ9wdxkAAFR6HJYCAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWQrgBAACWUi7CzZw5cxQVFSUfHx/FxMRo27Zt12y/bNkyNWvWTD4+PmrVqpVWrVp1iyoFAADlndvDzZIlSzRu3DhNnjxZO3bsUJs2bRQfH6+TJ08W237Lli0aPHiwRo4cqZ07d6p///7q37+/du/efYsrBwAA5ZHNGGPcWUBMTIw6duyo2bNnS5IKCwsVERGhJ554Qs8//3yR9gMHDtSFCxf0xRdf2Kd17txZbdu21bx58677eVlZWQoICFBmZqb8/f1d1xEAAFBmnNl/u3XkJi8vT8nJyYqLi7NPq1KliuLi4pSUlFTsMklJSQ7tJSk+Pr7E9gAAoHKp6s4PP336tAoKChQSEuIwPSQkRHv37i12mbS0tGLbp6WlFdv+0qVLunTpkv19ZmampCsJEAAAVAxX99ulOeDk1nBzK0ydOlWvvvpqkekRERFuqAYAANyM8+fPKyAg4Jpt3BpuateuLQ8PD6WnpztMT09PV2hoaLHLhIaGOtV+4sSJGjdunP19YWGhzp49q1q1aslms91kD8qvrKwsRURE6NixY5Xi3KLK1F/6al2Vqb/01brKqr/GGJ0/f15hYWHXbevWcOPl5aX27dsrMTFR/fv3l3QlfCQmJmrMmDHFLhMbG6vExEQ99dRT9mlr1qxRbGxsse29vb3l7e3tMC0wMNAV5VcI/v7+leIf01WVqb/01boqU3/pq3WVRX+vN2JzldsPS40bN07Dhg1Thw4d1KlTJyUkJOjChQsaPny4JGno0KEKDw/X1KlTJUljx45V9+7dNWPGDN1999365JNPtH37dv31r391ZzcAAEA54fZwM3DgQJ06dUqTJk1SWlqa2rZtq9WrV9tPGj569KiqVPnvRV133HGHPvroI7300kt64YUX1LhxY61cuVItW7Z0VxcAAEA54vZwI0ljxowp8TDU+vXri0wbMGCABgwYUMZVVWze3t6aPHlykUNyVlWZ+ktfrasy9Ze+Wld56K/bb+IHAADgSm5//AIAAIArEW4AAIClEG4AAIClEG4qkKlTp6pjx46qUaOGgoOD1b9/f+3bt8+hTY8ePWSz2RxejzzyiEObo0eP6u6775afn5+Cg4P13HPP6fLly7eyK6XyyiuvFOlLs2bN7PMvXryoxx9/XLVq1VL16tV13333FbnBY0Xpa1RUVJG+2mw2Pf7445Iq9nbdsGGD+vXrp7CwMNlsNq1cudJhvjFGkyZNUt26deXr66u4uDjt37/foc3Zs2f1wAMPyN/fX4GBgRo5cqSys7Md2nz77bfq2rWrfHx8FBERobfeequsu1asa/U3Pz9fEyZMUKtWrVStWjWFhYVp6NChOnHihMM6ivt9mDZtmkOb8tDf623bhx56qEg/evfu7dCmomzb6/W1uH+/NptN06dPt7epKNu1NPsaV/39Xb9+vdq1aydvb281atRIixYtck0nDCqM+Ph4s3DhQrN7926TkpJi+vbta2677TaTnZ1tb9O9e3czevRok5qaan9lZmba51++fNm0bNnSxMXFmZ07d5pVq1aZ2rVrm4kTJ7qjS9c0efJk06JFC4e+nDp1yj7/kUceMRERESYxMdFs377ddO7c2dxxxx32+RWprydPnnTo55o1a4wks27dOmNMxd6uq1atMi+++KJZsWKFkWQ+++wzh/nTpk0zAQEBZuXKlWbXrl3mnnvuMfXr1ze5ubn2Nr179zZt2rQx//73v83GjRtNo0aNzODBg+3zMzMzTUhIiHnggQfM7t27zccff2x8fX3Ne++9d6u6aXet/mZkZJi4uDizZMkSs3fvXpOUlGQ6depk2rdv77COyMhIM2XKFIft/ct/5+Wlv9fbtsOGDTO9e/d26MfZs2cd2lSUbXu9vv6yj6mpqWbBggXGZrOZgwcP2ttUlO1amn2NK/7+/vTTT8bPz8+MGzfO/PDDD2bWrFnGw8PDrF69+qb7QLipwE6ePGkkmW+++cY+rXv37mbs2LElLrNq1SpTpUoVk5aWZp82d+5c4+/vby5dulSW5Tpt8uTJpk2bNsXOy8jIMJ6enmbZsmX2aXv27DGSTFJSkjGmYvX118aOHWsaNmxoCgsLjTHW2a6/3ikUFhaa0NBQM336dPu0jIwM4+3tbT7++GNjjDE//PCDkWT+85//2Nv885//NDabzRw/ftwYY8y7775rgoKCHPo6YcIE07Rp0zLu0bUVtxP8tW3bthlJ5siRI/ZpkZGR5u233y5xmfLY35LCzb333lviMhV125Zmu957773mN7/5jcO0irhdjSm6r3HV39/x48ebFi1aOHzWwIEDTXx8/E3XzGGpCuzqE85r1qzpMP3DDz9U7dq11bJlS02cOFE5OTn2eUlJSWrVqpXDk9Xj4+OVlZWl77///tYU7oT9+/crLCxMDRo00AMPPKCjR49KkpKTk5Wfn6+4uDh722bNmum2225TUlKSpIrX16vy8vL0j3/8QyNGjHB4/pmVtutVhw4dUlpamsN2DAgIUExMjMN2DAwMVIcOHext4uLiVKVKFW3dutXeplu3bvLy8rK3iY+P1759+3Tu3Llb1Jsbk5mZKZvNVuSxMNOmTVOtWrUUHR2t6dOnOwznV6T+rl+/XsHBwWratKkeffRRnTlzxj7Pqts2PT1dX375pUaOHFlkXkXcrr/e17jq729SUpLDOq62ubqOm1EubuIH5xUWFuqpp55Sly5dHO7OPGTIEEVGRiosLEzffvutJkyYoH379mnFihWSpLS0NIdfNkn292lpabeuA6UQExOjRYsWqWnTpkpNTdWrr76qrl27avfu3UpLS5OXl1eRHUJISIi9HxWpr7+0cuVKZWRk6KGHHrJPs9J2/aWrtRVX+y+3Y3BwsMP8qlWrqmbNmg5t6tevX2QdV+cFBQWVSf036+LFi5owYYIGDx7s8AyeJ598Uu3atVPNmjW1ZcsWTZw4UampqZo5c6akitPf3r176w9/+IPq16+vgwcP6oUXXlCfPn2UlJQkDw8Py27bDz74QDVq1NAf/vAHh+kVcbsWt69x1d/fktpkZWUpNzdXvr6+N1w34aaCevzxx7V7925t2rTJYfqf/vQn+8+tWrVS3bp1ddddd+ngwYNq2LDhrS7zpvTp08f+c+vWrRUTE6PIyEgtXbr0pn7py7v58+erT58+Dk++tdJ2xRX5+fn6n//5HxljNHfuXId548aNs//cunVreXl56eGHH9bUqVMr1F1uBw0aZP+5VatWat26tRo2bKj169frrrvucmNlZWvBggV64IEH5OPj4zC9Im7XkvY15R2HpSqgMWPG6IsvvtC6detUr169a7aNiYmRJB04cECSFBoaWuSM9qvvQ0NDy6Ba1wkMDFSTJk104MABhYaGKi8vTxkZGQ5t0tPT7f2oiH09cuSIvv76a40aNeqa7ayyXa/WVlztv9yOJ0+edJh/+fJlnT17tsJu66vB5siRI1qzZs11n5wcExOjy5cv6/Dhw5IqXn+vatCggWrXru3we2u1bbtx40bt27fvuv+GpfK/XUva17jq729Jbfz9/W/6P7CEmwrEGKMxY8bos88+09q1a4sMXxYnJSVFklS3bl1JUmxsrL777juHPyhX/7g2b968TOp2lezsbB08eFB169ZV+/bt5enpqcTERPv8ffv26ejRo4qNjZVUMfu6cOFCBQcH6+67775mO6ts1/r16ys0NNRhO2ZlZWnr1q0O2zEjI0PJycn2NmvXrlVhYaE95MXGxmrDhg3Kz8+3t1mzZo2aNm1a7g5bXA02+/fv19dff61atWpdd5mUlBRVqVLFfginIvX3l37++WedOXPG4ffWSttWujLy2r59e7Vp0+a6bcvrdr3evsZVf39jY2Md1nG1zdV13GwnUEE8+uijJiAgwKxfv97hUsKcnBxjjDEHDhwwU6ZMMdu3bzeHDh0yn3/+uWnQoIHp1q2bfR1XL8/r1auXSUlJMatXrzZ16tQpF5cM/9ozzzxj1q9fbw4dOmQ2b95s4uLiTO3atc3JkyeNMVcuRbztttvM2rVrzfbt201sbKyJjY21L1+R+mqMMQUFBea2224zEyZMcJhe0bfr+fPnzc6dO83OnTuNJDNz5kyzc+dO+9VB06ZNM4GBgebzzz833377rbn33nuLvRQ8OjrabN261WzatMk0btzY4XLhjIwMExISYh588EGze/du88knnxg/Pz+3XAp+rf7m5eWZe+65x9SrV8+kpKQ4/Du+egXJli1bzNtvv21SUlLMwYMHzT/+8Q9Tp04dM3To0HLX32v19fz58+bZZ581SUlJ5tChQ+brr7827dq1M40bNzYXL160r6OibNvr/R4bc+VSbj8/PzN37twiy1ek7Xq9fY0xrvn7e/VS8Oeee87s2bPHzJkzh0vBKyNJxb4WLlxojDHm6NGjplu3bqZmzZrG29vbNGrUyDz33HMO90MxxpjDhw+bPn36GF9fX1O7dm3zzDPPmPz8fDf06NoGDhxo6tata7y8vEx4eLgZOHCgOXDggH1+bm6ueeyxx0xQUJDx8/Mzv//9701qaqrDOipKX40x5quvvjKSzL59+xymV/Ttum7dumJ/b4cNG2aMuXI5+Msvv2xCQkKMt7e3ueuuu4p8B2fOnDGDBw821atXN/7+/mb48OHm/PnzDm127dpl7rzzTuPt7W3Cw8PNtGnTblUXHVyrv4cOHSrx3/HVexolJyebmJgYExAQYHx8fMztt99u3njjDYdAYEz56O+1+pqTk2N69epl6tSpYzw9PU1kZKQZPXq0w6XBxlScbXu932NjjHnvvfeMr6+vycjIKLJ8Rdqu19vXGOO6v7/r1q0zbdu2NV5eXqZBgwYOn3EzeCo4AACwFM65AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4AQAAlkK4ASxq0aJFCgwMdHcZFUKPHj301FNPlcm6z5w5o+DgYPvDEW+VefPmqV+/frf0M4HygnADVFAPPfSQbDabbDabvLy81KhRI02ZMkWXL18us888fPiwbDab/cGd1/Ppp5+qR48eCggIUPXq1dW6dWtNmTJFZ8+eLbMab8SKFSv05z//2f4+KipKCQkJLln366+/rnvvvVdRUVGS/vsdenh46Pjx4w5tU1NTVbVqVdlsNnsYqlu3rqZNm+bQ7vnnn5fNZtP69esdpvfo0UMPPvigJGnEiBHasWOHNm7c6JJ+ABUJ4QaowHr37q3U1FTt379fzzzzjF555RVNnz7d3WVJkl588UUNHDhQHTt21D//+U/t3r1bM2bM0K5du/T3v//d3eU5qFmzpmrUqOHy9ebk5Gj+/PkaOXJkkXnh4eFavHixw7QPPvhA4eHhDtN69OhRJMSsW7dOERERDtMvXryof//73/rNb34jSfLy8tKQIUP0zjvvuKYzQEXikidUAbjlhg0bZu69916Hab/97W9N586djTHGLFy40AQEBNjnHThwwNxzzz0mODjYVKtWzXTo0MGsWbPGYfnIyEjz+uuvm+HDh5vq1aubiIgIhycS61cP0uvevXuxtW3dutVIMgkJCcXOP3funFM1TZkyxQwaNMj4+fmZsLAwM3v2bIc2M2bMMC1btjR+fn6mXr165tFHHy3y8MVNmzaZ7t27G19fXxMYGGh69eplzp49a4wxpnv37mbs2LH2n3/dz+zsbFOjRg2zbNkyh3V+9tlnxs/Pz2RlZRXbz2XLlpk6deo4TLv68MyXXnrJNG7c2GFekyZNzMsvv2wkmUOHDhljrjyMsXr16vYHDmZlZRlPT08ze/Zsh+9/7dq1DssZY8w333xjvLy8HJ7mDFQGjNwAFuLr66u8vLxi52VnZ6tv375KTEzUzp071bt3b/Xr109Hjx51aDdjxgx16NBBO3fu1GOPPaZHH31U+/btkyRt27ZNkvT1118rNTVVK1asKPazPvzwQ1WvXl2PPfZYsfOvngtU2pqmT5+uNm3aaOfOnXr++ec1duxYrVmzxj6/SpUqeuedd/T999/rgw8+0Nq1azV+/Hj7/JSUFN11111q3ry5kpKStGnTJvXr108FBQVFaluxYoXq1aunKVOmKDU1VampqapWrZoGDRqkhQsXOrRduHCh7r///hJHfTZu3Kj27dsXO++ee+7RuXPntGnTJknSpk2bdO7cuSLnyfTs2VPZ2dn6z3/+Y19nkyZNdN9992nr1q26ePGipCujOVFRUfbDX5LUoUMHXb58WVu3bi22BsCy3J2uANyYX47cFBYWmjVr1hhvb2/z7LPPGmOKjtwUp0WLFmbWrFn295GRkeaPf/yj/X1hYaEJDg42c+fONcb8d9Rh586d11xvnz59TOvWrZ3vVAk19e7d26HNwIEDTZ8+fUpcx7Jly0ytWrXs7wcPHmy6dOlSYvtfjtxc/cy3337boc3WrVuNh4eHOXHihDHGmPT0dFO1alWzfv36Etd77733mhEjRjhM++V3+NRTT5nhw4cbY4wZPny4efrpp83OnTuLjMCEh4ebN954wxhjzHPPPWcee+wxY8yVkZ61a9caY4zp2rWrfV2/FBQUZBYtWlRijYAVMXIDVGBffPGFqlevLh8fH/Xp00cDBw7UK6+8Umzb7OxsPfvss7r99tsVGBio6tWra8+ePUVGSVq3bm3/2WazKTQ0VCdPnnSqLmNMqdqVtqbY2Ngi7/fs2WN///XXX+uuu+5SeHi4atSooQcffFBnzpxRTk6OpP+O3NyMTp06qUWLFvrggw8kSf/4xz8UGRmpbt26lbhMbm6ufHx8Spw/YsQILVu2TGlpaVq2bJlGjBhRbLtfnnezfv169ejRQ5LUvXt3rV+/Xrm5udq6dat69uxZZFlfX1/79wBUFoQboALr2bOnUlJStH//fuXm5uqDDz5QtWrVim377LPP6rPPPtMbb7yhjRs3KiUlRa1atSpyGMvT09Phvc1mU2FhoVN1NWnSRD/99JPy8/Ov2a60NV3L4cOH9bvf/U6tW7fWp59+quTkZM2ZM0eS7Ovx9fV1qv6SjBo1SosWLZJ05ZDU8OHDZbPZSmxfu3ZtnTt3rsT5rVq1UrNmzTR48GDdfvvtatmyZbHtevbsqc2bN+vMmTPauXOnunfvLulKuFm3bp22bNmivLw8+8nEv3T27FnVqVPHiV4CFR/hBqjAqlWrpkaNGum2225T1apVr9l28+bNeuihh/T73/9erVq1UmhoqNP3XvHy8pKkYs9V+aUhQ4YoOztb7777brHzMzIynKrp3//+d5H3t99+uyQpOTlZhYWFmjFjhjp37qwmTZroxIkTDu1bt26txMTE0nRR0pV+FtfHP/7xjzpy5Ijeeecd/fDDDxo2bNg11xMdHa0ffvjhmm1GjBih9evXlzhqI10JNxcuXNDMmTPVuHFjBQcHS5K6deumbdu26Z///KcaN25c5EqrgwcP6uLFi4qOjr5mDYDVEG6ASqJx48ZasWKFUlJStGvXLg0ZMsTpEZng4GD5+vpq9erVSk9PV2ZmZrHtYmJiNH78eD3zzDMaP368kpKSdOTIESUmJmrAgAH2QzulrWnz5s1666239OOPP2rOnDlatmyZxo4dK0lq1KiR8vPzNWvWLP3000/6+9//rnnz5jksP3HiRP3nP//RY489pm+//VZ79+7V3Llzdfr06WLrj4qK0oYNG3T8+HGHNkFBQfrDH/6g5557Tr169VK9evWu+X3Fx8fr+++/v+bozejRo3Xq1CmNGjWqxDYNGjTQbbfdplmzZtlHbSQpIiJCYWFh+utf/1rsIamNGzeqQYMGatiw4TXrBKyGcANUEjNnzlRQUJDuuOMO9evXT/Hx8WrXrp1T66hatareeecdvffeewoLC9O9995bYts333xTH330kbZu3ar4+Hi1aNFC48aNU+vWre0jHqWt6ZlnntH27dsVHR2t1157TTNnzlR8fLwkqU2bNpo5c6befPNNtWzZUh9++KGmTp3qsHyTJk30r3/9S7t27VKnTp0UGxurzz//vMTRrilTpujw4cNq2LBhkUM6I0eOVF5e3jVHWq5q1aqV2rVrp6VLl5bYpmrVqqpdu/Z1R9569uyp8+fP28+3uap79+46f/58seHm448/1ujRo69bJ2A1NlPaM/8AwA2ioqL01FNPldnjEZz197//XU8//bROnDhhP0x3LV9++aWee+457d69W1Wq3Lr/T37//ff6zW9+ox9//FEBAQG37HOB8uDa/1UAAEi6crfh1NRUTZs2TQ8//HCpgo0k3X333dq/f7+OHz+uiIiIMq7yv1JTU7V48WKCDSolDksBQCm89dZbatasmUJDQzVx4kSnln3qqaduabCRpLi4OPuhO6Cy4bAUAACwFEZuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApRBuAACApfx/WNGxMht48G0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# number per line = total / 4\n", - "# 0 - (num-1), num - (2num-1), etc \n", - "# \n", - "num = int(len(parametric.results) / 2)\n", - "print(num)\n", - "\n", - "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", - "plant_cap = np.arange(100,2100,100)\n", - "index = 3\n", - "\n", - "# Cable Cost\n", - "plt.step(plant_cap, parametric.results.cable_cost[0+20*index:20*(index+1)])\n", - "plt.step(plant_cap, parametric.results.cable_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,1.1e9])\n", - "\n", - "plt.show()\n", - "\n", - "# Substation Cost\n", - "plt.plot(plant_cap, sub_cost[0+20*index:20*(index+1)])\n", - "plt.plot(plant_cap, sub_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.ylabel(\"Substation Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,1.1e9])\n", - "\n", - "plt.show()\n", - "\n", - "#Total Export System Cost\n", - "total_cost = sub_cost + parametric.results.cable_cost\n", - "plt.plot(plant_cap, total_cost[0+20*index:20*(index+1)])\n", - "plt.plot(plant_cap, total_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.ylabel(\"Total Export Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,1.1e9])\n", - "plt.rcParams.update({'font.size':16})\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "011bc16a-e7ca-44a9-97b2-f23be59a1025", - "metadata": { - "tags": [] - }, - "source": [ - "# Varying distance to shore for given plant capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "fbdb3740-680a-4d92-a89d-caab35ee70b8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cable_vec = np.zeros((40,20))\n", - "oss_vec = np.zeros((40,20))\n", - "total_vec = np.zeros((40,20))\n", - "num2 = int(len(cable_vec) / 2)\n", - "print(num2)\n", - "for i in np.arange(20):\n", - " for j in np.arange(40):\n", - " index = 20 * j + i \n", - " cable_vec[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", - " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", - "\n", - "ind = 10\n", - "# Cable Cost\n", - "plt.plot(np.arange(15,315,15), cable_vec[0:num2,ind])\n", - "plt.plot(np.arange(15,315,15), cable_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "plt.ylim([0,1.32e9])\n", - "plt.show()\n", - "\n", - "# Substation Cost\n", - "plt.plot(np.arange(15,315,15), oss_vec[0:num2,ind])\n", - "plt.plot(np.arange(15,315,15), oss_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.ylabel(\"Substation Cost ($)\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.ylim([0,1.32e9])\n", - "plt.show()\n", - "\n", - "# Total Export System Cost\n", - "plt.scatter(np.arange(15,315,15), total_vec[0:num2,ind])\n", - "plt.scatter(np.arange(15,315,15), total_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"upper left\")\n", - "plt.ylabel(\"Export System Cost ($)\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.ylim([0,1.32e9])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "13162103-9236-4ba2-9b21-fcca8fc1605c", - "metadata": { - "tags": [] - }, - "source": [ - "# Contour for which is cheaper" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "eca84092-1fba-4b06-a70f-79d818758d77", - "metadata": {}, - "outputs": [], - "source": [ - "cable_vec_ac = np.zeros((20,20))\n", - "oss_vec_ac = np.zeros((20,20))\n", - "total_vec_ac = np.zeros((20,20))\n", - "# dist = np.zeros((20,20))\n", - "\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " index = 20 * j + i \n", - " cable_vec_ac[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec_ac[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", - " total_vec_ac[j,i] = parametric.results.cable_cost[index] + oss_vec_ac[j,i]\n", - "# dist[j,i] = parameters.site.distance_to_landfall[index]\n", - "\n", - "\n", - "\n", - "# plt.colormap" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "198770c5-171b-4134-8091-5a7b4876d6a3", - "metadata": {}, - "outputs": [], - "source": [ - "cable_vec_dc = np.zeros((20,20))\n", - "oss_vec_dc = np.zeros((20,20))\n", - "total_vec_dc = np.zeros((20,20))\n", - "# dist = np.zeros((20,20))\n", - "\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " index = 20 * j + i + 400\n", - " cable_vec_dc[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec_dc[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", - " total_vec_dc[j,i] = parametric.results.cable_cost[index] + oss_vec_dc[j,i]\n", - "# dist[j,i] = parameters.site.distance_to_landfall[index]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "cf33552a-14e3-41ef-a0bf-59b9a29a26ac", - "metadata": {}, - "outputs": [], - "source": [ - "contour_binary = np.zeros((20,20))\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " if total_vec_dc[j,i] < total_vec_ac[j,i]:\n", - " contour_binary[j,i] = 1\n", - "# print(total_vec_dc[j,i])" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "42f80e56-fdc7-4732-878e-c9588aeb8349", - "metadata": {}, - "outputs": [], - "source": [ - "cmap = LinearSegmentedColormap.from_list('custom_div_cmap',['#d73027', '#ffffbf','#1a9641'], 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0d4a44b7-e89c-402b-925b-634014fe94c9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_binary, cmap=cmap, shading='auto')\n", - "# plt.colorbar()\n", - "plt.xlabel('Plant Capacity (MW)')\n", - "plt.ylabel('Distance to Shore (km)')\n", - "# plt.title('HVDC is cheaper where green')\n", - "plt.title('Cheaper Transmission Type (HVAC v HVDC)')\n", - "plt.rcParams.update({'font.size':10})\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "b5306152-3345-4b33-a53e-14de50ff6913", - "metadata": {}, - "outputs": [], - "source": [ - "contour_cost = np.zeros((20,20))\n", - "MWcap = np.arange(100,2100,100)\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " if total_vec_dc[j,i] > total_vec_ac[j,i]:\n", - " contour_cost[j,i] = total_vec_ac[j,i]\n", - " else: \n", - " contour_cost[j,i] = total_vec_dc[j,i]\n", - "\n", - "for i in np.arange(20):\n", - " contour_cost[:,i] = contour_cost[:,i] / MWcap[i]" - ] - }, - { - "cell_type": "markdown", - "id": "0b768f48-927b-45c3-8f9a-2088323bd732", - "metadata": { - "tags": [] - }, - "source": [ - "# Color Map of Total Cost of Cheaper Option" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "414b80bf-1ace-41d4-8a30-01f623ce4059", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB5eUlEQVR4nO3dd1gUV9sG8HvpTZpSFcGOKChiRKwoKqKxRGPQaLAnKiZ2DXkTNRrFFFvyGUtijTX2RI1drFgj9hAxKhZKotJU6p7vD8OElSK7O8AK9y/XXHFnzpx9Zmd3efacM2cUQggBIiIionJCr6wDICIiIpITkxsiIiIqV5jcEBERUbnC5IaIiIjKFSY3REREVK4wuSEiIqJyhckNERERlStMboiIiKhcYXJDRERE5QqTGw0oFAqMHj26rMOgUuLm5oZBgwbJXq+/vz/8/f1lr5fKVpcuXTB8+PCyDoNkdv36dRgYGODq1atlHQoVA5ObPG7duoUPPvgANWvWhImJCSwtLdGyZUssXLgQz58/L+vwypy/vz8UCsUrl+nTp5d1qFQINze3Yp3DVatWlXWo+Wzfvh1BQUGoUqUKjIyM4OzsjHfeeQeHDx8ukec7deoUpk+fjqSkpGLvc/LkSezfvx9TpkyR1kVEREChUGDLli0F7jNo0CBYWFgAABITE2FgYIABAwYU+hypqakwNTVFr169VNZ///33UCgU8PX1LTLGhIQETJw4Ee7u7jAzM4O5uTl8fHzwxRdfqHWs6lq1ahUUCgXOnz9f4HZ/f380bNgQAPD7779DoVDg008/LbS+mzdvQqFQYPz48QCA6dOnq7yHzczMUL16dXTr1g0rV65ERkZGoXVFRESgV69ecHR0hJGREezt7dGtWzds27ZNKuPh4YGuXbti6tSpmhw+lTKDsg5AV+zevRt9+vSBsbExQkJC0LBhQ2RmZuLEiROYNGkSrl27hmXLlpV1mGXqf//7H4YNGyY9PnfuHL799lt88sknqF+/vrTey8urLMIrMdHR0dDTk/93wP79+2Wv81UWLFiAtLQ06fGePXuwYcMGzJ8/H1WqVJHWt2jRotRjK4wQAkOGDMGqVavg7e2N8ePHw9HREXFxcdi+fTsCAgJw8uRJ2WM+deoUPv/8cwwaNAjW1tbF2ufrr79GQEAAateurdFz2tvbo2PHjti5cyeePXsGMzOzfGW2bduG9PT0fAnQunXr4ObmhrNnzyImJqbAGM6dO4cuXbogLS0NAwYMgI+PDwDg/PnzmDNnDo4dO1Ym78uXNWnSBO7u7tiwYQO++OKLAsusX78eAPK9DosXL4aFhQUyMjLw4MED7Nu3D0OGDMGCBQuwa9cuuLi4qJSfNm0aZsyYgTp16uCDDz6Aq6srHj16hD179qB3795Yt24d3n33XQDAiBEj0KVLF9y6dQu1atUqgSMn2QgSf/31l7CwsBDu7u7i4cOH+bbfvHlTLFiwQHoMQISGhpZmiKUqLS2tWOU2b94sAIgjR47IUh+Vvq+//loAELdv3y7rUAqVG+PYsWOFUqnMt33NmjXizJkzJfa8xX1tEhIShIGBgfjxxx9V1h85ckQAEJs3by5wv4EDBwpzc3Pp8U8//SQAiA0bNhRYvlOnTsLKykqkp6dL6/766y8BQGzbtk3Y2dmJ6dOn59vvyZMnomrVqsLBwUHcuHEj3/b4+Hgxc+bMYh2rJlauXCkAiHPnzhW4vW3btqJBgwbS45kzZwoAIjIyssDy9erVE+7u7tLjadOmCQDi77//zld27dq1Qk9PT/j6+qqsz/0Oe/vtt0VmZma+/fbu3St+/fVX6XFmZqawsbERn332WdEHS2WOyY0QYsSIEQKAOHnyZLHK5yY327dvFw0aNBBGRkbCw8ND/Pbbb/nK3r9/XwwePFjY29tL5ZYvX65SJiMjQ3z22WeiSZMmwtLSUpiZmYlWrVqJw4cPq5S7ffu2ACC+/vprMW/ePFG9enVhYmIi2rRpI65cuZLvuW/cuCF69+4tbGxshLGxsfDx8RE7d+5UKZP7hRMRESFGjhwp7OzshLW1dbFeh4KSm9wvmGvXrol+/foJa2tr0bhxYyGEEJcuXRIDBw4UNWrUEMbGxsLBwUEMHjxY/PPPPyr15tZx8+ZNMXDgQGFlZSUsLS3FoEGDxNOnT1XK7t+/X7Rs2VJYWVkJc3NzUbduXREWFiZtz/3DsmnTJjF9+nTh7OwsLCwsRO/evUVSUpJIT08XY8aMEXZ2dsLc3FwMGjRI5Y+GEEK4urqKgQMHSo8zMzPF9OnTRe3atYWxsbGwtbUVLVu2FPv375fKxMXFiUGDBomqVasKIyMj4ejoKLp3767yh7Jt27aibdu2Ks+VkJAghgwZIuzt7YWxsbHw8vISq1atUimT932wdOlSUbNmTWFkZCSaNm0qzp49+8rzltfLf8CnTp0qDAwMRGJiYr6yw4cPF1ZWVuL58+fS69K1a1exb98+0ahRI2FsbCzq168vtm7dmm/fJ0+eiDFjxohq1aoJIyMjUatWLTFnzhyRk5NTZHzPnj0Ttra2wt3dXWRnZxfrmG7duiXefvttYWNjI0xNTYWvr6/YtWtXvnLffvut8PDwEKampsLa2lr4+PiIdevWCSH+ew++vBSV6KxYsUIAEHfu3FFZr25yk5aWJszNzUW3bt3ylU1ISBD6+vpi6NChKutnzpwpbGxsREZGhhg5cqSoU6dOvn3nzJkjAEjHqK7c98rLxyeEEB9//LEwNDQUjx8/LnR/dZOb3ITtww8/zFf2/PnzAoBKMlZUciOEEO+//74AoPI5dXd3F7a2tiIlJaXQuF/21ltvCS8vr2KXp7LBbikAv/76K2rWrKlWs/aJEyewbds2jBo1CpUqVcK3336L3r17IzY2FpUrVwbwom+7efPm0gBkOzs7/Pbbbxg6dChSUlIwduxYAEBKSgp+/PFH9OvXD8OHD0dqaiqWL1+OwMBAnD17Fo0bN1Z57jVr1iA1NRWhoaFIT0/HwoUL0b59e1y5cgUODg4AgGvXrqFly5aoWrUqPv74Y5ibm+Pnn39Gz549sXXrVrz11lsqdY4aNQp2dnaYOnUqnj59qvmL+a8+ffqgTp06mD17NoQQAIADBw7gr7/+wuDBg+Ho6Ch19V27dg2nT5+GQqFQqeOdd95BjRo1EB4ejt9//x0//vgj7O3t8eWXX0rH+Oabb8LLywszZsyAsbExYmJicPLkyXzxhIeHw9TUFB9//DFiYmLw3XffwdDQEHp6enjy5AmmT5+O06dPY9WqVahRo0aR/erTp09HeHg4hg0bhmbNmiElJQXnz5/H77//jo4dOwIAevfujWvXruHDDz+Em5sbEhMTceDAAcTGxsLNza3Aep8/fw5/f3/ExMRg9OjRqFGjBjZv3oxBgwYhKSkJY8aMUSm/fv16pKam4oMPPoBCocBXX32FXr164a+//oKhoWGxz1Ve7733HmbMmIFNmzapDJrPzMzEli1b0Lt3b5iYmEjrb968ieDgYIwYMQIDBw7EypUr0adPH+zdu1d6LZ49e4a2bdviwYMH+OCDD1C9enWcOnUKYWFhiIuLw4IFCwqN58SJE3j8+DHGjh0LfX39V8afkJCAFi1a4NmzZ/joo49QuXJlrF69Gt27d8eWLVuk9/0PP/yAjz76CG+//TbGjBmD9PR0XL58GWfOnMG7776LXr164c8//8zXZWdnZ1foc586dQqVK1eGq6trgdtTU1Pxzz//5Fv/8lgQc3Nz9OjRA1u2bMHjx49ha2srbdu0aRNycnLQv39/lX3WrVuHXr16wcjICP369cPixYtx7tw5vPHGG1KZX375Baampnj77bdf8SoW7J133sHkyZPx888/Y9KkSSrbfv75Z3Tq1Ak2NjavrCc5ObnA1yErK0vlcY0aNdCiRQv8/PPPmD9/vsr5z+2Syu0uKo733nsPy5Ytw/79+9GxY0fcvHkTf/zxB4YMGYJKlSoVux4fHx/s3LkTKSkpsLS0LPZ+VMrKOrsqa8nJyQKA6NGjR7H3ASCMjIxETEyMtO7SpUsCgPjuu++kdUOHDhVOTk75Wib69u0rrKysxLNnz4QQQmRnZ4uMjAyVMk+ePBEODg5iyJAh0rrcX+ympqbi/v370vozZ84IAGLcuHHSuoCAAOHp6anSCqFUKkWLFi1UftXl/ppq1apVsX8Z5yqq5aZfv375yuceb14bNmwQAMSxY8fy1ZH32IV48YupcuXK0uP58+cX+UtNiP9+NTds2FCl2blfv35CoVCIoKAglfJ+fn7C1dVVZd3LLTeNGjUSXbt2LfQ5nzx5IrWsFOXllpsFCxYIAGLt2rXSuszMTOHn5ycsLCykX5e574PKlSur/FLeuXOnAKDSjP4qBXW9+Pn55Wu+37ZtW75z7erqKgCotNQkJycLJycn4e3tLa2bOXOmMDc3F3/++adKnR9//LHQ19cXsbGxhca3cOFCAUBs3769WMczduxYAUAcP35cWpeamipq1Kgh3NzcpJaiHj16qLQSFETdbqlWrVoJHx+ffOtz34NFLXlbboQQYvfu3QKAWLp0qcr65s2bi6pVq6q0eOW2Yhw4cEAI8eJzXq1aNTFmzBiVfW1sbESjRo2KdSyF8fPzy3eMZ8+eFQDEmjVritw397umqOXlc7Jo0SIBQOzbt09al5OTI6pWrSr8/PxUyr6q5Sb3c/nWW28JIf77vMyfP7+4hy+EEGL9+vUCQIl0hZJ8KvzVUikpKQCgVuYOAB06dFAZUObl5QVLS0v89ddfAF4Mgty6dSu6desGIQT++ecfaQkMDERycjJ+//13AIC+vj6MjIwAAEqlEo8fP0Z2djaaNm0qlcmrZ8+eqFq1qvS4WbNm8PX1xZ49ewAAjx8/xuHDh/HOO+9Ivxb/+ecfPHr0CIGBgbh58yYePHigUufw4cOL9cu4uEaMGJFvnampqfTv9PR0/PPPP2jevDkAFHicL9fRunVrPHr0SDpnuYM8d+7cCaVSWWQ8ISEhKq0Zvr6+0kDVvHx9fXHv3j1kZ2cXWpe1tTWuXbuGmzdvFrjd1NQURkZGiIiIwJMnT4qMK689e/bA0dER/fr1k9YZGhrio48+QlpaGo4ePapSPjg4WOWXcuvWrQFAeg9qKiQkBGfOnMGtW7ekdevWrYOLiwvatm2rUtbZ2VmlFdDS0hIhISG4ePEi4uPjAQCbN29G69atYWNjo/I56NChA3JycnDs2LFCY1H387lnzx40a9YMrVq1ktZZWFjg/fffx507d3D9+nUAL87h/fv3ce7cuWLVWxyPHj0qsuVi6tSpOHDgQL6lU6dO+cp26tQJdnZ2UgsFANy+fRunT59Gv379VAa4r1u3Dg4ODmjXrh2AF1NVBAcHY+PGjcjJyZHKpaSkqP0997Lg4GBcuHBB5b2xadMmGBsbo0ePHsWqY9GiRQW+DgVdiBAcHAxDQ0OV1+Ho0aN48OBBvtarV8m9Ii01NRWA5t/9uee4oNYn0h0VPrnJbVbMfcMXV/Xq1fOts7Gxkf6Y/f3330hKSsKyZctgZ2ensgwePBjAi8s+c61evRpeXl4wMTFB5cqVYWdnh927dyM5OTnf89SpUyffurp16+LOnTsAgJiYGAgh8Nlnn+V77mnTpuV7buBFE7CcCqrv8ePHGDNmDBwcHGBqago7OzupXEHH+fJrnPulkvsaBwcHo2XLlhg2bBgcHBzQt29f/PzzzwUmOi/XZWVlBQD5rpywsrKCUqksMJ5cM2bMQFJSEurWrQtPT09MmjQJly9flrYbGxvjyy+/xG+//QYHBwe0adMGX331lfTHvjB3795FnTp18l2ZlXsl2t27d4s8ppdfH00FBwfD2NgY69atA/Di3OzatQv9+/fP13VYu3btfOvq1q0LANL78ebNm9i7d2++92KHDh0A5H8v5qXu5/Pu3buoV69evvUvv4ZTpkyBhYUFmjVrhjp16iA0NLTA7kx1iX+7YAvi6emJDh065FucnJzylTUwMEBwcDCOHz8u/RDJ/QOf9496Tk4ONm7ciHbt2uH27duIiYlBTEwMfH19kZCQgEOHDkllLS0t1f6ee1mfPn2gp6eHTZs2Sce7efNmBAUFFbuLplmzZgW+DgUlhpUrV0ZgYCC2b9+O9PR0AC9eBwMDA7zzzjtqxZ57lWBuMqPpd3/uOX75fa+pY8eOoVu3bnB2doZCocCOHTvUrkMIgW+++QZ169aFsbExqlatilmzZskS3+uKyY2lJZydndWemKmwVo7cN37uH9gBAwYU+CvlwIEDaNmyJQBg7dq1GDRoEGrVqoXly5dj7969OHDgANq3b//KFomC5O4zceLEQp/75ctE87aqyKGg+t555x388MMPGDFiBLZt24b9+/dj7969KjHn9arX2NTUFMeOHcPBgwfx3nvv4fLlywgODkbHjh1VfrEWVdernqMgbdq0wa1bt7BixQo0bNgQP/74I5o0aYIff/xRKjN27Fj8+eefCA8Ph4mJCT777DPUr18fFy9eLLRedWkSe3HY2NjgzTfflJKbLVu2ICMjo8i5V4qiVCrRsWPHQt+LvXv3LnRfd3d3AMCVK1c0eu7C1K9fH9HR0di4cSNatWqFrVu3olWrVlLyr4nKlStrnVjmNWDAACiVSmzYsAEAsGHDBnh4eKiMwTt8+DDi4uKwceNG1KlTR1py//DnnkPgxWv5559/IjMzU+OYnJ2d0bp1a/z8888AgNOnTyM2NhbBwcEa1/kqAwYMQEpKCnbt2oXMzExs3bpVatlSR+53fO53n6bvrdxznHfqBG08ffoUjRo1wqJFizSuY8yYMfjxxx/xzTff4I8//sAvv/yCZs2ayRLf64oDigG8+eabWLZsGSIjI+Hn5ydLnXZ2dqhUqRJycnKkX6iF2bJlC2rWrIlt27ap/Boo7Iu2oO6QP//8UxqoWrNmTQAvujRe9dyl5cmTJzh06BA+//xzlcG6hXXtFJeenh4CAgIQEBCAefPmYfbs2fjf//6HI0eOlOix29raYvDgwRg8eDDS0tLQpk0bTJ8+XWUeoFq1amHChAmYMGECbt68icaNG2Pu3LlYu3ZtgXW6urri8uXLUCqVKq03f/zxh7S9tISEhKBHjx44d+4c1q1bB29vbzRo0CBfudxWwrzv2z///BMApPdjrVq1kJaWptH5aNWqFWxsbLBhwwZ88sknr+w6dXV1RXR0dL71Bb2G5ubmCA4ORnBwMDIzM9GrVy/MmjULYWFhMDExUfuXubu7O7Zu3arWPkXx9fVFrVq1sH79enTs2BHXrl3L92t83bp1sLe3L/AP47Zt27B9+3YsWbIEpqam6NatGyIjI7F161aVrk91BQcHY9SoUYiOjsamTZtgZmaGbt26aVzfq3Tv3h2VKlXC+vXrYWhoiCdPnqjdJQUAP/30EwAgMDAQwIsWxnr16mHnzp1YuHCh1G31Krdv34aenp7UQqmtoKAgBAUFFbo9IyMD//vf/7BhwwYkJSWhYcOG+PLLL6XZzW/cuIHFixfj6tWrUqul3C3xr6MK33IDAJMnT4a5uTmGDRuGhISEfNtv3bqFhQsXqlWnvr4+evfuja1btxbYKvT333+rlAVUf3GfOXMGkZGRBda9Y8cOlTEzZ8+exZkzZ6QPiL29Pfz9/bF06VLExcUV+dylpaBjBFDklTKv8vjx43zrcn/VFjUbqbYePXqk8tjCwgK1a9eWnvPZs2dSE3quWrVqoVKlSkXG1aVLF8THx0tN/gCQnZ2N7777DhYWFvnGu5Sk3JmAv/zySxw9erTQVpuHDx9i+/bt0uOUlBSsWbMGjRs3hqOjI4AXLXaRkZHYt29fvv2TkpKKHN9kZmaGKVOm4MaNG5gyZUqBrVJr167F2bNnAbx4Dc+ePavy2Xn69CmWLVsGNzc3eHh4AMh/Do2MjODh4QEhhHTVjrm5uRRjcfj5+eHJkydaj3nKq3///rh48SKmTZsGhUKhcnXQ8+fPsW3bNrz55pt4++238y2jR49GamoqfvnlFwAvxrA5OTlhwoQJUgKaV2JiYqET5uXVu3dv6OvrY8OGDdi8eTPefPNN6bUqCaampnjrrbewZ88eLF68WLqaTB3r16/Hjz/+CD8/PwQEBEjrP//8czx69AjDhg0r8H24f/9+7Nq1S2XdhQsX0KBBA6lru6SNHj0akZGR2LhxIy5fvow+ffqgc+fO0g/D3Kt9d+3ahRo1asDNzQ3Dhg0r8PuxImHLDSD9OgoODkb9+vVVZig+deqUdDmuuubMmYMjR47A19cXw4cPh4eHBx4/fozff/8dBw8elN58b775JrZt24a33noLXbt2xe3bt7FkyRJ4eHiozCabq3bt2mjVqhVGjhyJjIwMLFiwAJUrV8bkyZOlMosWLUKrVq3g6emJ4cOHo2bNmkhISEBkZCTu37+PS5cuafx6acLS0lIae5KVlYWqVati//79uH37tsZ1zpgxA8eOHUPXrl3h6uqKxMREfP/996hWrZrKgFK5eXh4wN/fHz4+PrC1tcX58+exZcsW6dLpP//8EwEBAXjnnXfg4eEBAwMDbN++HQkJCejbt2+h9b7//vtYunQpBg0ahAsXLsDNzQ1btmzByZMnsWDBAq0Hg6rD0NAQffv2xf/93/9BX1+/0F/6devWxdChQ3Hu3Dk4ODhgxYoVSEhIwMqVK6UykyZNwi+//II333wTgwYNgo+PD54+fYorV65gy5YtuHPnTpFN/LkzhM+dOxdHjhzB22+/DUdHR8THx2PHjh04e/YsTp06BQD4+OOPsWHDBgQFBeGjjz6Cra0tVq9ejdu3b2Pr1q1Si1inTp3g6OiIli1bwsHBATdu3MD//d//oWvXrtLrnDt77//+9z/07dsXhoaG6NatW6F/yLt27QoDAwMcPHgQ77//vvovegEGDBiAGTNmYOfOnWjZsqXKNAK//PILUlNT0b179wL3bd68Oezs7LBu3Tpp8Pn27dvRpUsXNG7cWGWG4t9//x0bNmwoVsu1vb092rVrh3nz5iE1NbVEu6RyDRgwAGvWrMG+ffvQv3//IpOpLVu2wMLCApmZmdIMxSdPnkSjRo2wefNmlbLBwcG4cuUKZs2ahYsXL6Jfv37SDMV79+7FoUOHVAYzZ2Vl4ejRoxg1alSJHWtesbGxWLlyJWJjY+Hs7AzgxXCDvXv3YuXKlZg9ezb++usv3L17F5s3b8aaNWuQk5ODcePG4e233y6xW5O8Fkr9+iwd9ueff4rhw4cLNzc3YWRkJCpVqiRatmwpvvvuO5VLqlHIDMUvXzIsxItJt0JDQ4WLi4swNDQUjo6OIiAgQCxbtkwqo1QqxezZs4Wrq6swNjYW3t7eYteuXWLgwIEqlyXnnbxt7ty5wsXFRRgbG4vWrVuLS5cu5Yvn1q1bIiQkRDg6OgpDQ0NRtWpV8eabb4otW7ZIZV41sVZRiroUvKDLMe/fvy/eeustYW1tLaysrESfPn3Ew4cPBQAxbdq0V9aRG2vupbmHDh0SPXr0EM7OzsLIyEg4OzuLfv36qVxyXNgEaoUdd0HP/fJ5/eKLL0SzZs2EtbW1MDU1Fe7u7mLWrFnSpeb//POPCA0NFe7u7sLc3FxYWVkJX19f8fPPP6s8V2GT+A0ePFhUqVJFGBkZCU9PT7Fy5UqVMnnfBy97+bV8laIud869xLdTp04F7pt3Ej8vLy9hbGws3N3dC5ysLjU1VYSFhYnatWsLIyMjUaVKFdGiRQvxzTffFDgzbEG2bNkiOnXqJGxtbYWBgYFwcnISwcHBIiIiQqVc7iR+1tbWwsTERDRr1izfJH5Lly4Vbdq0EZUrVxbGxsaiVq1aYtKkSSI5OVml3MyZM0XVqlWFnp5esS4L7969uwgICFBZp+4kfi974403BADx/fffq6zv1q2bMDExyTexZV6DBg0ShoaGKtNRPHz4UIwbN07UrVtXmJiYCDMzM+Hj4yNmzZqV7/gL88MPPwgAolKlStKkjq+i7iR+eWVnZwsnJycBQOzZs6fAMi9PvGhiYiKqVasm3nzzTbFixYp8k3PmlftdYm9vLwwMDISdnZ3o1q1bvklPf/vtN2mC0ZKAl6Y92LVrlzRVQN7FwMBAvPPOO0KIF5NrAhDR0dHSfhcuXBAAxB9//FEicb4OFEJoOfqQSs2dO3dQo0YNfP3115g4cWJZh0Pl3KVLl9C4cWOsWbMG7733Xr7tbm5uaNiwYb5m+4rs+PHj8Pf3xx9//FHgVY30euvZsycUCoVKV6yccuvu2bMngBeX2ffv3x/Xrl3LN97MwsICjo6OmDZtGmbPnq0yCeLz589hZmYmTVhYEbFbiogK9MMPP8DCwiLf3aepcK1bt0anTp3w1Vdf4YcffijrcEhGN27cwK5duxAVFVVqz+nt7Y2cnBwkJiZK81i9rGXLlsjOzla5mWfumKrSvAhB1zC5ISIVv/76K65fv45ly5Zh9OjRJTpYtDz67bffyjoEKgH169cvcvC7ptLS0hATEyM9vn37NqKiomBra4u6deuif//+CAkJwdy5c+Ht7Y2///4bhw4dgpeXF7p27YoOHTqgSZMm0p3PlUolQkND0bFjR9mu6HodMbkhIhUffvghEhIS0KVLF3z++edlHQ5RuXb+/HlpdmkAGD9+PABg4MCBWLVqFVauXIkvvvgCEyZMwIMHD1ClShU0b94cb775JoAX02H8+uuv+PDDD9GmTRuYm5sjKCgIc+fOLZPj0RUcc0NERETlCue5ISIionKFyQ0RERGVKxxzgxf3vnn48CEqVaok283QiIio/BFCIDU1Fc7Ozvluciun9PR0re4DlpeRkRFMTExkqet1weQGL6aQf/nu0ERERIW5d+8eqlWrViJ1p6eno4arBeITc15duBgcHR1x+/btCpXgMLkBpOnW7/7uBksL7TNx781Dta4jL+s/ZK0Oxknq32m8KEbJ8l4eafBUnl8rufTS5Y1PkSlffYmt1Luz8asYpMt7fYC+zPXpZckcn8z16WXJ99mQsy4AUOTIe6wZNkay1vfMoeibmqpLIfNV13rZ8rx+OVnpuLx5ZoneDiUzMxPxiTm4e8ENlpW0+5uUkqqEq88dZGZmMrmpaHK7oiwt9GBZSfsPqJ7MbyB9eb+DYGAo75eugYHMyY2BvE29evpZry6kBsUr7kytDn0jmd8rSnn/ABrI/AdVDzInNzLXpydkTG5krAsAFAp5jzXHUN4vFn0jmZMbmXt8XtxBQz6lMYTBopICFpW0ex4lKuZQCyY3REREOihHKKHt74scmZPs1wWTGyIiIh2khIBSy9ZJbfd/XZXppeCLFy+Gl5cXLC0tYWlpCT8/P5Wpy9PT0xEaGorKlSvDwsICvXv3RkJCgkodsbGx6Nq1K8zMzGBvb49JkyaVyBTZRERE9Hoo0+SmWrVqmDNnDi5cuIDz58+jffv26NGjB65duwYAGDduHH799Vds3rwZR48excOHD1Vu4peTk4OuXbsiMzMTp06dwurVq7Fq1SpMnTq1rA6JiIhIFkqZ/quIyrRbqlu3biqPZ82ahcWLF+P06dOoVq0ali9fjvXr16N9+/YAgJUrV6J+/fo4ffo0mjdvjv379+P69es4ePAgHBwc0LhxY8ycORNTpkzB9OnTYWQk80hcIiKiUpIjBHK0vEOStvu/rnRmhuKcnBxs3LgRT58+hZ+fHy5cuICsrCx06NBBKuPu7o7q1asjMjISABAZGQlPT084ODhIZQIDA5GSkiK1/hQkIyMDKSkpKgsRERGVD2We3Fy5cgUWFhYwNjbGiBEjsH37dnh4eCA+Ph5GRkawtrZWKe/g4ID4+HgAQHx8vEpik7s9d1thwsPDYWVlJS2cwI+IiHRN7oBibZeKqMyTm3r16iEqKgpnzpzByJEjMXDgQFy/fr1EnzMsLAzJycnScu/evRJ9PiIiInUpIZCj5VJRk5syvxTcyMgItWvXBgD4+Pjg3LlzWLhwIYKDg5GZmYmkpCSV1puEhAQ4OjoCeDGl9NmzZ1Xqy72aKrdMQYyNjWFsbCzzkRAREZEuKPOWm5cplUpkZGTAx8cHhoaGOHTokLQtOjoasbGx8PPzAwD4+fnhypUrSExMlMocOHAAlpaW8PDwKPXYiYiI5MJuKc2VactNWFgYgoKCUL16daSmpmL9+vWIiIjAvn37YGVlhaFDh2L8+PGwtbWFpaUlPvzwQ/j5+aF58+YAgE6dOsHDwwPvvfcevvrqK8THx+PTTz9FaGgoW2aIiOi1xqulNFemyU1iYiJCQkIQFxcHKysreHl5Yd++fejYsSMAYP78+dDT00Pv3r2RkZGBwMBAfP/999L++vr62LVrF0aOHAk/Pz+Ym5tj4MCBmDFjRlkdEhEREZWxMk1uli9fXuR2ExMTLFq0CIsWLSq0jKurK/bs2SN3aERERGVK+e+ibR0VUZkPKCYiIqL8cq940raOiojJDRERkQ7KEZDhruDyxPK60bmrpYiIiIi0wZabPO5lp6FStvb5nl6mQoZo8tSXLW/qrZC5E1ahlPmngdydxHJfLSDj8cp/LuStT+4WbdnfK3L/LJWzOrl/Mcv9Ppa9Pnmrk/u9ItdnQ/bPWBE45kZzTG6IiIh0kBIK5EC7H8tKLfd/XbFbioiIiMoVttwQERHpIKXQvhdc7p7g1wWTGyIiIh2UI0O3lLb7v67YLUVERETlCltuiIiIdBBbbjTH5IaIiEgHKYUCSqHl1VJa7v+6YrcUERERlStMboiIiHRQbreUtos6Fi9eDC8vL1haWsLS0hJ+fn747bffCi2/atUqKBQKlcXExETbQ9cau6WIiIh0UA70kKNlG0SOmuWrVauGOXPmoE6dOhBCYPXq1ejRowcuXryIBg0aFLiPpaUloqOjpccKRdl3hTG5ISIi0kFChjE3Qs39u3XrpvJ41qxZWLx4MU6fPl1ocqNQKODo6KhxjCWB3VJERETlXEpKisqSkZHxyn1ycnKwceNGPH36FH5+foWWS0tLg6urK1xcXNCjRw9cu3ZNztA1wuSGiIhIB8k55sbFxQVWVlbSEh4eXujzXrlyBRYWFjA2NsaIESOwfft2eHh4FFi2Xr16WLFiBXbu3Im1a9dCqVSiRYsWuH//fom8JsXFbikiIiIdlCP0kCO0HHPz7+0X7t27B0tLS2m9sbFxofvUq1cPUVFRSE5OxpYtWzBw4EAcPXq0wATHz89PpVWnRYsWqF+/PpYuXYqZM2dqFbs2mNwQERGVc7lXPxWHkZERateuDQDw8fHBuXPnsHDhQixduvSV+xoaGsLb2xsxMTFaxastdksRERHpICUUUEJPy0X7K5eUSmWxxugAL8bpXLlyBU5OTlo/rzbYckNERKSDyuL2C2FhYQgKCkL16tWRmpqK9evXIyIiAvv27QMAhISEoGrVqtKYnRkzZqB58+aoXbs2kpKS8PXXX+Pu3bsYNmyYVnFri8lNHveyLWCera91PXpZMgSTt75seetT5HbCylWfUu76lLLWByFvfHLWJ/9rJ2t18scn86mQvz4ZK5T5fSf7uZX7tdP1+GSqT+64dE1iYiJCQkIQFxcHKysreHl5Yd++fejYsSMAIDY2Fnp6/3X6PHnyBMOHD0d8fDxsbGzg4+ODU6dOFToAubQwuSEiItJB8gwoVi8bW758eZHbIyIiVB7Pnz8f8+fPVzesEsfkhoiISAe9GHOj5Y0zK+hdwTmgmIiIiMoVttwQERHpIKUM95ZSopwPEioEkxsiIiIdVBZjbsoLJjdEREQ6KHeuGu3qqJjJDcfcEBERUbnClhsiIiIdlCMUyBFaTuKn5f6vKyY3REREOihHhgHFOeyWIiIiInr9seWGiIhIBymFHpRaXi2l5NVSREREpCvYLaU5dksRERFRucKWGyIiIh2khPZXO8l8s/bXBpMbIiIiHSTPJH4Vs4OmYh41ERERlVtsuSEiItJB8txbqmK2YTC5ISIi0kFKKKCEtmNuOENxhXc7yw6mmdq/JPoZMgSTh16WvJfyKXJ0uz7IPS+D3CPq5IxP5kNVKGU+t7LHJ3d9uvtelvu1k/1zIXt88lYn93tFtvhK8cpqttxormIeNREREZVbbLkhIiLSQfJM4lcx2zCY3BAREekgpVBAqe08NxX0ruAVM6UjIiKicostN0RERDpIKUO3VEWdxI/JDRERkQ6S567gFTO5qZhHTUREROUWW26IiIh0UA4UyNFyEj5t939dMbkhIiLSQeyW0lzFPGoiIiIqt8o0uQkPD8cbb7yBSpUqwd7eHj179kR0dLRKGX9/fygUCpVlxIgRKmViY2PRtWtXmJmZwd7eHpMmTUJ2dnZpHgoREZGscvBf15TmS8VUpt1SR48eRWhoKN544w1kZ2fjk08+QadOnXD9+nWYm5tL5YYPH44ZM2ZIj83MzKR/5+TkoGvXrnB0dMSpU6cQFxeHkJAQGBoaYvbs2aV6PERERHJht5TmyjS52bt3r8rjVatWwd7eHhcuXECbNm2k9WZmZnB0dCywjv379+P69es4ePAgHBwc0LhxY8ycORNTpkzB9OnTYWRkVKLHQEREVBJ440zN6dRRJycnAwBsbW1V1q9btw5VqlRBw4YNERYWhmfPnknbIiMj4enpCQcHB2ldYGAgUlJScO3atQKfJyMjAykpKSoLERERlQ86c7WUUqnE2LFj0bJlSzRs2FBa/+6778LV1RXOzs64fPkypkyZgujoaGzbtg0AEB8fr5LYAJAex8fHF/hc4eHh+Pzzz0voSIiIiLQnoIBSy0u5BS8FL1uhoaG4evUqTpw4obL+/fffl/7t6ekJJycnBAQE4NatW6hVq5ZGzxUWFobx48dLj1NSUuDi4qJZ4ERERCWA3VKa04mjHj16NHbt2oUjR46gWrVqRZb19fUFAMTExAAAHB0dkZCQoFIm93Fh43SMjY1haWmpshAREVH5UKYtN0IIfPjhh9i+fTsiIiJQo0aNV+4TFRUFAHBycgIA+Pn5YdasWUhMTIS9vT0A4MCBA7C0tISHh4da8dzPtIVxpqF6B1EAvUytq1CtL1vIWp9CKWt1gJA5vhy5j1fmA5bxeOU/F/JWJ3t8SpkDlLk6WeuT+XMh+7mV/b2i48crV3xyn9ciKIUCSqFdt5K2+7+uyjS5CQ0Nxfr167Fz505UqlRJGiNjZWUFU1NT3Lp1C+vXr0eXLl1QuXJlXL58GePGjUObNm3g5eUFAOjUqRM8PDzw3nvv4auvvkJ8fDw+/fRThIaGwtjYuCwPj4iISGM5MtwVXNv9X1dletSLFy9GcnIy/P394eTkJC2bNm0CABgZGeHgwYPo1KkT3N3dMWHCBPTu3Ru//vqrVIe+vj527doFfX19+Pn5YcCAAQgJCVGZF4eIiIgqjjLvliqKi4sLjh49+sp6XF1dsWfPHrnCIiIiKnPsltKczlwtRURERP9RQg9KLTtYtN3/dVUxj5qIiIjyWbx4Mby8vKQrif38/PDbb78Vuc/mzZvh7u4OExMTeHp66kRPCpMbIiIiHZQjFLIs6qhWrRrmzJmDCxcu4Pz582jfvj169OhR6Iz/p06dQr9+/TB06FBcvHgRPXv2RM+ePXH16lU5XgKNMbkhIiLSQbljbrRd1NGtWzd06dIFderUQd26dTFr1ixYWFjg9OnTBZZfuHAhOnfujEmTJqF+/fqYOXMmmjRpgv/7v/+T4yXQGJMbIiIiHST+vSu4Nov4d4bil++nmJGR8crnz8nJwcaNG/H06VP4+fkVWCYyMhIdOnRQWRcYGIjIyEjtXwAtMLkhIiIq51xcXGBlZSUt4eHhhZa9cuUKLCwsYGxsjBEjRmD79u2FTopb2P0dC7u3Y2nh1VJEREQ6KAcK5Gh548vc/e/du6dyq6GiJrmtV68eoqKikJycjC1btmDgwIE4evSo2rP+lyUmN0RERDpIKbSfpyb3rhPq3EfRyMgItWvXBgD4+Pjg3LlzWLhwIZYuXZqvbGH3dyzs3o6lhd1SREREVCilUlnoGB0/Pz8cOnRIZd2BAwcKHaNTWthyQ0REpINyBwVrW4c6wsLCEBQUhOrVqyM1NRXr169HREQE9u3bBwAICQlB1apVpTE7Y8aMQdu2bTF37lx07doVGzduxPnz57Fs2TKt4tYWkxsiIiIdpIQCSi3H3Ki7f2JiIkJCQhAXFwcrKyt4eXlh37596NixIwAgNjYWenr/JUwtWrTA+vXr8emnn+KTTz5BnTp1sGPHDjRs2FCruLXF5IaIiIgAAMuXLy9ye0RERL51ffr0QZ8+fUooIs0wuSEiItJBmswwXFAdFRGTGyIiIh1UFmNuyouKedRERERUbrHlJo/Y5zYw0jfSuh69LBmCUalPyFqfQqnb9UHIXJ/c8clYn0IpW1Uv6suRuT7Z3yuyVgeF3O8VGevT+WOV+9zKHJ6u1id3XEVRQv17QxVUR0XE5IaIiEgHCRmulhJMboiIiEhXaHJX74LqqIg45oaIiIjKFbbcEBER6SBeLaU5JjdEREQ6iN1SmquYKR0RERGVW2y5ISIi0kFlcW+p8oLJDRERkQ5it5Tm2C1FRERE5QpbboiIiHQQW240x+SGiIhIBzG50Ry7pYiIiKhc0ajlJisrC/Hx8Xj27Bns7Oxga2srd1xEREQVGltuNFfslpvU1FQsXrwYbdu2haWlJdzc3FC/fn3Y2dnB1dUVw4cPx7lz50oyViIiogpD4L/LwTVdSvEm5jqlWMnNvHnz4ObmhpUrV6JDhw7YsWMHoqKi8OeffyIyMhLTpk1DdnY2OnXqhM6dO+PmzZslHTcREVG5lttyo+1SERWrW+rcuXM4duwYGjRoUOD2Zs2aYciQIViyZAlWrlyJ48ePo06dOrIGSkRERFQcxUpuNmzYUKzKjI2NMWLECK0CIiIiIo650QYvBc8jMb0SDPSNta5HP1OGYPLQy5K311ShlLkXNkfm+pRKeesTMscn5ItPIfOhyn5u5e6wl/lcKGR+7ynkrE72c6Hb51b+97K89cl2vKU4iIXJjebUTm7S09Px3Xff4ciRI0hMTITypT9Ev//+u2zBEREREalL7eRm6NCh2L9/P95++200a9YMCkXFzAqJiIhKEltuNKd2crNr1y7s2bMHLVu2LIl4iIiICIAQCggtkxNt939dqT1DcdWqVVGpUqWSiIWIiIhIa2onN3PnzsWUKVNw9+7dkoiHiIiIoP0EfrlLRaR2t1TTpk2Rnp6OmjVrwszMDIaGhirbHz9+LFtwREREFRXH3GhO7eSmX79+ePDgAWbPng0HBwcOKCYiIiKdonZyc+rUKURGRqJRo0YlEQ8RERGBA4q1oXZy4+7ujufPn5dELERERPQvdktpTu0BxXPmzMGECRMQERGBR48eISUlRWUhIiIi7eW23Gi7VERqt9x07twZABAQEKCyXggBhUKBnJwceSIjIiIi0oDayc2RI0dKIg4iIiLKQ8jQLcWWm2Jq0aJFvsu/c/3zzz9aB0REREQv7tGp7f1SS/E+nzpF7TE3ffv2hSjg1U5ISIC/v78cMRERERFpTO3kJjY2FsOGDVNZFxcXB39/f7i7u8sWGBERUUXGGYo1p3Zys2fPHpw6dQrjx48HADx8+BD+/v7w9PTEzz//LHuAREREFRGvltKc2smNnZ0d9u/fj61bt2L8+PHw9/eHt7c3NmzYAD099aoLDw/HG2+8gUqVKsHe3h49e/ZEdHS0Spn09HSEhoaicuXKsLCwQO/evZGQkKBSJjY2Fl27doWZmRns7e0xadIkZGdnq3toREREVA6oPaAYAFxcXHDgwAG0bt0aHTt2xE8//aTRbRiOHj2K0NBQvPHGG8jOzsYnn3yCTp064fr16zA3NwcAjBs3Drt378bmzZthZWWF0aNHo1evXjh58iQAICcnB127doWjoyNOnTqFuLg4hISEwNDQELNnz1Yrnr+fWUAfxmofx8v0MrWuQrW+bKWs9Smy5R1iplDKGx9krk7rEXklWJ9CKfe5kLU6KHJ0Oz65R0vKebwKud93cp9buUeayl6fbr73ZH8PF0EpFFCU4iR+4eHh2LZtG/744w+YmpqiRYsW+PLLL1GvXr1C91m1ahUGDx6sss7Y2Bjp6ekaxyyHYiU3NjY2BSYvz549w6+//orKlStL69S5cebevXtVHq9atQr29va4cOEC2rRpg+TkZCxfvhzr169H+/btAQArV65E/fr1cfr0aTRv3hz79+/H9evXcfDgQTg4OKBx48aYOXMmpkyZgunTp8PIyKjY8RAREekKIWS4WkqN/YvT4FAQS0tLlV4XXbjnZLGSmwULFpRwGC8kJycDAGxtbQEAFy5cQFZWFjp06CCVcXd3R/Xq1REZGYnmzZsjMjISnp6ecHBwkMoEBgZi5MiRuHbtGry9vUsldiIiotfZqxocCqNQKODo6FjS4amlWMnNwIEDSzoOKJVKjB07Fi1btkTDhg0BAPHx8TAyMoK1tbVKWQcHB8THx0tl8iY2udtztxUkIyMDGRkZ0mPeNoKIiHRNWd848+UGh8KkpaXB1dUVSqUSTZo0wezZs9GgQQONn1cOxRoB/PTpU7UqVbc8AISGhuLq1avYuHGj2vuqKzw8HFZWVtLi4uJS4s9JRESkDjmvlnr5PpB5f+AXpKAGh4LUq1cPK1aswM6dO7F27VoolUq0aNEC9+/fl/W1UFexkpvatWtjzpw5iIuLK7SMEAIHDhxAUFAQvv32W7WCGD16NHbt2oUjR46gWrVq0npHR0dkZmYiKSlJpXxCQoLUBObo6Jjv6qncx4U1k4WFhSE5OVla7t27p1a8REREJS33ruDaLsCLC4Hy/qgPDw8v8rmL2+Dg5+eHkJAQNG7cGG3btsW2bdtgZ2eHpUuXyvY6aKJY3VIRERH45JNPMH36dDRq1AhNmzaFs7MzTExM8OTJE1y/fh2RkZEwMDBAWFgYPvjgg2I9uRACH374IbZv346IiAjUqFFDZbuPjw8MDQ1x6NAh9O7dGwAQHR2N2NhY+Pn5AXjxws6aNQuJiYmwt7cHABw4cACWlpbw8PAo8HmNjY1hbKz9VVFERESvg3v37sHS0lJ6XNTfwNwGh2PHjqk0OBSHoaEhvL29ERMTo3GscihWclOvXj1s3boVsbGx2Lx5M44fP45Tp07h+fPnqFKlCry9vfHDDz8gKCgI+vr6xX7y0NBQrF+/Hjt37kSlSpWkMTJWVlYwNTWFlZUVhg4divHjx8PW1haWlpb48MMP4efnh+bNmwMAOnXqBA8PD7z33nv46quvEB8fj08//RShoaFMYIiI6LUl59VSlpaWKslNwWWLbnAojpycHFy5cgVdunTRJFzZqDXPTfXq1TFhwgRMmDBBlidfvHgxAOS7J9XKlSsxaNAgAMD8+fOhp6eH3r17IyMjA4GBgfj++++lsvr6+ti1axdGjhwJPz8/mJubY+DAgZgxY4YsMRIREZWFF8mNtgOKi1/2VQ0OABASEoKqVatK3VozZsxA8+bNUbt2bSQlJeHrr7/G3bt3892mqbRpNImfXAq6AefLTExMsGjRIixatKjQMq6urtizZ4+coREREVUoxWlwiI2NVbkbwZMnTzB8+HDEx8fDxsYGPj4+OHXqVKHDQkpLmSY3REREVLDSvhS8OA0OERERKo/nz5+P+fPnqxtWiWNyQ0REpIMEtL+rhdx3xXhdqH3jTCIiIiJdxpYbIiIiHVTWMxS/zjRquTl+/DgGDBgAPz8/PHjwAADw008/4cSJE7IGR0REVGEJmZYKSO3kZuvWrQgMDISpqSkuXrwoTeGcnJyM2bNnyx4gERFRhSTHrRfYclM8X3zxBZYsWYIffvgBhoaG0vqWLVvi999/lzU4IiIiInWpPeYmOjq6wFufW1lZ5bsHFBEREWlGzhmKKxq1W24cHR0LvGfEiRMnULNmTVmCIiIiqujkvCt4RaN2y83w4cMxZswYrFixAgqFAg8fPkRkZCQmTpyIzz77rCRiLDWpT42hL0y0rscmQ95UWZGllLc+uTN5mX8aKJTyHi9ydLc+vSzZqgJQEudW3uoUcv+M1OX6dP1zIXt8slYn+3tZrvjkPk4qGWonNx9//DGUSiUCAgLw7NkztGnTBsbGxpg4cSI+/PDDkoiRiIio4pFjQDBbbl4tJycHJ0+eRGhoKCZNmoSYmBikpaXBw8MDFhYWJRUjERFRhcMxN5pTK7nR19dHp06dcOPGDVhbW5f5jbGIiIiIXqb2gOKGDRvir7/+KolYiIiIKBcn8dOYRvPcTJw4Ebt27UJcXBxSUlJUFiIiItIer5bSnNoDirt06QIA6N69OxSK/140IQQUCgVycnLki46IiIhITWonN0eOHCmJOIiIiOhlFbRbSVtqJzdt27YtiTiIiIgoD94VXHNqJzcAkJSUhOXLl+PGjRsAgAYNGmDIkCGwsrKSNTgiIqIKS44BwRW05UftAcXnz59HrVq1MH/+fDx+/BiPHz/GvHnzUKtWLd44k4iIiMqc2i0348aNQ/fu3fHDDz/AwODF7tnZ2Rg2bBjGjh2LY8eOyR4kERFRxaP4d9G2jopH7eTm/PnzKokNABgYGGDy5Mlo2rSprMERERFVWOyW0pja3VKWlpaIjY3Nt/7evXuoVKmSLEERERERaUrt5CY4OBhDhw7Fpk2bcO/ePdy7dw8bN27EsGHD0K9fv5KIkYiIqOLhDMUaU7tb6ptvvoFCoUBISAiys7MBAIaGhhg5ciTmzJkje4BEREQVEu8KrjG1kxsjIyMsXLgQ4eHhuHXrFgCgVq1aMDMzkz04IiIiInVpNM8NAJiZmcHT01POWIiIiOhfQrxYtK2jIlI7uXn69CnmzJmDQ4cOITExEUqlUmX763zH8KynRshRGmldj36GvO8mvSzlqwupQyFvM6UiR+ZPj1Lm+oTMr5+M3xb6WfIeq0Lm1072+mR+r8gdn6zjE2R+28n9V0oh80sne31y36ZQrtevNLMFXi2lMbWTm2HDhuHo0aN477334OTkpHLzTCIiIqKypnZy89tvv2H37t1o2bJlScRDREREAAcUa0Ht5MbGxga2trYlEQsRERH9SyG07+6Tu7vwdaH2PDczZ87E1KlT8ezZs5KIh4iIiADOc6OFYrXceHt7q4ytiYmJgYODA9zc3GBoaKhSljfPJCIioldp27YtAgIC4O/vDz8/v3z5hDaKldz07NlTtickIiKiYijnY25q1KiBlStXYvr06TA1NYWfnx/atWuH9u3bo1mzZtDX19e47mIlN9OmTdP4CYiIiEgD5fxS8FWrVgEA7ty5g8OHD+Po0aNYtmwZPvvsM1hYWKBly5Zo3749Jk2apHbdao+5ySs9PR2rV6/G999/j5s3b2pTFREREVVAbm5uGDJkCFavXo27d+8iJiYGH330EU6dOoWPP/5YozqLfbXU+PHjkZWVhe+++w4AkJmZiebNm+P69eswMzPD5MmTsX//frRo0UKjQIiIiCiPct5yk9fdu3cREREhLYmJiWjevDnatm2rUX3FTm7279+P2bNnS4/XrVuH2NhY3Lx5E9WrV8eQIUMwa9Ys7N69W6NAiIiIKI9yntysWbNGSmb++ecftGjRAm3btsXw4cPxxhtvaDXAuNjJTWxsLDw8PKTH+/fvx9tvvw1XV1cAwJgxY9ClSxeNAyEiIqKKY9CgQahevTo+/vhjDB06VNarpYo95kZPTw8izz01Tp8+jebNm0uPra2t8eTJE9kCIyIiqtByr5bSdtFR33//PZo3b47PP/8c9vb26NatG+bOnYvz58+r5BuaKHZyU79+ffz6668AgGvXriE2Nhbt2rWTtt+9excODg5aBUNEREQv5M5QrO2iq0aMGIGNGzciLi4OJ0+eRJcuXXD27Fl07doVNjY26Nq1K7755huN6i52cjN58mSEhYUhICAAAQEB6NKlC2rUqCFt37NnD5o1a6ZREERERFS2wsPD8cYbb6BSpUqwt7dHz549ER0d/cr9Nm/eDHd3d5iYmMDT0xN79uxR+7k9PDwwcuRIbNq0CRcvXsTo0aNx4sQJTJkyRZNDKX5y89Zbb2HPnj3w8vLCuHHjsGnTJpXtZmZmGDVqlEZBEBER0UtK+fYLR48eRWhoKE6fPo0DBw4gKysLnTp1wtOnTwvd59SpU+jXrx+GDh2KixcvomfPnujZsyeuXr1a7OdNTEzEpk2bMHLkSNSvXx8uLi745ptv4O3tjalTpxb/APJQCG07tsqBlJQUWFlZweX76dAzNdG6Puff1L4faZHM7z+XtT4o5O2D1U/LkLU+xfNMWetDpsz1ZWXLVlXaG9VlqwsAFEp5P856GUpZ69PPlLc+Rbbc9cn3+skeW06OrPVlVjGTtb7ndvINBgUAvSx538uKHHnqy85Kx9lfPkNycjIsLS1lqfNluX+Tqn/5hdZ/k5TP0xE75VON4v37779hb2+Po0ePok2bNgWWCQ4OxtOnT7Fr1y5pXfPmzdG4cWMsWbKkyPpHjRqFiIgIREdHw8DAAM2aNYO/vz/atWuHFi1awMRE82OX968wERERyUIBGe4K/u//U1JSVNYbGxvD2Ni4yH2Tk5MBALa2toWWiYyMxPjx41XWBQYGYseOHa+MLbelp127dmjZsiXMzORLuJncEBERlXMuLi4qj6dNm4bp06cXWl6pVGLs2LFo2bIlGjZsWGi5+Pj4fBcTOTg4ID4+/pUxRUZGAniReBWW2MTExKB27dqvrOtlTG7yUKQZQJGj/Uuinylzc2qWvM3bwkCru27kp5Q3Ptnrk7vnVcb69GTupoGevF2Osl9pIXN9CplfPoWM51bOugAAMh+r/OdC7s+ZvNXJ9V4u1auPZLxx5r1791S6pV7VahMaGoqrV6/ixIkT2j1/MXTt2hUHDhzI1w0VHR2NgIAA3L9/X+06Zf4rR0RERLKQcUCxpaWlylJUcjN69Gjs2rULR44cQbVq1YoM0dHREQkJCSrrEhIS4OjoWOzDtLCwQK9evZCd/d94xhs3bsDf3x+9e/cudj15aZzc/P333zhx4gROnDiBv//+W9NqiIiISAcIITB69Ghs374dhw8fVpnupTB+fn44dOiQyroDBw7Az8+v2M+7bds2JCcno3///hBC4OrVq/D390e/fv2wcOFCtY8D0CC5efr0KYYMGQJnZ2e0adMGbdq0gbOzM4YOHYpnz55pFAQRERG9pJQvBQ8NDcXatWuxfv16VKpUCfHx8YiPj8fz5/9dsRsSEoKwsDDp8ZgxY7B3717MnTsXf/zxB6ZPn47z589j9OjRxX5eU1NT7N69G9HR0XjnnXcQEBCAkJAQzJs3r/jBv0Tt5Gb8+PE4evQofvnlFyQlJSEpKQk7d+7E0aNHMWHCBI0DISIiov+U9gzFixcvRnJyMvz9/eHk5CQteee1i42NRVxcnPS4RYsWWL9+PZYtW4ZGjRphy5Yt2LFjR5GDkIEXg4jzLnp6eti0aRPOnDmD3r1747PPPpO2aULt5Gbr1q1Yvnw5goKCpL67Ll264IcffsCWLVvUquvYsWPo1q0bnJ2doVAo8l06NmjQICgUCpWlc+fOKmUeP36M/v37w9LSEtbW1hg6dCjS0tLUPSwiIqIKTQhR4DJo0CCpTEREBFatWqWyX58+fRAdHY2MjAxcvXq1WDfRtra2ho2Njcri4eGB+/fvY8mSJbCxsZHKaELtS4OePXtW4D2k7O3t1e6Wevr0KRo1aoQhQ4agV69eBZbp3LkzVq5cKT1+eRBU//79ERcXJ82mOHjwYLz//vtYv369WrEQERHpFDW7lQqtQwcdOXKkROtXO7nx8/PDtGnTsGbNGumyrefPn+Pzzz9XawARAAQFBSEoKKjIMsbGxoWOur5x4wb27t2Lc+fOoWnTpgCA7777Dl26dME333wDZ2dnteIhIiLSGeU4uWnbti1WrFiBbt26wc7OTvb61e6WWrBgAU6ePIlq1apJN9F0cXHBqVOnNB7VXJSIiAjY29ujXr16GDlyJB49eiRti4yMhLW1tZTYAECHDh2gp6eHM2fOFFpnRkZGvv4+IiIiKj1r166Fi4sLWrRogS+//BI3btyQrW61kxtPT0/cvHkT4eHhaNy4MRo3bow5c+bg5s2baNCggWyBAS+6pNasWYNDhw7hyy+/xNGjRxEUFIScf++xEh8fD3t7e5V9DAwMYGtrW+TsiOHh4bCyspKWl2duJCIiKmulPaC4tB0+fBhxcXEYNWoULly4AF9fX9SpUwcTJkzAsWPHoNRiQle1u6WOHTuGFi1aYPjw4Srrs7OzcezYsUJvrqWJvn37Sv/29PSEl5cXatWqhYiICAQEBGhcb1hYmMq9MFJSUpjgEBGRbpFxhmJdZWNjgwEDBmDAgAHIzMzE4cOH8csvv6B///54/vw5unTpgu7duyMoKAjm5ubFrlftlpt27drh8ePH+dYnJyejXbt26lanlpo1a6JKlSqIiYkB8GJmxMTERJUy2dnZePz4cZGzIxobG+ebrZGIiEinlPI8N2XNyMgInTt3xvfff4979+5h3759cHNzw8yZM9We80btlhshBBSK/Jngo0eP1MqqNHH//n08evQITk5OAF4Mbk5KSsKFCxfg4+MD4EUzl1KphK+vb4nGQkRERNrJzs6GUqmEkZGRtO7HH3/E8ePH0bRpU3z++eeYMWMGsrKy1Kq32MlN7qXaCoUCgwYNUrkkOycnB5cvX0aLFi3UevK0tDSpFQYAbt++jaioKNja2sLW1haff/45evfuDUdHR9y6dQuTJ09G7dq1ERgYCACoX78+OnfujOHDh2PJkiXIysrC6NGj0bdvX14pRURErzU5xszo8pgb4MV0LjVr1kR4eDgAYOnSpRg/fjyCgoIwY8YMPHz4EOHh4TA0NFSr3mJ3S+UOvhVCoFKlSioDch0dHfH+++9j7dq1aj35+fPn4e3tDW9vbwAvZj/29vbG1KlToa+vj8uXL6N79+6oW7cuhg4dCh8fHxw/flwlsVq3bh3c3d0REBCALl26oFWrVli2bJlacRAREemcCtAt9fvvv6tMzrt06VIsWLAAW7ZswebNmzWes67YLTe5E+m5ublh4sSJsnRB+fv7Q4jCX/l9+/a9sg5bW1tO2EdERPQaGTx4MIAXw02+/fZbrF69GkIIXLp0Cb/99hsiIyORnZ2Nhw8fYsiQIQCAFStWFLt+tcfcTJs2Td1diIiISF1yXMqtoy03uQ0mhw8fxtixY9G6dWvs3r0bJ0+exLZt2wC8uFBp586daiU1udROboiIiKgUlOMZinP5+/vj/fffR0hICFauXIng4GBp26VLl1CnTh2N6mVyk4fBUz3o5ah9dXw+ehnqjep+FUVWjqz1qT8BwCvkyPzpKaKrUiM5mk8EVSAtJpZ6mX6mvLHlGMp7chVKec+F3PXJ/16RsT6ZY1Poen3ZslZXAu893aqHXpg3bx7Gjh2L9evXo3379vjkk0+kbTt27MCAAQM0qpfJDRERkS6qAC03lStXxk8//VTgNnXntslLq+QmPT1dunkmERERyaciXApeUtRuw1YqlZg5cyaqVq0KCwsL/PXXXwCAzz77DMuXL5c9QCIiIiJ1qJ3cfPHFF1i1ahW++uorlRkFGzZsiB9//FHW4IiIiIjUpXZys2bNGixbtgz9+/eHvr6+tL5Ro0b4448/ZA2OiIiowqoAk/iVFLXH3Dx48AC1a9fOt16pVKp97wciIiIqGMfcaE7tlhsPDw8cP3483/otW7ZIt1EgIiIiKitqt9xMnToVAwcOxIMHD6BUKrFt2zZER0djzZo12LVrV0nESEREVDFV0JYXbandctOjRw/8+uuvOHjwIMzNzTF16lTcuHEDv/76Kzp27FgSMRIREVU8HHOjMY3muWndujUOHDggdyxEREREWlM7uTl37hyUSiV8fX1V1p85cwb6+vpo2rSpbMERERFVVBxQrDm1u6VCQ0Nx7969fOsfPHiA0NBQWYIiIiKq8NgtpTG1k5vr16+jSZMm+dZ7e3vj+vXrsgRFREREpCm1kxtjY2MkJCTkWx8XFwcDA96Hk4iISA653VLaLhWR2slNp06dEBYWhuTkZGldUlISPvnkE14tRUREJBd2S2lM7aaWb775Bm3atIGrq6s0aV9UVBQcHBwKvW05ERERUWlRO7mpWrUqLl++jHXr1uHSpUswNTXF4MGD0a9fPxgaGpZEjERERBWPHC0vbLkpPnNzc7z//vtyx0JERET/4qXgmtMoubl58yaOHDmCxMREKJVKlW1Tp06VJbCyoP8M0M/Rvh6DdBkqyUORmS1rfTBQe6hVkRRC5k+PUub65I5Pxvr0MpWvLqQGpb5C1voUObr72gGAQub3iqzvZR1/7SDvWw/6Mr+XhczvZdleP7nPQ5HPBbbcaEjt5OaHH37AyJEjUaVKFTg6OkKh+O8NqFAoXuvkhoiIiF5/aic3X3zxBWbNmoUpU6aURDxEREQEsOVGC2onN0+ePEGfPn1KIhYiIiL6F8fcaE7twRd9+vTB/v37SyIWIiIiIq2p3XJTu3ZtfPbZZzh9+jQ8PT3zXf790UcfyRYcERFRhcVuKY2pndwsW7YMFhYWOHr0KI4ePaqyTaFQMLkhIiKSAbulNKd2cnP79u2SiIOIiIhIFvJOeEJERETyKIN7Sx07dgzdunWDs7MzFAoFduzYUWT5iIgIKBSKfEt8fLx6TywzjSbxu3//Pn755RfExsYiMzNTZdu8efNkCYyIiKhCK4MxN0+fPkWjRo0wZMgQ9OrVq9j7RUdHw9LSUnpsb2+v3hPLTO3k5tChQ+jevTtq1qyJP/74Aw0bNsSdO3cghECTJk1KIkYiIiIqBUFBQQgKClJ7P3t7e1hbW8sfkIbU7pYKCwvDxIkTceXKFZiYmGDr1q24d+8e2rZty/lviIiIZKKQaSkNjRs3hpOTEzp27IiTJ0+W0rMWTu3k5saNGwgJCQEAGBgY4Pnz57CwsMCMGTPw5Zdfyh4gERFRhSTjmJuUlBSVJSMjQ5YQnZycsGTJEmzduhVbt26Fi4sL/P398fvvv8tSv6bU7pYyNzeXxtk4OTnh1q1baNCgAQDgn3/+kTc6IiKiCkrOS8FdXFxU1k+bNg3Tp0/XrnIA9erVQ7169aTHLVq0wK1btzB//nz89NNPWtevKbWTm+bNm+PEiROoX78+unTpggkTJuDKlSvYtm0bmjdvXhIxEhERkRbu3bunMuDX2Ni4xJ6rWbNmOHHiRInVXxxqJzfz5s1DWloaAODzzz9HWloaNm3ahDp16vBKKSIiIrnIeLWUpaWlSnJTkqKiouDk5FQqz1UYtZObmjVrSv82NzfHkiVLZA2IiIiI/lXKMwynpaUhJiZGenz79m1ERUXB1tYW1atXR1hYGB48eIA1a9YAABYsWIAaNWqgQYMGSE9Px48//ojDhw+X+T0o1R5QXLNmTTx69Cjf+qSkJJXEh4iIiF4v58+fh7e3N7y9vQEA48ePh7e3N6ZOnQoAiIuLQ2xsrFQ+MzMTEyZMgKenJ9q2bYtLly7h4MGDCAgIKJP4c6ndcnPnzh3k5OTkW5+RkYEHDx7IElRZMUwD9LO0r0cvI//row1FVras9YlsjeZuLFyOUt76lPK+fhAy//SRsT69THmPVV9P3gs/5Y5PkSXze0XuOdZlPLcKHX7fAfLHp58u77lVGsl7chXZ8hyvXlbpNaWUxb2l/P39IYp4b6xatUrl8eTJkzF58mQNIitZxf4r98svv0j/3rdvH6ysrKTHOTk5OHToENzc3GQNjoiIqMLiXcE1VuzkpmfPngBe3Pl74MCBKtsMDQ3h5uaGuXPnyhocERERkbqKndwolS+aHGvUqIFz586hSpUqJRYUERFRRVcW3VLlhdqDL27fvp1vXVJSkk7dU4KIiOi1x24pjak9YuvLL7/Epk2bpMd9+vSBra0tqlatikuXLskaHBEREZG61E5ulixZIk3jfODAARw8eBB79+5FUFAQJk2aJHuAREREFVFut5S2S0WkdrdUfHy8lNzs2rUL77zzDjp16gQ3Nzf4+vrKHiAREVGFxG4pjandcmNjY4N79+4BAPbu3YsOHToAAIQQBc5/Q0RERBqQ8a7gFY3aLTe9evXCu+++izp16uDRo0cICgoCAFy8eBG1a9eWPUAiIiIidaid3MyfPx9ubm64d+8evvrqK1hYWAB4MSXzqFGjZA+QiIioIuKl4JpTu1vK0NAQEydOxMKFC6V7TwDAuHHjMGzYMLXqOnbsGLp16wZnZ2coFArs2LFDZbsQAlOnToWTkxNMTU3RoUMH3Lx5U6XM48eP0b9/f1haWsLa2hpDhw6V7lpORET02mK3lMaK1XLzyy+/ICgoCIaGhiq3YShI9+7di/3kT58+RaNGjTBkyBD06tUr3/avvvoK3377LVavXo0aNWrgs88+Q2BgIK5fvw4TExMAQP/+/REXF4cDBw4gKysLgwcPxvvvv4/169cXOw4iIiIqP4qV3PTs2RPx8fGwt7eXbsNQEIVCodag4qCgIGnMzsuEEFiwYAE+/fRT9OjRAwCwZs0aODg4YMeOHejbty9u3LiBvXv34ty5c2jatCkA4LvvvkOXLl3wzTffwNnZudixEBER6RKFEFrf4FT2G7i+JorVLaVUKmFvby/9u7BFzqulbt++jfj4eOlqLACwsrKCr68vIiMjAQCRkZGwtraWEhsA6NChA/T09HDmzBnZYiEiIip17JbSmNoDiktLfHw8AMDBwUFlvYODg7QttzUpLwMDA9ja2kplCpKRkYGMjAzpcUpKilxhExERURlTa0CxUqnEihUr8Oabb6Jhw4bw9PRE9+7dsWbNGojXqOkrPDwcVlZW0pI7KSEREZGu4AzFmit2ciOEQPfu3TFs2DA8ePAAnp6eaNCgAe7evYtBgwbhrbfekjUwR0dHAEBCQoLK+oSEBGmbo6MjEhMTVbZnZ2fj8ePHUpmChIWFITk5WVpyJyUkIiLSGeyW0lixu6VWrVqFY8eO4dChQ2jXrp3KtsOHD6Nnz55Ys2YNQkJCZAmsRo0acHR0xKFDh9C4cWMAL7qPzpw5g5EjRwIA/Pz8kJSUhAsXLsDHx0eKRalUFnkrCGNjYxgbG8sSJxEREemWYic3GzZswCeffJIvsQGA9u3b4+OPP8a6devUSm7S0tIQExMjPb59+zaioqJga2uL6tWrY+zYsfjiiy9Qp04d6VJwZ2dn6Yqt+vXro3Pnzhg+fDiWLFmCrKwsjB49Gn379tXoSinDp4B+ltq75aOXka19JXllyRBUHgqlkaz1QamUuT6Zf2rocHyKdHnfK3oKhbz1Zcl7SxWFzPUpjWQeNihn97rcXfWy1ydvdfoZ8n7OFDJ/bBU58hywyJY5sCJwEj/NFbtb6vLly+jcuXOh24OCgnDp0iW1nvz8+fPw9vaWJgMcP348vL29MXXqVADA5MmT8eGHH+L999/HG2+8gbS0NOzdu1ea4wYA1q1bB3d3dwQEBKBLly5o1aoVli1bplYcREREOofdUhor9s+ex48f57tyKS8HBwc8efJErSf39/cvciCyQqHAjBkzMGPGjELL2NracsI+IiIqd9hyo7lit9zk5OTAwKDwXEhfXx/Z2TJ3xxARERGpqdgtN0IIDBo0qNCBuHnnjSEiIiItydGtVEFbboqd3AwcOPCVZeS6UoqIiIgqbreStoqd3KxcubIk4yAiIiKShc7efoGIiKhCE0L7KQBeo7sHyInJDRERkQ7i1VKaU+veUkRERES6ji03REREuohXS2mMyQ0REZEOUii1vw2F3LexeF2wW4qIiIjKFbbcEBER6SJ2S2mMyQ0REZEO4tVSmmNyQ0REpIs4z43GOOaGiIiIyhW23BAREekgdktpjslNHkapShgYan/dnCIjS4Zo8sjKlrU6Raa89SFL7uOVuT6lvNdCCiFffXKfC7mbYhU5OfLWly3vudCTu8ldxvgUcr/v9OQ9u3pZ8sanyJG7PnmPV5Ejz3tFZMv8/Vnkk4EDijXEbikiIiIqV9hyQ0REpIPYLaU5JjdERES6iFdLaYzdUkRERAQAOHbsGLp16wZnZ2coFArs2LHjlftERESgSZMmMDY2Ru3atbFq1aoSj/NVmNwQERHpoNxuKW0XdTx9+hSNGjXCokWLilX+9u3b6Nq1K9q1a4eoqCiMHTsWw4YNw759+zQ4YvmwW4qIiEgXlcHVUkFBQQgKCip2+SVLlqBGjRqYO3cuAKB+/fo4ceIE5s+fj8DAQPWeXEZsuSEiIirnUlJSVJaMjAxZ6o2MjESHDh1U1gUGBiIyMlKW+jXF5IaIiEgHydkt5eLiAisrK2kJDw+XJcb4+Hg4ODiorHNwcEBKSgqeP38uy3Nogt1SREREukgpXiza1gHg3r17sLS0lFYbGxtrV6+OY3JDRESki2Qcc2NpaamS3MjF0dERCQkJKusSEhJgaWkJU1NT2Z+vuNgtRURERBrx8/PDoUOHVNYdOHAAfn5+ZRTRC0xuiIiIdJACMoy5UfM509LSEBUVhaioKAAvLvWOiopCbGwsACAsLAwhISFS+REjRuCvv/7C5MmT8ccff+D777/Hzz//jHHjxsnzImiI3VJERES6qAxmKD5//jzatWsnPR4/fjwAYODAgVi1ahXi4uKkRAcAatSogd27d2PcuHFYuHAhqlWrhh9//LFMLwMHmNwQERHRv/z9/SGKSIgKmn3Y398fFy9eLMGo1MfkhoiISAfxxpmaY3JDRESki8pghuLyggOKiYiIqFxhyw0REZEOUggBhZYDirXd/3XF5CYPw9QcGBjmaF2P4nmmDNHkkZUlb33p8txTRJIh7/EKmY9XoZC5gVLbGUPzUGTKfKxyf5Fla/95KMn6FDkyf4UplfLVlSNjXQAUBvqy1qeXLvP3So687z39LHUvYn4FmT4bejnZstRTLMp/F23rqIDYLUVERETlCltuiIiIdBC7pTTH5IaIiEgX8WopjTG5ISIi0kVlMENxecExN0RERFSusOWGiIhIB3GGYs0xuSEiItJF7JbSGLuliIiIqFxhyw0REZEOUihfLNrWURExuSEiItJF7JbSGLuliIiIqFxhyw0REZEu4iR+GmNyQ0REpIN4+wXNsVuKiIiIyhW23BAREekiDijWGJMbIiIiXSQAaHspd8XMbXS7W2r69OlQKBQqi7u7u7Q9PT0doaGhqFy5MiwsLNC7d28kJCSUYcRERETyyB1zo+1SEel8y02DBg1w8OBB6bGBwX8hjxs3Drt378bmzZthZWWF0aNHo1evXjh58qRGz2WUmgUDA32tY0Z6hvZ15CEys2StT6Enb04rMjJlrQ/Z2bJWJ4wMZa0POTny1SXze0Xu1w45Ms8AppS7PhnPBSDv8cp9rNkyfDfloTCU9+tfIfPxCpm/p+T6I6+XI+/3MZUMnU9uDAwM4OjomG99cnIyli9fjvXr16N9+/YAgJUrV6J+/fo4ffo0mjdvXtqhEhERyUdAhjE3skTy2tHpbikAuHnzJpydnVGzZk30798fsbGxAIALFy4gKysLHTp0kMq6u7ujevXqiIyMLLLOjIwMpKSkqCxEREQ6JXdAsbZLBaTTyY2vry9WrVqFvXv3YvHixbh9+zZat26N1NRUxMfHw8jICNbW1ir7ODg4ID4+vsh6w8PDYWVlJS0uLi4leBRERERUmnS6WyooKEj6t5eXF3x9feHq6oqff/4ZpqamGtcbFhaG8ePHS49TUlKY4BARkW5RAlDIUEcFpNPJzcusra1Rt25dxMTEoGPHjsjMzERSUpJK601CQkKBY3TyMjY2hrGxcQlHS0REpDnOUKw5ne6WellaWhpu3boFJycn+Pj4wNDQEIcOHZK2R0dHIzY2Fn5+fmUYJREREZUlnW65mThxIrp16wZXV1c8fPgQ06ZNg76+Pvr16wcrKysMHToU48ePh62tLSwtLfHhhx/Cz8+PV0oREdHrjzMUa0ynk5v79++jX79+ePToEezs7NCqVSucPn0adnZ2AID58+dDT08PvXv3RkZGBgIDA/H999+XcdREREQyYHKjMZ1ObjZu3FjkdhMTEyxatAiLFi0qpYiIiIhI1+l0ckNERFRhseVGY0xuiIiIdBEvBdcYkxsiIiIdxEvBNfdaXQpORERE9CpsuSEiItJFHHOjMSY3REREukgpAIWWyYmyYiY37JYiIiKicoXJDRERkS7K7ZbSdlHTokWL4ObmBhMTE/j6+uLs2bOFll21ahUUCoXKYmJios1Ry4LJDRERkU6SI7FRL7nZtGkTxo8fj2nTpuH3339Ho0aNEBgYiMTExEL3sbS0RFxcnLTcvXtXy+PWHsfc5KGf8hz6+tpPCiDS02WIJm99GbLWB6W8Ex+I7GxZ60NOjm7XJ2MftiIzU7a6AADZMv9ekfm9Inv/f5a2k4C8RMb4hJD3tVPo68tbn4HMX/9yH69C5veyXPEpZf4+1jHz5s3D8OHDMXjwYADAkiVLsHv3bqxYsQIff/xxgfsoFAo4OjqWZpivxJYbIiIiXVTK3VKZmZm4cOECOnToIK3T09NDhw4dEBkZWeh+aWlpcHV1hYuLC3r06IFr165pddhyYHJDRESki5RCngVASkqKypKRkb8F6p9//kFOTg4cHBxU1js4OCA+Pr7AEOvVq4cVK1Zg586dWLt2LZRKJVq0aIH79+/L/3qogckNERFROefi4gIrKytpCQ8Pl6VePz8/hISEoHHjxmjbti22bdsGOzs7LF26VJb6NcUxN0RERLpIKLUfK/Tv/vfu3YOlpaW02tjYOF/RKlWqQF9fHwkJCSrrExISij2mxtDQEN7e3oiJidEiaO2x5YaIiEgXyTjmxtLSUmUpKLkxMjKCj48PDh06JK1TKpU4dOgQ/Pz8ihVyTk4Orly5AicnJ3leAw2x5YaIiEgXKdW/lLvgOopv/PjxGDhwIJo2bYpmzZphwYIFePr0qXT1VEhICKpWrSp1a82YMQPNmzdH7dq1kZSUhK+//hp3797FsGHDtItbS0xuiIiICAAQHByMv//+G1OnTkV8fDwaN26MvXv3SoOMY2Njoaf3X6fPkydPMHz4cMTHx8PGxgY+Pj44deoUPDw8yuoQAAAKISroXbXySElJgZWVFQLqT4CBfv6mOrXF/a19HXmIp89lrU9hZChrfTo/z43M84PIOReKnqWFbHW9qLCCzXOjx3luNGZuLm99Mh8vdHSem2xlBg7Gfo/k5GSVMSxyyv2b1MH5Axjoafc3KVuZgYMPl5ZovLqILTdERES6SECGu4LLEslrhwOKiYiIqFxhyw0REZEu0vDGl/nqqICY3BAREekipRKAlmOF5B4395pgtxQRERGVK2y5ISIi0kXsltIYkxsiIiJdxORGY+yWIiIionKFLTdERES6qAxuv1BeMLnJQ5GcBoVeltb1KJ+nyxBNnvoyM2WtTyHzDMBC7hmFK8hMpwCgeC7zR1DuWWzlfq/IfOWGQuYZmeWOT1YyH6vcr53s3R8KmWeflis+pbzfx0URQqn1TNdyz5T9umByQ0REpIuE0L7lhWNuiIiIiF5/bLkhIiLSRUKGMTcVtOWGyQ0REZEuUioBhZZjZiromBt2SxEREVG5wpYbIiIiXcRuKY0xuSEiItJBQqmE0LJbqqJeCs5uKSIiIipX2HJDRESki9gtpTEmN0RERLpIKQAFkxtNsFuKiIiIyhW23BAREekiIQBoO89NxWy5YXJDRESkg4RSQGjZLSWY3BAREZHOEEpo33LDS8GJiIiIXntsuSEiItJB7JbSHJMbIiIiXcRuKY0xucF/mW22MlOW+pRCnnr+qy9L1voUMr/ZhciRtT75P4wy977KGJ+Q+b0CoS9zffKeW7mnglcIec+tLk9VL/exKpQyf/3L3UKgUMhbn0zx5f6dKI0WkWxkaT2HXzbk/fvxumByAyA1NRUAEBG/sowjKSXZZR1AKdPlVtm0sg6AKiy+97SSmpoKKyurEqnbyMgIjo6OOBG/R5b6HB0dYWRkJEtdrwuFqKgdcnkolUo8fPgQlSpVgkLuXwtaSklJgYuLC+7duwdLS8uyDkdjPA7dUR6OASgfx1EejgGoWMchhEBqaiqcnZ2hp1dy1+Skp6cjM1Oell0jIyOYmJjIUtfrgi03APT09FCtWrWyDqNIlpaWr/WXRi4eh+4oD8cAlI/jKA/HAFSc4yipFpu8TExMKlxCIideCk5ERETlCpMbIiIiKleY3Og4Y2NjTJs2DcbGxmUdilZ4HLqjPBwDUD6OozwcA8DjIN3DAcVERERUrrDlhoiIiMoVJjdERERUrjC5ISIionKFyQ0RERGVK0xuykB4eDjeeOMNVKpUCfb29ujZsyeio6NVyvj7+0OhUKgsI0aMUCkTGxuLrl27wszMDPb29pg0aRKys0vv3grTp0/PF6O7u7u0PT09HaGhoahcuTIsLCzQu3dvJCQk6NQxAICbm1u+41AoFAgNDQWgm+fi2LFj6NatG5ydnaFQKLBjxw6V7UIITJ06FU5OTjA1NUWHDh1w8+ZNlTKPHz9G//79YWlpCWtrawwdOhRpaapz8l++fBmtW7eGiYkJXFxc8NVXX5XacWRlZWHKlCnw9PSEubk5nJ2dERISgocPH6rUUdD5mzNnTqkdx6vOxaBBg/LF17lzZ5Uyun4uABT4GVEoFPj666+lMmV9Lorz3SrX91JERASaNGkCY2Nj1K5dG6tWrZLtOEgGgkpdYGCgWLlypbh69aqIiooSXbp0EdWrVxdpaWlSmbZt24rhw4eLuLg4aUlOTpa2Z2dni4YNG4oOHTqIixcvij179ogqVaqIsLCwUjuOadOmiQYNGqjE+Pfff0vbR4wYIVxcXMShQ4fE+fPnRfPmzUWLFi106hiEECIxMVHlGA4cOCAAiCNHjgghdPNc7NmzR/zvf/8T27ZtEwDE9u3bVbbPmTNHWFlZiR07dohLly6J7t27ixo1aojnz59LZTp37iwaNWokTp8+LY4fPy5q164t+vXrJ21PTk4WDg4Oon///uLq1atiw4YNwtTUVCxdurRUjiMpKUl06NBBbNq0Sfzxxx8iMjJSNGvWTPj4+KjU4erqKmbMmKFyfvJ+lkr6OF51LgYOHCg6d+6sEt/jx49Vyuj6uRBCqMQfFxcnVqxYIRQKhbh165ZUpqzPRXG+W+X4Xvrrr7+EmZmZGD9+vLh+/br47rvvhL6+vti7d68sx0HaY3KjAxITEwUAcfToUWld27ZtxZgxYwrdZ8+ePUJPT0/Ex8dL6xYvXiwsLS1FRkZGSYYrmTZtmmjUqFGB25KSkoShoaHYvHmztO7GjRsCgIiMjBRC6MYxFGTMmDGiVq1aQqlUCiF0/1y8/IdIqVQKR0dH8fXXX0vrkpKShLGxsdiwYYMQQojr168LAOLcuXNSmd9++00oFArx4MEDIYQQ33//vbCxsVE5hilTpoh69eqVynEU5OzZswKAuHv3rrTO1dVVzJ8/v9B9SvM4CktuevToUeg+r+u56NGjh2jfvr3KOl06F0Lk/26V63tp8uTJokGDBirPFRwcLAIDA0vkOEh97JbSAcnJyQAAW1tblfXr1q1DlSpV0LBhQ4SFheHZs2fStsjISHh6esLBwUFaFxgYiJSUFFy7dq10Agdw8+ZNODs7o2bNmujfvz9iY2MBABcuXEBWVhY6dOgglXV3d0f16tURGRmpU8eQV2ZmJtauXYshQ4ao3ET1dTgXuW7fvo34+HiV197Kygq+vr4qr721tTWaNm0qlenQoQP09PRw5swZqUybNm1U7iYcGBiI6OhoPHnypJSORlVycjIUCgWsra1V1s+ZMweVK1eGt7c3vv76a5UuBF04joiICNjb26NevXoYOXIkHj16pBLf63YuEhISsHv3bgwdOjTfNl06Fy9/t8r1vRQZGalSR26Z3Dqo7PHGmWVMqVRi7NixaNmyJRo2bCitf/fdd+Hq6gpnZ2dcvnwZU6ZMQXR0NLZt2wYAiI+PV/nwAZAex8fHl0rsvr6+WLVqFerVq4e4uDh8/vnnaN26Na5evYr4+HgYGRnl+yPk4OAgxacLx/CyHTt2ICkpCYMGDZLWvQ7nIq/c5ywopryvvb29vcp2AwMD2NraqpSpUaNGvjpyt9nY2JRI/IVJT0/HlClT0K9fP5WbGn700Udo0qQJbG1tcerUKYSFhSEuLg7z5s2TYi3L4+jcuTN69eqFGjVq4NatW/jkk08QFBSEyMhI6Ovrv5bnYvXq1ahUqRJ69eqlsl6XzkVB361yfS8VViYlJQXPnz+HqampbMdBmmFyU8ZCQ0Nx9epVnDhxQmX9+++/L/3b09MTTk5OCAgIwK1bt1CrVq3SDrNAQUFB0r+9vLzg6+sLV1dX/Pzzz6/th3v58uUICgqCs7OztO51OBflXVZWFt555x0IIbB48WKVbePHj5f+7eXlBSMjI3zwwQcIDw/XiWn0+/btK/3b09MTXl5eqFWrFiIiIhAQEFCGkWluxYoV6N+/f767VuvSuSjsu5UqBnZLlaHRo0dj165dOHLkCKpVq1ZkWV9fXwBATEwMAMDR0THfCP/cx46OjiUQ7atZW1ujbt26iImJgaOjIzIzM5GUlKRSJiEhQYpP147h7t27OHjwIIYNG1ZkOV0/F7nPWVBMeV/7xMREle3Z2dl4/Pixzp2f3MTm7t27OHDggEqrTUF8fX2RnZ2NO3fuANCd48hVs2ZNVKlSReX987qcCwA4fvw4oqOjX/k5AcruXBT23SrX91JhZSwtLV/bH3blDZObMiCEwOjRo7F9+3YcPnw4XzNtQaKiogAATk5OAAA/Pz9cuXJF5Usx94vfw8OjROJ+lbS0NNy6dQtOTk7w8fGBoaEhDh06JG2Pjo5GbGws/Pz8AOjeMaxcuRL29vbo2rVrkeV0/VzUqFEDjo6OKq99SkoKzpw5o/LaJyUl4cKFC1KZw4cPQ6lUSsmbn58fjh07hqysLKnMgQMHUK9evVLrBslNbG7evImDBw+icuXKr9wnKioKenp6UlePLhxHXvfv38ejR49U3j+vw7nItXz5cvj4+KBRo0avLFva5+JV361yfS/5+fmp1JFbJrcO0gFlPKC5Qho5cqSwsrISERERKpdMPnv2TAghRExMjJgxY4Y4f/68uH37tti5c6eoWbOmaNOmjVRH7uWKnTp1ElFRUWLv3r3Czs6uVC+jnjBhgoiIiBC3b98WJ0+eFB06dBBVqlQRiYmJQogXl1xWr15dHD58WJw/f174+fkJPz8/nTqGXDk5OaJ69epiypQpKut19VykpqaKixcviosXLwoAYt68eeLixYvSVURz5swR1tbWYufOneLy5cuiR48eBV4K7u3tLc6cOSNOnDgh6tSpo3L5cVJSknBwcBDvvfeeuHr1qti4caMwMzOT9fLjoo4jMzNTdO/eXVSrVk1ERUWpfFZyr1o5deqUmD9/voiKihK3bt0Sa9euFXZ2diIkJKTUjqOoY0hNTRUTJ04UkZGR4vbt2+LgwYOiSZMmok6dOiI9PV2qQ9fPRa7k5GRhZmYmFi9enG9/XTgXr/puFUKe76XcS8EnTZokbty4IRYtWsRLwXUMk5syAKDAZeXKlUIIIWJjY0WbNm2Era2tMDY2FrVr1xaTJk1SmVtFCCHu3LkjgoKChKmpqahSpYqYMGGCyMrKKrXjCA4OFk5OTsLIyEhUrVpVBAcHi5iYGGn78+fPxahRo4SNjY0wMzMTb731loiLi9OpY8i1b98+AUBER0errNfVc3HkyJEC30MDBw4UQry4HPyzzz4TDg4OwtjYWAQEBOQ7tkePHol+/foJCwsLYWlpKQYPHixSU1NVyly6dEm0atVKGBsbi6pVq4o5c+aU2nHcvn270M9K7hxEFy5cEL6+vsLKykqYmJiI+vXri9mzZ6skDiV9HEUdw7Nnz0SnTp2EnZ2dMDQ0FK6urmL48OEqlxkLofvnItfSpUuFqampSEpKyre/LpyLV323CiHf99KRI0dE48aNhZGRkahZs6bKc1DZUwghRAk1ChERERGVOo65ISIionKFyQ0RERGVK0xuiIiIqFxhckNERETlCpMbIiIiKleY3BAREVG5wuSGiIiIyhUmN0TFsGrVqnx3EqaC+fv7Y+zYsSVS96NHj2Bvby/dq6i0LFmyBN26dSvV5yQizTG5IQIwaNAgKBQKKBQKGBkZoXbt2pgxYways7NL7Dnv3LkDhUIh3avqVbZu3Qp/f39YWVnBwsICXl5emDFjBh4/flxiMWpi27ZtmDlzpvTYzc0NCxYskKXuWbNmoUePHnBzcwPw32uor6+PBw8eqJSNi4uDgYEBFAqFlAw5OTlhzpw5KuU+/vhjKBQKREREqKz39/fHe++9BwAYMmQIfv/9dxw/flyW4yCiksXkhuhfnTt3RlxcHG7evIkJEyZg+vTp+Prrr8s6LADA//73PwQHB+ONN97Ab7/9hqtXr2Lu3Lm4dOkSfvrpp7IOT4WtrS0qVaoke73Pnj3D8uXLMXTo0HzbqlatijVr1qisW716NapWraqyzt/fP18Sc+TIEbi4uKisT09Px+nTp9G+fXsAgJGREd599118++238hwMEZWssr7/A5EuGDhwoOjRo4fKuo4dO4rmzZsLIYRYuXKlsLKykrbFxMSI7t27C3t7e2Fubi6aNm0qDhw4oLK/q6urmDVrlhg8eLCwsLAQLi4uKjcIxEv3v2nbtm2BsZ05c0YAEAsWLChw+5MnT9SKacaMGaJv377CzMxMODs7i//7v/9TKTN37lzRsGFDYWZmJqpVqyZGjhyZ7z5HJ06cEG3bthWmpqbC2tpadOrUSTx+/FgIIUTbtm3FmDFjpH+/fJxpaWmiUqVKYvPmzSp1bt++XZiZmYmUlJQCj3Pz5s3Czs5OZV3u/ac+/fRTUadOHZVtdevWFZ999pkAIG7fvi2EeHFvJAsLC+k+QSkpKcLQ0FD83//9n8rrf/jwYZX9hBDi6NGjwsjISOUmjESkm9hyQ1QIU1NTZGZmFrgtLS0NXbp0waFDh3Dx4kV07twZ3bp1Q2xsrEq5uXPnomnTprh48SJGjRqFkSNHIjo6GgBw9uxZAMDBgwcRFxeHbdu2Ffhc69atg4WFBUaNGlXg9tyxQMWN6euvv0ajRo1w8eJFfPzxxxgzZgwOHDggbdfT08O3336La9euYfXq1Th8+DAmT54sbY+KikJAQAA8PDwQGRmJEydOoFu3bsjJyckX27Zt21CtWjXMmDEDcXFxiIuLg7m5Ofr27YuVK1eqlF25ciXefvvtQlt9jh8/Dh8fnwK3de/eHU+ePMGJEycAACdOnMCTJ0/yjZNp164d0tLScO7cOanOunXronfv3jhz5gzS09MBvGjNcXNzk7q/AKBp06bIzs7GmTNnCoyBiHRIWWdXRLogb8uNUqkUBw4cEMbGxmLixIlCiPwtNwVp0KCB+O6776THrq6uYsCAAdJjpVIp7O3txeLFi4UQ/7U6XLx4sch6g4KChJeXl/oHVUhMnTt3VikTHBwsgoKCCq1j8+bNonLlytLjfv36iZYtWxZaPm/LTe5zzp8/X6XMmTNnhL6+vnj48KEQQoiEhARhYGAgIiIiCq23R48eYsiQISrr8r6GY8eOFYMHDxZCCDF48GAxbtw4cfHixXwtMFWrVhWzZ88WQggxadIkMWrUKCHEi5aew4cPCyGEaN26tVRXXjY2NmLVqlWFxkhEuoEtN0T/2rVrFywsLGBiYoKgoCAEBwdj+vTpBZZNS0vDxIkTUb9+fVhbW8PCwgI3btzI10ri5eUl/VuhUMDR0RGJiYlqxSWEKFa54sbk5+eX7/GNGzekxwcPHkRAQACqVq2KSpUq4b333sOjR4/w7NkzAP+13GijWbNmaNCgAVavXg0AWLt2LVxdXdGmTZtC93n+/DlMTEwK3T5kyBBs3rwZ8fHx2Lx5M4YMGVJgubzjbiIiIuDv7w8AaNu2LSIiIvD8+XOcOXMG7dq1y7evqamp9DoQke5ickP0r3bt2iEqKgo3b97E8+fPsXr1apibmxdYduLEidi+fTtmz56N48ePIyoqCp6envm6sQwNDVUeKxQKKJVKteKqW7cu/vrrL2RlZRVZrrgxFeXOnTt488034eXlha1bt+LChQtYtGgRAEj1mJqaqhV/YYYNG4ZVq1YBeNElNXjwYCgUikLLV6lSBU+ePCl0u6enJ9zd3dGvXz/Ur18fDRs2LLBcu3btcPLkSTx69AgXL15E27ZtAbxIbo4cOYJTp04hMzNTGkyc1+PHj2FnZ6fGURJRWWByQ/Qvc3Nz1K5dG9WrV4eBgUGRZU+ePIlBgwbhrbfegqenJxwdHdWee8XIyAgAChyrkte7776LtLQ0fP/99wVuT0pKUium06dP53tcv359AMCFCxegVCoxd+5cNG/eHHXr1sXDhw9Vynt5eeHQoUPFOUQAL46zoGMcMGAA7t69i2+//RbXr1/HwIEDi6zH29sb169fL7LMkCFDEBERUWirDfAiuXn69CnmzZuHOnXqwN7eHgDQpk0bnD17Fr/99hvq1KmT70qrW7duIT09Hd7e3kXGQERlj8kNkQbq1KmDbdu2ISoqCpcuXcK7776rdouMvb09TE1NsXfvXiQkJCA5ObnAcr6+vpg8eTImTJiAyZMnIzIyEnfv3sWhQ4fQp08fqWunuDGdPHkSX331Ff78808sWrQImzdvxpgxYwAAtWvXRlZWFr777jv89ddf+Omnn7BkyRKV/cPCwnDu3DmMGjUKly9fxh9//IHFixfjn3/+KTB+Nzc3HDt2DA8ePFApY2Njg169emHSpEno1KkTqlWrVuTrFRgYiGvXrhXZejN8+HD8/fffGDZsWKFlatasierVq+O7776TWm0AwMXFBc7Ozli2bFmBXVLHjx9HzZo1UatWrSLjJKKyx+SGSAPz5s2DjY0NWrRogW7duiEwMBBNmjRRqw4DAwN8++23WLp0KZydndGjR49Cy3755ZdYv349zpw5g8DAQDRo0ADjx4+Hl5eX1OJR3JgmTJiA8+fPw9vbG1988QXmzZuHwMBAAECjRo0wb948fPnll2jYsCHWrVuH8PBwlf3r1q2L/fv349KlS2jWrBn8/Pywc+fOQlu7ZsyYgTt37qBWrVr5unSGDh2KzMzMIltacnl6eqJJkyb4+eefCy1jYGCAKlWqvLLlrV27dkhNTZXG2+Rq27YtUlNTC0xuNmzYgOHDh78yTiIqewpR3NGKRPTac3Nzw9ixY0vs9gjq+umnnzBu3Dg8fPhQ6qYryu7duzFp0iRcvXoVenql99vs2rVraN++Pf78809YWVmV2vMSkWaK/nlDRFQCnj17hri4OMyZMwcffPBBsRIbAOjatStu3ryJBw8ewMXFpYSj/E9cXBzWrFnDxIboNcFuKSIqdV999RXc3d3h6OiIsLAwtfYdO3ZsqSY2ANChQwep646IdB+7pYiIiKhcYcsNERERlStMboiIiKhcYXJDRERE5QqTGyIiIipXmNwQERFRucLkhoiIiMoVJjdERERUrjC5ISIionKFyQ0RERGVK/8PiXB0AEHuAEEAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_cost, shading='auto')\n", - "plt.colorbar(label='$/kW')\n", - "plt.xlabel('Plant Capacity (MW)')\n", - "plt.ylabel('Distance to Shore (km)')\n", - "# plt.title('HVDC is cheaper where green')\n", - "plt.title('Cheaper Transmission Type Cost (HVAC v HVDC)')\n", - "# plt.colorbar.set_ylabel('# of contacts', rotation=270)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "29ae71b4-2fbc-4cea-885b-201c3f2834e6", - "metadata": { - "tags": [] - }, - "source": [ - "# Overall Bar Chart" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "3b7753e2-b221-45d3-b6d0-d299991eac40", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ind = np.arange(0,20)\n", - "index = 3\n", - "width = 0.4\n", - "plt.figure(figsize=(20,8))\n", - "plant_cap = np.arange(100,2100,100)\n", - "\n", - "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", - "\n", - "cable_data_ac = parametric.results.cable_cost[20*index:20*(index+1)]\n", - "# print(len(parametric.results.cable_cost[20*index:20*(index+1)]))\n", - "substation_data_ac = sub_cost[20*index:20*(index+1)]\n", - "plt.bar(ind,cable_data_ac, width, label = 'ac cable', color = 'lightsteelblue', bottom = substation_data_ac)\n", - "plt.bar(ind,substation_data_ac, width, label = 'ac oss', color = 'cornflowerblue')\n", - "\n", - "cable_data_dc = parametric.results.cable_cost[num+20*index:num+20*(index+1)]\n", - "substation_data_dc = sub_cost[num+20*index:num+20*(index+1)]\n", - "plt.bar(ind+width, cable_data_dc, width, label = 'dc cable', color = 'lightcoral', bottom = substation_data_dc)\n", - "plt.bar(ind+width, substation_data_dc, width, label = 'dc oss', color = 'indianred')\n", - "plant_cap_str = np.char.mod('%d',plant_cap)\n", - "# print(plant_cap)\n", - "\n", - "total_cost = sub_cost + parametric.results.cable_cost\n", - "# plt.plot(ind, total_cost[0+20*index:20*(index+1)], color = 'blue', label = 'HVAC')\n", - "# plt.plot(ind, total_cost[num+20*index:num+20*(index+1)], color = 'red', label = 'HVDC')\n", - "\n", - "plt.xticks(ind,plant_cap_str)\n", - "plt.legend(loc = 'upper left')\n", - "plt.ylabel(\"Project Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.rcParams.update({'font.size':10})\n", - "# plt.figure(figsize=(12,5))\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d116c707-edeb-4e92-a5cb-598237daf19d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/oss_component_breakdown.ipynb b/oss_component_breakdown.ipynb deleted file mode 100644 index 1c205c0f..00000000 --- a/oss_component_breakdown.ipynb +++ /dev/null @@ -1,450 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "9ca44daf-9e05-4ff7-bf05-a864acd2623e", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager\n", - "from ORBIT.phases.design import OffshoreSubstationDesign\n", - "from ORBIT.phases.design import ElectricalDesign\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "id": "db5af5db-e245-4989-a8c8-f2f76f8f01a3", - "metadata": {}, - "source": [ - "## Cost Curves \n", - "#### Vary Plant Capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f7857dd1-e6c7-4f31-bc77-a837d97c2462", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - } - ], - "source": [ - "cap = np.arange(100,2010,10)\n", - "i = 0\n", - "mpt_cost1 = [0] * len(cap)\n", - "shunt_list1 = [0] * len(cap)\n", - "switch_list1 = [0] * len(cap)\n", - "topside_list1 = [0] * len(cap)\n", - "capex_list1 = [None] * len(cap)\n", - "for x in cap:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ExportSystemDesign',\n", - " 'OffshoreSubstationDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = OffshoreSubstationDesign(config)\n", - " design.run()\n", - " mpt_cost1[i] = design.mpt_cost\n", - "# print(x, \":\", design.num_cables)\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - "# print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - " shunt_list1[i] = design.shunt_reactor_cost\n", - " switch_list1[i] = design.switchgear_costs\n", - " topside_list1[i] = design.topside_cost\n", - " \n", - "\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list1[i] = project.capex_breakdown\n", - " i = i + 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7347c506-7f27-4738-a133-b42f17fd4e67", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" - ] - } - ], - "source": [ - "cap = np.arange(100,2010,10)\n", - "i = 0\n", - "mpt_cost2 = [0] * len(cap)\n", - "shunt_list2 = [0] * len(cap)\n", - "switch_list2 = [0] * len(cap)\n", - "topside_list2 = [0] * len(cap)\n", - "capex_list2 = [None] * len(cap)\n", - "for x in cap:\n", - " config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 50},\n", - " 'plant': {'num_turbines': (x/10), 'capacity': x},\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_500mm_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }\n", - " design = ElectricalDesign(config)\n", - " design.run()\n", - " mpt_cost2[i] = design.mpt_cost\n", - "# print(x, \":\", design.num_cables)\n", - "# print(\"shunt reactor costs = \", design.shunt_reactor_cost)\n", - "# print(\"switchgear costs = \", design.switchgear_costs)\n", - "# print(\"topside costs = \", design.topside_cost)\n", - "# print(\"ancillary system costs = \", design.ancillary_system_cost)\n", - "# print(\"land assembly costs = \", design.land_assembly_cost)\n", - " shunt_list2[i] = design.shunt_reactor_cost\n", - " switch_list2[i] = design.switchgear_costs\n", - " topside_list2[i] = design.topside_cost\n", - " \n", - "\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " capex_list2[i] = project.capex_breakdown\n", - " i = i + 1" - ] - }, - { - "cell_type": "markdown", - "id": "093653d4-e392-46a3-aa34-ce522c2d7ae0", - "metadata": { - "tags": [] - }, - "source": [ - "### Plot Costs by Plant Capacity\n", - "#### Shunt Reactor\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1d6cf66a-ead9-4036-9612-380fcef1ab9e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, shunt_list1)\n", - "plt.plot(cap, shunt_list2)\n", - "plt.title(\"Shunt Reactor\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a0ea568e-2f52-4ed7-bc06-c4157c5e2453", - "metadata": { - "tags": [] - }, - "source": [ - "#### Switchgear" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "26ecc47f-420c-4315-9ce6-4b1ccca9608a", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, switch_list1)\n", - "plt.plot(cap, switch_list2)\n", - "plt.title(\"Switchgear\")\n", - "plt.xlabel(\"DIstance to Shore (mi)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a6cf5e54-2238-4988-9c88-0708ae5353a8", - "metadata": { - "tags": [] - }, - "source": [ - "#### Topside" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d2cf82d5-58f3-4999-826a-116759a4d9f6", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, topside_list1)\n", - "plt.plot(cap, topside_list2)\n", - "plt.title(\"Topside\")\n", - "plt.xlabel(\"Distance to Shore (mi)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"old\",\"new\"], loc = \"lower right\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ee87907e-7ddc-4159-8b7c-cba42890425f", - "metadata": { - "tags": [] - }, - "source": [ - "#### MPT" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0d3137c6-02f6-4220-bea8-208f56bd7a25", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(cap, mpt_cost1)\n", - "plt.plot(cap, mpt_cost2)\n", - "plt.title(\"MPT\")\n", - "plt.xlabel(\"DIstance to Shore (mi)\")\n", - "plt.ylabel(\"Cost (USD)\")\n", - "plt.legend([\"cable cost\",\"oss cost\"], loc = \"lower right\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/osw_project_details.xlsx b/osw_project_details.xlsx deleted file mode 100644 index 266227052b890fddfb21c984b61c8c240a0bee52..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10551 zcmeHtg;yNe_I2X~cM0wejXMN)4<6jzouC1Ny9bvfI0ScTJP_R7o!}0?o_X`WnaRBG zFL+G}7J@+WfK|x~yU;*#|0Duf&e3E6U4*>wgK?4Ao0C-4UF$a5B zGkaHqw_c8BE_%$KcDAJX(2%sb07&rl|2zJRXP_);Sg{9)CUGPED7M8UyHxWAp7S`U zAA?>+s1uafS7M@@ZDsY69sYnOnul%8U5)W$$%pN1#InZTu0H5vUyCYIWZ*!jx;_Cn zOK<-XRR=D9g0qhHX)YGQ8&-S+gJ|w2$eDp6inPi|N$$ge^-1Uo;$+Xnyj8&VQ?^EU4 zU1%HGrwvUYSAd~$Z79p5tFSHY+{6kTuWP`F$Yk#iLAvbXS4tD9wdxiAV2)Gn{@esY8{ghv`S#woE;lys)$E!$GBG1 zpDnJ$%S|8T_jzEjk*8DX*o4s6zIYsN3tHm#1?w7pzxkq56m77RjPiZh@!G&Xzt7Rw zwr=prS<1dY+cPWx@bUr$Q2rY&>(qf1mtbF$2eS?lOiKf2Gg}uH=HJHu(eb~SgMWGS zvIGUC9w1Wasq|ymz|Hh>9Ga+{hlq3w*;~H=nI+V^=mJWD=&7AkB%R9ELFn$&SJT(&QnFsO?rpL3rHxWiYrcMkSwt9$BbXkj)2E=lVtiWxF)gZgTpn80z@2-L_#@MQHl=tU zS@axVi@+s+H|%nr;aUna#*1FGa4 z7`JRcr246Hul#jtInIW&yg=NqdP)a=4hBV%d|3f2)IUk`HP5it3JL%)1WOqzcxF6p zSv(w^ZHyfpY<|qIk-w|PcjJ_oCE0Gtia1a zzaSz}A=|DUN7NXxbE3iQrqT86WF+B1`X!SP2Sex=uGbJY_?47ZUOD23*Gumnj$FHJ z+_|-8^Gl~S7xv_*>(wU}733Yc)NARHAN9-`RZ#u24!cMNuJwfSj=QMFMhOS>F_127}*eHQHLRyYDXmNSu%(cR_{z(Bc0+T)f=(3?P$(c zYULSFCiJE|uO`U97^9$db&3)cZ541wrr0H-a`A)YoYXBpdn^}Hdqp_a%$;eg%Qk)* zhfBpOvm~f7)(nU}9EFa7cbDP|vYRsdERTA<@h0~6R-l`LWc@2HsW5R9?X@7T*)u2$ zcHEUs0V<2+{WHx=Kb_^f>?0w@3^R$M3>h89br;tj9J=F9-{G3F> zJJSy;8KFW5)J?eJrU?pACdGkeDIK?4_*ncqR+8$dS6}5OqcE3u7U!R~jML_J_Qj5= zxG~#K7eD)Bdmt_f-6XR}?fK^aA6XeF zl$3e_W@9s0x?Tg|A;7HsmwNq`oBvia2ykKvw({S7l&LDnfq-ajh|gg_k4$%L^m$hn z@+0*_RQSPKxtr5R~ho#4eC>bu8O+pC+jM-Q`JGZn{_+bUbi26QLZ|qd+${ zYnL&iA#fxguH6c_|DbkM9#q@VK$<~kzWvf9ws;Mj6XZoQeu4i=MgZ9hFupfM#&Fvu zaSeao`e?4;HEPpUaF4W2SSm+c!YSw*>Pi|mAVuO&m*BFUpWdQ=y6!6aFhtj}c+NO{ zd1}5j*gw4re$)R9U`ddW*lsFhu07MHt zr5NGYYKLM)tD!BNmf<@{*#Tx;9i@?12eF#)%h^nw3YiT|s4}Og00@i! zuYofus&EVS>59WR^wj$)I~zBtS#@c2e>b_6J2GPrAQTa`b7^*} zz?X{0CQx1qZ4P|>lC(g3@^iY3Vi9jmf}pU3_T;KY+DUsd2FP^-bk&xHKxA@9u$~n` zdb?!w>`p=8Q%vWCs_67>nKN*#Lvt3^ZV7 zUl}C-?7!LHrRGo_73|3+9h8JTVF*&iiAssQV?6nWuPe|tzF!#E*t3Gos=RXF6-N0QM+^ zrid_^RhN(ov>>JYLg9cpkH@(fIPFFS#Z9BMYfKypQ<0{*&)F^hZZmKU2D)?X9whR8|y?|`Ss*4zdO+HLz4Ef{UQ*_ zH<=u@N~pcONOt`9#$tWj_)63 z>o?@ID`UbAt3b0x(dd#f1lqzey+%(?0%es!mW1k{@7= zvj;f?o#-IWkA>q#YKJn;`KVG;#s{ASBJZ=D+E{y{NxmICxg%PcgaxB1*;W8WY*zry zCN8h`^x@w2Kgr^y$l+ml4$-4o4aKil1Q6NG+r!s11-ZE6)WZ4nUt{Pm90nZR?tCz+ z`#=^*6UyHRl??nar&G@_aAI50>5JnUh%|41tqithff0Iz5el7+cM`a+j4l*2nkubA z=qWpI%cU}gf-zV99@V2@7G0gS@WY1rD+x#?tg|)F%^0|CUDD99nX{*@nODZD%^PqRQ;|wy;1cs!Z9BMdmR*xZ ze;AKZI)JTIVL%c1YRg5VK8B6+wwmHbzyGa;cc0%Y8Az#wG1W{#l4+t9$!aklv(mhQ z9l;a=ksj=0Hvx55YPe}^IXsj-Y4j2!v6Z~7q++{|JtB&V#@rmeF--^Ee3I0ARR?pt zYQ>}#=5Mj`DAX+bqFpE^hdyaJX%(+SV9D4v$j`^jwtT)a(Q;b~NZKba+N`Z{96KX8 zkFf)}#;*apm8Vc5Ai8Fi`B@;fVn^k<)E%bzST~eD8*dj_hArzm8=&^*XHZdPH zzVTrcUx$#^&H)u6yl?&*Sr|L13gzP=rauF#b-TFMmB8RWoUD1y-=mI&Ia5ekMPG2f zM2^mpyIG%)M1DF@=dR^NgX*_nnl$#I|C|BEVMvuc)H&5H{9xld$a)D775Eef*i4kA6Rr49i6YuGMG~`sVE^h}F{PPS&Nfdt~?aKt@dm zoh9EJ(kAaMvrBO(RyZ``fr@TtD$VtmDNg-)wmBgCCWIAdv)}Da&@XE;CGIp?>uo65 zn6YjmOjVU561P_3S97c@*d>G*!%6Q#>tKx3oay*@+U9I+%SQHEI0NvjGZFEBeu3w6 zGBi6$Y#jQYnl_tZnO%ZI;;H&t$0qk+1RpzWKgYP?t;EAxXCb0PXIEFJu{FTD$yKwC zHsf=NL_9YXX*yt9a^ztNo>lmT(LI=kyNun0Vp>&^a zqk6OAJC9|z$qUx+_r00#YEZ|Vv0LJXj?>i_$y~xTyVi9`&jvSbuQm9+9TcDW>{;%+ zGjAEVu5ve~(=$3h9>{alXZAsTF}| znyR!z@;?Hq<<1d1^NVE>WbUY_?wWx5lGetu*61HC$_nFBatt6h_ZH{(Qg?C9a4iap zQ|5lltp2ICUASoNir_!&BmJ%9_q*D*|kGG}ze^S_v>Asd%qcX$y-|MI8i_Cf-0Hw_V1*qO9E~8K)VU zqbT2|%(Ru&aYv4ndT#st`6k=X`@;2XqAkr^Dh;taA;q9w`CRZ*)La_nWQxBH4=snU zl5|oOy4frHJ4D7uxy2kmXLP$k`2IPlJ8|2*6cQQUMS7fG_|W*qPII2XRqCjI>28V~ zoPI*0;FUBSh9cE+Jc@){{UBpypZ9EJ6i3L(vi?3_Tb0&X<3*99Xje5$s;Tm-H+yPC zKZfk7o)D2OoEv4c@)K|POx)07VE9?yQ9bSAHn8A~Yfy`C!)lA!=f1Et$s77=jk}!h zcUe!6!Uya46d6E$dDnk+_@vWOKk*sDk|QX&xPFfBFxfuN2wC}lIaMu?%#3X626cl^ZT?l*MJ78$+2x z>a0DQ7O+jb_hK+tkb*_p66k)Y#37d+sjA6qk#leBM4hk+0RkXZDP=YWdy$mJ;A5ygBZ!3iYpNlCX>Va&9$$Ez2S_G=sp2na-`T9qO+-Yu7 zmTW2G z!>JuFXM9&x8%x+M?eEXe_Y-kf-(T%2#S$$n5)!5TBnz+pS+Q<%N*!qwi1Kg-A)EyQ zih>f}pzpbVIT;>+)Ym0F=yt0*?p`F+>Vs(&=&+e@COK=Oj7hJQtcF=KiE_vD;9D!n z82!T`vR8ihaUtCa(P`QS6so_<9_meq! zBg~d{MiR}(d$UoZ>ei_AHWFOdpsGl-1%djxx{+{pe!h#Z$qOxbYOYazcs>n6E?Q$o z?8CcFQ|o(Am zjqhuXPkP;OJ%XlU6C_|13Xgzm~FLe5@uCGL_(_4K5hp11__rUAt>TPziq?2Ko-WE}h_t355QE}DP1X>j zf(Ok_bM)SNJB*97}>ZF*}|1;S{$q<13w z*K`PFV-|MOSXZ_AW+yLeH>;91i9#ldDA#Y%zzJXw?m8p?NXmnDUvqlc6q{0$aT9?v z`$04+x{U-mO=BQ6wb~en-~O)78oq&^g2Uzxa}Td)))TggVoDb`U#-y{UnblB*25?T zAGanm zGM-AdB1z!7T7~0tN$)CA8Ra}-cNZ zr>b`cZuF>YhVd%zP$m!WA>J8{Nw`~8_Rlh(Y;H4+grG-8${T#gty{m}Xn!~F>vW1v zn)OgOl&fv$ZXIG?CrAt3rdR;34e^EOm+PJ)doNdw6AJunqd-Pkn6_6w2e~LQIrS#c4sQ%;uGDxqTv-oE+bRqB;YOt$ zbh2Qlcb_1g%=_onV7i(|&Z z4|=$^cINGv&@$#9Dzz9gv~9E zx(@=aj!tVu?uu5;2O7bnA>qq?3^6=hWb88K5SHd^{5TZ0SuINR+BPQzo<(c(N^EhU zpY2E>Cx^Ai4Rr95Zh?(gt*zh9h5Hn2E2L}R9qr6aoVYSpsC9Zb-N8(z$tw|=FRLkp zgijaOiirgz9}3{?H-X{xvb$p}Vktgq7*0BP@CM(OSDp#fyH7Rnp*WMpc`5j*UNyY3 z7SX@LSU}}t>N7{pnn3I|RkX?I_vEsptyk2)9_I~CGE2JPkGwADIctDX!IdT!r~l4G z+6`TGekCWZ(O}ElKtRxgSKdq9r8pWS;pWu+f=Nem+a`{1^kgGGlt5zFyQpLDQ7Tz) zW_SJV^G-FpKdW1h%Zib~^V84}fFV8wub=h3KlwMEEZMBz`*o#XP0! z#2D(#xBUZZ`5yF}pWnxio7z|Xpc(HRtm7twUu!f=h<~ z%vWc>Nh*bde*uCCgY^etERCGaOx0YSt?Vs+=gkK&Zx-I5y|0||*SgD-Eu>T=zskq? z*!cz{IR*anI_v8r2#2$i<`$DLFYP8l^aq^#1S{+}F6Mhnj~Y#Lxo#7C_Kt2&`0!KV zGDZ4s!6dPp7fOMS(0n0FmPfGI&1=Os*9!f-7)Pag+yfsYei-c~AYnHms^yxST9rX= zD77Hy8KJADk|hlF91aho=0SdiiceEjkoMKqf&|2G9mn=G2O3x5B8| zk+!`_Xd_{^$^xkG7cFM?DyQ3L4TbTNE$2xDm1bv{2`S+^I2taB4=F6rHSe_7EJXSQvY7Eo8!nIdMwgb}`3uE-$O>J=|>=}7{SbI7j@b4St4 zsXI3Dd0`9DCJMLY2h=wV&>#-)4u8y@1hBx>o7$Z}HSk;#pusL2xpX=t+DjDnV-?R?-GJrv=hVggsm=S!AE4mxni|Bl80W(Jr@!q# z{nK?3=5Znvz$)Mdc3*UGE!@<>MA_NF(S^mt!P)GO-irT~z`;`&m0+OM4aDkQRd_^^ z%UNy~Rko~;&s~?nz%=J*=RAhNnGv=s4R&y7=mM<;#~$dFgh9M@nYiE)oa-t?)55s;nqVeDe>66j$9azUYI#RZ{CUsxTYkn)7SrldUu z%D_LLc~?z5@s82qDr(;qyvkB^Vwn%R*;o^5v<7l1BywyrOAaXgd^qr0R*zfwkB#`JKakZ7M z8Y_LVO4}IN1+L=8q8qLn32?H-Nm0TJXdOF?V^1Lh5_fR%^1}g{-}gSeL;Ddx-lIuU zbo(D$35;Z3p@oBe5FMOzp#9YcjT{~S=YnA0`{VeOAmRW{y+Tf*?n#iA33!*4kpjz% zr8O_Bj35%~Efk7P@@gnQmc<{<#@3Hd&3hk2Z~1uMi_0t%@)=yljrS^tZ|7sdKoi*D zUMG9bE$jJV!z8?_J7axA6%()_Y2d4xNr-9c8~`H)T_!GZL!X^kct91SX$GX;z$b5IhDGPMOzF~S0X_!FCe=8>Et1gR5sm^)cP&-Hs${F zH(q1gFSmYGYssG?BlhbJ4QdJsn3F#>SldL0al#$;c|udI!X6NRud0o9!mm59nhq{X zLv;1`wA0MLwL^pbBzsBCkNL40c5y1IPDxr@xc4!N36Pgyn-*%qdoyZtBf%mCg}d8F zW(aAtPUy5d0QGFmMLo$68sgghna!1h39x|~rJc0Ya50Tg)NyzIF;_g3*^zSFZ{r&@ik zc}Dzq2!()T0xSK0Zc+R9>-zWkKQyc<%l+NJ->e2LSZR0Dym}>aXy> ihrqwWHz@uB|05tO%fW!(E&zZ4{se%9JCFLeZ~q58h^zhp diff --git a/param_model.ipynb b/param_model.ipynb deleted file mode 100644 index c68466b3..00000000 --- a/param_model.ipynb +++ /dev/null @@ -1,1001 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "85c306d1-3bb1-46ac-a752-0aa5ccc7b48f", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" - ] - }, - { - "cell_type": "markdown", - "id": "179873b1-f957-4c87-b46b-ef5fc7723a4a", - "metadata": {}, - "source": [ - "# Cable Cost" - ] - }, - { - "cell_type": "markdown", - "id": "a420ca9c-7f7f-40a3-a456-c7f0bceb8e2c", - "metadata": { - "tags": [] - }, - "source": [ - "## Distance to Shore" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d088b5f9-6c52-4513-9915-4deb32b59d5f", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 60\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10,\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': 'XLPE_500mm_220kV',\n", - " }\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7c32e7c8-bb3b-4c7b-b7fb-e0e34e1d3005", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(50,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(300,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "834f7c24-26ee-4121-9acf-0ce49edba906", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "6e244129-a23c-455b-a754-2ba4133b618f", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n" - ] - }, - { - "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", - "
site.distance_to_landfallplant.capacitycable_costoss_cost
0503007.051660e+076.281680e+07
1504007.051660e+076.951580e+07
2505001.057749e+089.003345e+07
3506001.057749e+089.673245e+07
4507001.057749e+081.034314e+08
...............
31930516001.433833e+096.780425e+08
32030517001.433833e+097.009405e+08
32130518001.638666e+097.856789e+08
32230519001.638666e+097.901449e+08
32330520001.843500e+098.782329e+08
\n", - "

324 rows × 4 columns

\n", - "
" - ], - "text/plain": [ - " site.distance_to_landfall plant.capacity cable_cost oss_cost\n", - "0 50 300 7.051660e+07 6.281680e+07\n", - "1 50 400 7.051660e+07 6.951580e+07\n", - "2 50 500 1.057749e+08 9.003345e+07\n", - "3 50 600 1.057749e+08 9.673245e+07\n", - "4 50 700 1.057749e+08 1.034314e+08\n", - ".. ... ... ... ...\n", - "319 305 1600 1.433833e+09 6.780425e+08\n", - "320 305 1700 1.433833e+09 7.009405e+08\n", - "321 305 1800 1.638666e+09 7.856789e+08\n", - "322 305 1900 1.638666e+09 7.901449e+08\n", - "323 305 2000 1.843500e+09 8.782329e+08\n", - "\n", - "[324 rows x 4 columns]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric.run()\n", - "parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "7244d57c-7cc4-4c77-9572-bfdf89c62eb8", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "FutureWarning: C:\\Users\\sbredenk\\.conda\\envs\\orbit-sophie\\lib\\site-packages\\statsmodels\\tsa\\tsatools.py:142\n", - "In a future version of pandas all arguments of concat except for the argument 'objs' will be keyword-only" - ] - }, - { - "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", - "
OLS Regression Results
Dep. Variable: cable_cost R-squared: 0.913
Model: OLS Adj. R-squared: 0.912
Method: Least Squares F-statistic: 1680.
Date: Fri, 29 Oct 2021 Prob (F-statistic): 8.77e-171
Time: 14:39:52 Log-Likelihood: -6469.5
No. Observations: 324 AIC: 1.294e+04
Df Residuals: 321 BIC: 1.296e+04
Df Model: 2
Covariance Type: nonrobust
\n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "
coef std err t P>|t| [0.025 0.975]
const -5.423e+08 2.11e+07 -25.642 0.000 -5.84e+08 -5.01e+08
plant.capacity 4.807e+05 1.22e+04 39.314 0.000 4.57e+05 5.05e+05
site.distance_to_landfall 3.473e+06 8.15e+04 42.605 0.000 3.31e+06 3.63e+06
\n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "\n", - " \n", - "\n", - "
Omnibus: 2.305 Durbin-Watson: 0.813
Prob(Omnibus): 0.316 Jarque-Bera (JB): 2.033
Skew: 0.142 Prob(JB): 0.362
Kurtosis: 3.265 Cond. No. 4.24e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 4.24e+03. This might indicate that there are
strong multicollinearity or other numerical problems." - ], - "text/plain": [ - "\n", - "\"\"\"\n", - " OLS Regression Results \n", - "==============================================================================\n", - "Dep. Variable: cable_cost R-squared: 0.913\n", - "Model: OLS Adj. R-squared: 0.912\n", - "Method: Least Squares F-statistic: 1680.\n", - "Date: Fri, 29 Oct 2021 Prob (F-statistic): 8.77e-171\n", - "Time: 14:39:52 Log-Likelihood: -6469.5\n", - "No. Observations: 324 AIC: 1.294e+04\n", - "Df Residuals: 321 BIC: 1.296e+04\n", - "Df Model: 2 \n", - "Covariance Type: nonrobust \n", - "=============================================================================================\n", - " coef std err t P>|t| [0.025 0.975]\n", - "---------------------------------------------------------------------------------------------\n", - "const -5.423e+08 2.11e+07 -25.642 0.000 -5.84e+08 -5.01e+08\n", - "plant.capacity 4.807e+05 1.22e+04 39.314 0.000 4.57e+05 5.05e+05\n", - "site.distance_to_landfall 3.473e+06 8.15e+04 42.605 0.000 3.31e+06 3.63e+06\n", - "==============================================================================\n", - "Omnibus: 2.305 Durbin-Watson: 0.813\n", - "Prob(Omnibus): 0.316 Jarque-Bera (JB): 2.033\n", - "Skew: 0.142 Prob(JB): 0.362\n", - "Kurtosis: 3.265 Cond. No. 4.24e+03\n", - "==============================================================================\n", - "\n", - "Notes:\n", - "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", - "[2] The condition number is large, 4.24e+03. This might indicate that there are\n", - "strong multicollinearity or other numerical problems.\n", - "\"\"\"" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model = parametric.create_model([\"plant.capacity\",\"site.distance_to_landfall\"],'cable_cost')\n", - "model.sm.summary()\n", - "# model.predict(parameters)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e4b7c985-4e62-4717-86d1-bfd37d158dd7", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 4.182942\n", - "1 3.501289\n", - "2 2.213090\n", - "3 1.758655\n", - "4 1.304219\n", - " ... \n", - "319 0.103110\n", - "320 0.069586\n", - "321 0.156554\n", - "322 0.127221\n", - "323 0.198122\n", - "Name: cable_cost, Length: 324, dtype: float64" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.perc_diff" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "18672b9d-0854-4e44-8753-43a768775ca0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.hist(model.perc_diff,bins = 100)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "e7830989-75d8-4641-9a9c-42d436540be1", - "metadata": {}, - "outputs": [], - "source": [ - "# dist = np.arange(50,315,15)\n", - "# cap = np.arange(300,2100,100)\n", - "# cablecost = np.zeros(len(dist))\n", - "# # print(len(cap))\n", - "# for i in np.arange(0,len(dist)):\n", - "# cablecost[i] = parametric.results.cable_cost[19*i]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3085fb7f-e958-4294-9cab-fb27d6e81a72", - "metadata": {}, - "outputs": [], - "source": [ - "# print(cablecost)\n", - "\n", - "# ax = plt.axes(projection = '3d')\n", - "# ax.plot3D(dist,cap,model.predict(parameters))\n", - "# ax.plot3D(dist,cap,cablecost)\n", - "# plt.legend([\"predict\",\"orbit\"])\n", - "# plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "f3d24be3-426f-47ec-ae71-fcf846d4d5f6", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# dist = np.arange(50,315,15)\n", - "cap = np.arange(300,2100,100)\n", - "\n", - "plt.plot(cap,parametric.results.cable_cost[0:18])\n", - "plt.plot(cap,model.predict(parameters)[0:18])\n", - "plt.legend([\"orbit\",\"predict\"])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "f52c8961-6f5a-434e-889b-2db674676991", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "18" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(model.predict(parameters))" - ] - }, - { - "cell_type": "markdown", - "id": "c816316c-280c-4074-b655-92e6376c63eb", - "metadata": { - "tags": [] - }, - "source": [ - "## Plant Capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "9a698314-0788-467d-88ac-fc8c9f89de77", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config1 = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 60\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10,\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': 'XLPE_500mm_220kV',\n", - " }\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "6f86ae09-caa4-4816-92d3-fa565adb12e7", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "4142db72-839f-4ec3-9a9b-645d16ed61ef", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "28f880f4-d092-4441-8712-2277a495401c", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "parametric1 = ParametricManager(base_config1, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric1.run()\n", - "# parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "eb10e3d3-32fa-4fd1-9536-4cbb5ce98d10", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "FutureWarning: C:\\Users\\sbredenk\\.conda\\envs\\orbit-sophie\\lib\\site-packages\\statsmodels\\tsa\\tsatools.py:142\n", - "In a future version of pandas all arguments of concat except for the argument 'objs' will be keyword-only" - ] - } - ], - "source": [ - "model1 = parametric1.create_model([\"plant.capacity\"],'cable_cost')" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "cac13d3e-7082-4f91-b967-9e149123bc76", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 -7.398858\n", - "1 -11.015592\n", - "2 -6.816162\n", - "3 -8.624529\n", - "4 -6.621931\n", - " ... \n", - "395 0.467762\n", - "396 0.437037\n", - "397 0.480522\n", - "398 0.453637\n", - "399 0.490446\n", - "Name: cable_cost, Length: 400, dtype: float64" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model1.perc_diff" - ] - }, - { - "cell_type": "markdown", - "id": "2a476432-58aa-430f-8e99-fb044d375575", - "metadata": {}, - "source": [ - "# OSS Cost" - ] - }, - { - "cell_type": "markdown", - "id": "d4d4ae03-d237-40f3-a6f3-2d2073fa8f79", - "metadata": {}, - "source": [ - "## Distance to Shore" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "3b6340b5-f891-4139-ad9f-531d474895cd", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 60\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10,\n", - "# 'num_turbines': 50, \n", - " 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': 'XLPE_500mm_220kV',\n", - " }\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "d60ec7bb-5bc4-48eb-8595-af5253bbe826", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - "# 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "c78c3ba5-705c-41ab-a7c0-e207aeb62e8f", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - " 'num_substations': lambda run: run.num_substations\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "7d2b40ac-6aef-4f69-8fb9-99b39339347e", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric.run()\n", - "# parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "ee606b9c-4766-49ad-883f-5cceb9d06bbc", - "metadata": {}, - "outputs": [], - "source": [ - "model = parametric.create_model([\"site.distance_to_landfall\"],'oss_cost')" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "8f70f822-3a2c-4d45-965f-1e9673ebf2fa", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 8.172125e-16\n", - "1 5.956174e-16\n", - "2 8.634491e-16\n", - "3 7.639807e-16\n", - "4 5.480498e-16\n", - "5 4.967373e-16\n", - "6 5.677634e-16\n", - "7 6.275873e-16\n", - "8 5.817131e-16\n", - "9 3.613924e-16\n", - "10 5.075180e-16\n", - "11 4.770924e-16\n", - "12 4.501086e-16\n", - "13 5.680182e-16\n", - "14 5.391564e-16\n", - "15 3.848143e-16\n", - "16 4.894202e-16\n", - "17 4.678414e-16\n", - "18 3.360638e-16\n", - "19 2.149649e-16\n", - "Name: oss_cost, dtype: float64" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.perc_diff" - ] - }, - { - "cell_type": "markdown", - "id": "044ac8ba-1370-43cf-9d76-7626bdf4023e", - "metadata": {}, - "source": [ - "## Plant Capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "cb09d47b-fd37-4fc1-aee7-de88472147d8", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config1 = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - " 'distance_to_landfall': 60\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10,\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': 'XLPE_500mm_220kV',\n", - " }\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "64d77593-7243-4d62-a4e8-5a600e42004e", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - "# 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - "# 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,900,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "04b06ada-3ca9-43ad-87a4-c7b259abecb6", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "d415d492-3a39-44ee-a6d6-9eec06560e8e", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "parametric1 = ParametricManager(base_config1, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric1.run()\n", - "# parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "b53acae3-0f91-4dda-aae0-bbd89fe8608d", - "metadata": {}, - "outputs": [], - "source": [ - "model1 = parametric1.create_model([\"plant.capacity\"],'oss_cost')" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "7783b713-e5ea-4f14-8d87-0d9b912a49c6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3.67371173e+07, 5.02341251e+07, 6.37311329e+07, 7.72281408e+07,\n", - " 9.07251486e+07, 1.04222156e+08, 1.17719164e+08, 1.31216172e+08])" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model1.predict(parameters)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "8e32cf5b-f494-4b16-8ec1-7b612d1a8d06", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 0.035688\n", - "1 -0.121405\n", - "2 0.060151\n", - "3 -0.036495\n", - "4 0.069707\n", - "5 0.000000\n", - "6 -0.061287\n", - "7 0.020302\n", - "Name: oss_cost, dtype: float64" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model1.perc_diff" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "30495cfc-cd76-4def-bed4-7a18010737c1", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "ename": "ValueError", - "evalue": "Missing input(s) '['site.distance_to_landfall']'", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparametric1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mresults\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0moss_cost\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparameters\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;32m~\\ORBIT\\ORBIT\\parametric.py\u001b[0m in \u001b[0;36mpredict\u001b[1;34m(self, inputs)\u001b[0m\n\u001b[0;32m 275\u001b[0m \u001b[0mmissing\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 276\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmissing\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 277\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Missing input(s) '{missing}'\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 278\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 279\u001b[0m \u001b[0minputs\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mk\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mv\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0minputs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", - "\u001b[1;31mValueError\u001b[0m: Missing input(s) '['site.distance_to_landfall']'" - ] - } - ], - "source": [ - "plt.plot(model1.predict(parameters))\n", - "plt.plot(parametric1.results.oss_cost)\n", - "plt.show()\n", - "print(model.predict(parameters))" - ] - }, - { - "cell_type": "markdown", - "id": "49143465-3b7a-439a-a842-73c0475670d8", - "metadata": {}, - "source": [ - "# Both (2 independent variables)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "543f7edf-88c6-42f6-909d-dac55d08cfad", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml b/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml deleted file mode 100644 index 0034c121..00000000 --- a/shared_transmission_configs/Atlantic Shores Offshore Wind 1 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1510 -site: - depth: 43 - distance: 150 - distance_to_landfall: 25.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml b/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml deleted file mode 100644 index eb61ed57..00000000 --- a/shared_transmission_configs/Atlantic Shores Offshore Wind 2 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1500 -site: - depth: 43 - distance: 150 - distance_to_landfall: 25.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Bay State Wind base.yaml b/shared_transmission_configs/Bay State Wind base.yaml deleted file mode 100644 index 402517b4..00000000 --- a/shared_transmission_configs/Bay State Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 2277 -site: - depth: 43 - distance: 65 - distance_to_landfall: 33.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Beacon Wind base.yaml b/shared_transmission_configs/Beacon Wind base.yaml deleted file mode 100644 index 08695b0e..00000000 --- a/shared_transmission_configs/Beacon Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1230 -site: - depth: 43 - distance: 118 - distance_to_landfall: 96.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/CVOW Commercial base.yaml b/shared_transmission_configs/CVOW Commercial base.yaml deleted file mode 100644 index 404a9a53..00000000 --- a/shared_transmission_configs/CVOW Commercial base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 2580 -site: - depth: 43 - distance: 100 - distance_to_landfall: 43.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Empire Wind 2 base.yaml b/shared_transmission_configs/Empire Wind 2 base.yaml deleted file mode 100644 index aec4d305..00000000 --- a/shared_transmission_configs/Empire Wind 2 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1260 -site: - depth: 43 - distance: 285 - distance_to_landfall: 48.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Empire Wind base.yaml b/shared_transmission_configs/Empire Wind base.yaml deleted file mode 100644 index 5dc55135..00000000 --- a/shared_transmission_configs/Empire Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 816 -site: - depth: 43 - distance: 295 - distance_to_landfall: 32.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/Garden State Offshore Energy base.yaml b/shared_transmission_configs/Garden State Offshore Energy base.yaml deleted file mode 100644 index 72c2b43c..00000000 --- a/shared_transmission_configs/Garden State Offshore Energy base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1050 -site: - depth: 43 - distance: 105 - distance_to_landfall: 17.0 -turbine: - turbine_rating: 10 diff --git a/shared_transmission_configs/Hudson North WEA base.yaml b/shared_transmission_configs/Hudson North WEA base.yaml deleted file mode 100644 index adee2bc1..00000000 --- a/shared_transmission_configs/Hudson North WEA base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1059 -site: - depth: 43 - distance: 315 - distance_to_landfall: .nan -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Hudson South WEA base.yaml b/shared_transmission_configs/Hudson South WEA base.yaml deleted file mode 100644 index 056a7ec6..00000000 --- a/shared_transmission_configs/Hudson South WEA base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1024 -site: - depth: 43 - distance: 280 - distance_to_landfall: .nan -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Kitty Hawk base.yaml b/shared_transmission_configs/Kitty Hawk base.yaml deleted file mode 100644 index e865e8a5..00000000 --- a/shared_transmission_configs/Kitty Hawk base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 2400 -site: - depth: 43 - distance: 150 - distance_to_landfall: 43.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Liberty Wind base.yaml b/shared_transmission_configs/Liberty Wind base.yaml deleted file mode 100644 index 8421f67f..00000000 --- a/shared_transmission_configs/Liberty Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1600 -site: - depth: 43 - distance: 145 - distance_to_landfall: 135.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/MarWin base.yaml b/shared_transmission_configs/MarWin base.yaml deleted file mode 100644 index f6eb43f3..00000000 --- a/shared_transmission_configs/MarWin base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 248 -site: - depth: 43 - distance: 143 - distance_to_landfall: 27.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/Mayflower Res base.yaml b/shared_transmission_configs/Mayflower Res base.yaml deleted file mode 100644 index 68ccc0e5..00000000 --- a/shared_transmission_configs/Mayflower Res base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 747 -site: - depth: 43 - distance: 135 - distance_to_landfall: 50.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Mayflower Wind 1 base.yaml b/shared_transmission_configs/Mayflower Wind 1 base.yaml deleted file mode 100644 index 3feaaa36..00000000 --- a/shared_transmission_configs/Mayflower Wind 1 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 804 -site: - depth: 43 - distance: 135 - distance_to_landfall: 60.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Mayflower Wind 2 base.yaml b/shared_transmission_configs/Mayflower Wind 2 base.yaml deleted file mode 100644 index e67deacf..00000000 --- a/shared_transmission_configs/Mayflower Wind 2 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 747 -site: - depth: 43 - distance: 135 - distance_to_landfall: 60.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Momentum Wind base.yaml b/shared_transmission_configs/Momentum Wind base.yaml deleted file mode 100644 index 5e1ee77a..00000000 --- a/shared_transmission_configs/Momentum Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1205 -site: - depth: 43 - distance: 143 - distance_to_landfall: .nan -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Ocean Wind 1 base.yaml b/shared_transmission_configs/Ocean Wind 1 base.yaml deleted file mode 100644 index 9cc9abfd..00000000 --- a/shared_transmission_configs/Ocean Wind 1 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1104 -site: - depth: 43 - distance: 128 - distance_to_landfall: 25.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/Ocean Wind 2 base.yaml b/shared_transmission_configs/Ocean Wind 2 base.yaml deleted file mode 100644 index ec2ddd76..00000000 --- a/shared_transmission_configs/Ocean Wind 2 base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1148 -site: - depth: 43 - distance: 128 - distance_to_landfall: 25.0 -turbine: - turbine_rating: 14 diff --git a/shared_transmission_configs/Ocean Wind Res base.yaml b/shared_transmission_configs/Ocean Wind Res base.yaml deleted file mode 100644 index 49438892..00000000 --- a/shared_transmission_configs/Ocean Wind Res base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1148 -site: - depth: 43 - distance: 128 - distance_to_landfall: 50.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Park City Wind base.yaml b/shared_transmission_configs/Park City Wind base.yaml deleted file mode 100644 index c0f1a18e..00000000 --- a/shared_transmission_configs/Park City Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 804 -site: - depth: 43 - distance: 120 - distance_to_landfall: 37.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Revolution Wind (CT) base.yaml b/shared_transmission_configs/Revolution Wind (CT) base.yaml deleted file mode 100644 index 6b48b9ae..00000000 --- a/shared_transmission_configs/Revolution Wind (CT) base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 304 -site: - depth: 43 - distance: 80 - distance_to_landfall: 15.0 -turbine: - turbine_rating: 11 diff --git a/shared_transmission_configs/Revolution Wind (RI) base.yaml b/shared_transmission_configs/Revolution Wind (RI) base.yaml deleted file mode 100644 index 80ce4bac..00000000 --- a/shared_transmission_configs/Revolution Wind (RI) base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 400 -site: - depth: 43 - distance: 80 - distance_to_landfall: 15.0 -turbine: - turbine_rating: 11 diff --git a/shared_transmission_configs/Skipjack base.yaml b/shared_transmission_configs/Skipjack base.yaml deleted file mode 100644 index aac7734a..00000000 --- a/shared_transmission_configs/Skipjack base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 120 -site: - depth: 43 - distance: 115 - distance_to_landfall: 30.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/South Fork base.yaml b/shared_transmission_configs/South Fork base.yaml deleted file mode 100644 index 3c5c698f..00000000 --- a/shared_transmission_configs/South Fork base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 130 -site: - depth: 43 - distance: 57 - distance_to_landfall: 56.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/Sunrise Wind base.yaml b/shared_transmission_configs/Sunrise Wind base.yaml deleted file mode 100644 index 2250012a..00000000 --- a/shared_transmission_configs/Sunrise Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 880 -site: - depth: 43 - distance: 90 - distance_to_landfall: 48.0 -turbine: - turbine_rating: 8 diff --git a/shared_transmission_configs/TBD SC Lease base.yaml b/shared_transmission_configs/TBD SC Lease base.yaml deleted file mode 100644 index 2e322cad..00000000 --- a/shared_transmission_configs/TBD SC Lease base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 400 -site: - depth: 43 - distance: 668 - distance_to_landfall: .nan -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Untitled.ipynb b/shared_transmission_configs/Untitled.ipynb deleted file mode 100644 index cee6d224..00000000 --- a/shared_transmission_configs/Untitled.ipynb +++ /dev/null @@ -1,694 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "f57aa6ac-eff2-49b5-9897-de4e4d82aefb", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import yaml\n", - "import pandas as pd\n", - "import numpy as np\n", - "from copy import deepcopy\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b1c57ade-d71e-4df3-ae7a-7c29f2612138", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_excel(\"C:/Users/sbredenk/ORBIT/osw_project_details.xlsx\",sheet_name=0)\n", - "proj_name = df['name'].to_list()\n", - "filename = deepcopy(proj_name)\n", - "for i in range(0,len(filename)):\n", - " filename[i] = \"%s base.yaml\" % proj_name[i]" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "68659d52-49cd-4bc0-bd95-1fe91e8e8f42", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'c:\\users\\sbredenk\\orbit\\library'\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", - "OffshoreSubstationInstallation:\n", - "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n" - ] - } - ], - "source": [ - "total_capex = {}\n", - "for i in range(0,len(proj_name)):\n", - " with open(filename[i], \"r\") as fh:\n", - " config = yaml.load(fh, Loader=yaml.SafeLoader)\n", - " project = ProjectManager(config)\n", - " project.run()\n", - " total_capex[proj_name[i]] = project.capex_breakdown\n", - "# print(total_capex)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d239ca15-e8d1-491a-b0a3-3e7f2ecc9298", - "metadata": {}, - "outputs": [], - "source": [ - "# # print(filename[0])\n", - "# # config = yaml.load(filename[0], Loader=yaml.SafeLoader)\n", - "# with open(filename[0], \"r\") as fh:\n", - "# config = yaml.load(fh, Loader=yaml.SafeLoader)\n", - "# print(config)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2a7f96d0-e7b8-4974-b7fa-480e3be6de25", - "metadata": {}, - "outputs": [], - "source": [ - "# project = ProjectManager(config)\n", - "# project.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "81a3b807-9b1e-44bd-89c2-aa662441c331", - "metadata": {}, - "outputs": [], - "source": [ - "# project.capex_breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "dca4e2f1-88b2-45b7-be71-4495766f7864", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Export SystemOffshore SubstationExport System InstallationOffshore Substation InstallationTurbineSoftProjectTotal
Bay State Wind2.303148e+089.175986e+083.960141e+086.269466e+062.964000e+091.468665e+091.512500e+086.134112e+09
Park City Wind8.529159e+072.488645e+081.464821e+085.541351e+061.053000e+095.185800e+081.512500e+082.209009e+09
Vineyard Wind7.677159e+071.055821e+081.451418e+083.144713e+061.045200e+095.160000e+081.512500e+082.043090e+09
Beacon Wind3.516026e+085.239363e+082.320882e+085.505487e+061.599000e+097.933500e+081.512500e+083.656733e+09
Mayflower Wind 11.342816e+082.882594e+081.501469e+085.810329e+061.053000e+095.185800e+081.512500e+082.301328e+09
Mayflower Wind 21.342816e+081.250785e+081.402435e+083.448699e+069.750000e+084.818150e+081.512500e+082.011117e+09
Liberty Wind5.880632e+087.717445e+083.084256e+085.989648e+062.086500e+091.032000e+091.512500e+084.943973e+09
Sunrise Wind1.449621e+083.073611e+081.626852e+085.003394e+061.144000e+095.676000e+081.512500e+082.482862e+09
Revolution Wind (CT)2.562106e+074.832802e+076.106156e+072.971007e+064.004000e+081.960800e+081.512500e+088.857116e+08
Revolution Wind (RI)2.562106e+075.558142e+077.740593e+072.971007e+065.291000e+082.580000e+081.512500e+081.099929e+09
South Fork4.192053e+074.237166e+073.278349e+072.771245e+061.716000e+088.385000e+071.512500e+085.265469e+08
Empire Wind7.464159e+072.403004e+081.474387e+088.679431e+061.060800e+095.263200e+081.512500e+082.209430e+09
Empire Wind 21.812026e+083.929549e+082.295573e+088.500112e+061.638000e+098.127000e+081.512500e+083.414165e+09
Atlantic Shores Offshore Wind 11.194632e+083.804164e+082.651961e+086.079307e+061.969500e+099.739500e+081.512500e+083.865855e+09
Atlantic Shores Offshore Wind 21.194632e+083.804164e+082.627205e+086.079307e+061.950000e+099.675000e+081.512500e+083.837429e+09
Ocean Wind 19.955265e+073.031187e+081.962150e+085.684806e+061.435200e+097.120800e+081.512500e+082.903101e+09
Ocean Wind 29.955265e+073.091632e+082.034770e+085.684806e+061.492400e+097.404600e+081.512500e+083.001988e+09
Garden State Offshore Energy5.692212e+072.607424e+081.853546e+085.272372e+061.365000e+096.772500e+081.512500e+082.701792e+09
Skipjack2.346053e+073.434497e+072.965637e+073.274993e+061.560000e+087.740000e+071.512500e+084.753869e+08
MarWin2.133053e+074.255531e+075.139725e+073.518181e+063.276000e+081.599600e+081.512500e+087.576113e+08
CVOW Commercial3.269053e+081.538904e+094.552726e+089.258712e+063.354000e+091.664100e+091.512500e+087.499690e+09
Kitty Hawk2.942148e+081.027316e+094.243994e+088.579636e+063.120000e+091.548000e+091.512500e+086.573760e+09
Vineyard Wind South2.259632e+084.660576e+082.700570e+085.541351e+061.950000e+099.675000e+081.512500e+084.036369e+09
Mayflower Res1.129816e+081.165144e+081.394695e+083.448699e+069.750000e+084.818150e+081.512500e+081.980479e+09
Ocean Wind Res1.883026e+083.805308e+082.109008e+085.684806e+061.501500e+097.404600e+081.512500e+083.178629e+09
Hudson North WEANaNNaN1.863273e+089.038069e+061.384500e+096.830550e+081.512500e+082.414170e+09
Hudson South WEANaNNaN1.812817e+088.410453e+061.345500e+096.604800e+081.512500e+082.346922e+09
Momentum WindNaNNaN2.109680e+085.953784e+061.579500e+097.772250e+081.512500e+082.724897e+09
TBD SC LeaseNaNNaN7.693624e+078.090997e+065.265000e+082.580000e+081.512500e+081.020777e+09
TOTAL3.782688e+099.308041e+095.579104e+091.662062e+084.015180e+101.986278e+104.386250e+098.323686e+10
\n", - "
" - ], - "text/plain": [ - " Export System Offshore Substation \\\n", - "Bay State Wind 2.303148e+08 9.175986e+08 \n", - "Park City Wind 8.529159e+07 2.488645e+08 \n", - "Vineyard Wind 7.677159e+07 1.055821e+08 \n", - "Beacon Wind 3.516026e+08 5.239363e+08 \n", - "Mayflower Wind 1 1.342816e+08 2.882594e+08 \n", - "Mayflower Wind 2 1.342816e+08 1.250785e+08 \n", - "Liberty Wind 5.880632e+08 7.717445e+08 \n", - "Sunrise Wind 1.449621e+08 3.073611e+08 \n", - "Revolution Wind (CT) 2.562106e+07 4.832802e+07 \n", - "Revolution Wind (RI) 2.562106e+07 5.558142e+07 \n", - "South Fork 4.192053e+07 4.237166e+07 \n", - "Empire Wind 7.464159e+07 2.403004e+08 \n", - "Empire Wind 2 1.812026e+08 3.929549e+08 \n", - "Atlantic Shores Offshore Wind 1 1.194632e+08 3.804164e+08 \n", - "Atlantic Shores Offshore Wind 2 1.194632e+08 3.804164e+08 \n", - "Ocean Wind 1 9.955265e+07 3.031187e+08 \n", - "Ocean Wind 2 9.955265e+07 3.091632e+08 \n", - "Garden State Offshore Energy 5.692212e+07 2.607424e+08 \n", - "Skipjack 2.346053e+07 3.434497e+07 \n", - "MarWin 2.133053e+07 4.255531e+07 \n", - "CVOW Commercial 3.269053e+08 1.538904e+09 \n", - "Kitty Hawk 2.942148e+08 1.027316e+09 \n", - "Vineyard Wind South 2.259632e+08 4.660576e+08 \n", - "Mayflower Res 1.129816e+08 1.165144e+08 \n", - "Ocean Wind Res 1.883026e+08 3.805308e+08 \n", - "Hudson North WEA NaN NaN \n", - "Hudson South WEA NaN NaN \n", - "Momentum Wind NaN NaN \n", - "TBD SC Lease NaN NaN \n", - "TOTAL 3.782688e+09 9.308041e+09 \n", - "\n", - " Export System Installation \\\n", - "Bay State Wind 3.960141e+08 \n", - "Park City Wind 1.464821e+08 \n", - "Vineyard Wind 1.451418e+08 \n", - "Beacon Wind 2.320882e+08 \n", - "Mayflower Wind 1 1.501469e+08 \n", - "Mayflower Wind 2 1.402435e+08 \n", - "Liberty Wind 3.084256e+08 \n", - "Sunrise Wind 1.626852e+08 \n", - "Revolution Wind (CT) 6.106156e+07 \n", - "Revolution Wind (RI) 7.740593e+07 \n", - "South Fork 3.278349e+07 \n", - "Empire Wind 1.474387e+08 \n", - "Empire Wind 2 2.295573e+08 \n", - "Atlantic Shores Offshore Wind 1 2.651961e+08 \n", - "Atlantic Shores Offshore Wind 2 2.627205e+08 \n", - "Ocean Wind 1 1.962150e+08 \n", - "Ocean Wind 2 2.034770e+08 \n", - "Garden State Offshore Energy 1.853546e+08 \n", - "Skipjack 2.965637e+07 \n", - "MarWin 5.139725e+07 \n", - "CVOW Commercial 4.552726e+08 \n", - "Kitty Hawk 4.243994e+08 \n", - "Vineyard Wind South 2.700570e+08 \n", - "Mayflower Res 1.394695e+08 \n", - "Ocean Wind Res 2.109008e+08 \n", - "Hudson North WEA 1.863273e+08 \n", - "Hudson South WEA 1.812817e+08 \n", - "Momentum Wind 2.109680e+08 \n", - "TBD SC Lease 7.693624e+07 \n", - "TOTAL 5.579104e+09 \n", - "\n", - " Offshore Substation Installation \\\n", - "Bay State Wind 6.269466e+06 \n", - "Park City Wind 5.541351e+06 \n", - "Vineyard Wind 3.144713e+06 \n", - "Beacon Wind 5.505487e+06 \n", - "Mayflower Wind 1 5.810329e+06 \n", - "Mayflower Wind 2 3.448699e+06 \n", - "Liberty Wind 5.989648e+06 \n", - "Sunrise Wind 5.003394e+06 \n", - "Revolution Wind (CT) 2.971007e+06 \n", - "Revolution Wind (RI) 2.971007e+06 \n", - "South Fork 2.771245e+06 \n", - "Empire Wind 8.679431e+06 \n", - "Empire Wind 2 8.500112e+06 \n", - "Atlantic Shores Offshore Wind 1 6.079307e+06 \n", - "Atlantic Shores Offshore Wind 2 6.079307e+06 \n", - "Ocean Wind 1 5.684806e+06 \n", - "Ocean Wind 2 5.684806e+06 \n", - "Garden State Offshore Energy 5.272372e+06 \n", - "Skipjack 3.274993e+06 \n", - "MarWin 3.518181e+06 \n", - "CVOW Commercial 9.258712e+06 \n", - "Kitty Hawk 8.579636e+06 \n", - "Vineyard Wind South 5.541351e+06 \n", - "Mayflower Res 3.448699e+06 \n", - "Ocean Wind Res 5.684806e+06 \n", - "Hudson North WEA 9.038069e+06 \n", - "Hudson South WEA 8.410453e+06 \n", - "Momentum Wind 5.953784e+06 \n", - "TBD SC Lease 8.090997e+06 \n", - "TOTAL 1.662062e+08 \n", - "\n", - " Turbine Soft Project \\\n", - "Bay State Wind 2.964000e+09 1.468665e+09 1.512500e+08 \n", - "Park City Wind 1.053000e+09 5.185800e+08 1.512500e+08 \n", - "Vineyard Wind 1.045200e+09 5.160000e+08 1.512500e+08 \n", - "Beacon Wind 1.599000e+09 7.933500e+08 1.512500e+08 \n", - "Mayflower Wind 1 1.053000e+09 5.185800e+08 1.512500e+08 \n", - "Mayflower Wind 2 9.750000e+08 4.818150e+08 1.512500e+08 \n", - "Liberty Wind 2.086500e+09 1.032000e+09 1.512500e+08 \n", - "Sunrise Wind 1.144000e+09 5.676000e+08 1.512500e+08 \n", - "Revolution Wind (CT) 4.004000e+08 1.960800e+08 1.512500e+08 \n", - "Revolution Wind (RI) 5.291000e+08 2.580000e+08 1.512500e+08 \n", - "South Fork 1.716000e+08 8.385000e+07 1.512500e+08 \n", - "Empire Wind 1.060800e+09 5.263200e+08 1.512500e+08 \n", - "Empire Wind 2 1.638000e+09 8.127000e+08 1.512500e+08 \n", - "Atlantic Shores Offshore Wind 1 1.969500e+09 9.739500e+08 1.512500e+08 \n", - "Atlantic Shores Offshore Wind 2 1.950000e+09 9.675000e+08 1.512500e+08 \n", - "Ocean Wind 1 1.435200e+09 7.120800e+08 1.512500e+08 \n", - "Ocean Wind 2 1.492400e+09 7.404600e+08 1.512500e+08 \n", - "Garden State Offshore Energy 1.365000e+09 6.772500e+08 1.512500e+08 \n", - "Skipjack 1.560000e+08 7.740000e+07 1.512500e+08 \n", - "MarWin 3.276000e+08 1.599600e+08 1.512500e+08 \n", - "CVOW Commercial 3.354000e+09 1.664100e+09 1.512500e+08 \n", - "Kitty Hawk 3.120000e+09 1.548000e+09 1.512500e+08 \n", - "Vineyard Wind South 1.950000e+09 9.675000e+08 1.512500e+08 \n", - "Mayflower Res 9.750000e+08 4.818150e+08 1.512500e+08 \n", - "Ocean Wind Res 1.501500e+09 7.404600e+08 1.512500e+08 \n", - "Hudson North WEA 1.384500e+09 6.830550e+08 1.512500e+08 \n", - "Hudson South WEA 1.345500e+09 6.604800e+08 1.512500e+08 \n", - "Momentum Wind 1.579500e+09 7.772250e+08 1.512500e+08 \n", - "TBD SC Lease 5.265000e+08 2.580000e+08 1.512500e+08 \n", - "TOTAL 4.015180e+10 1.986278e+10 4.386250e+09 \n", - "\n", - " Total \n", - "Bay State Wind 6.134112e+09 \n", - "Park City Wind 2.209009e+09 \n", - "Vineyard Wind 2.043090e+09 \n", - "Beacon Wind 3.656733e+09 \n", - "Mayflower Wind 1 2.301328e+09 \n", - "Mayflower Wind 2 2.011117e+09 \n", - "Liberty Wind 4.943973e+09 \n", - "Sunrise Wind 2.482862e+09 \n", - "Revolution Wind (CT) 8.857116e+08 \n", - "Revolution Wind (RI) 1.099929e+09 \n", - "South Fork 5.265469e+08 \n", - "Empire Wind 2.209430e+09 \n", - "Empire Wind 2 3.414165e+09 \n", - "Atlantic Shores Offshore Wind 1 3.865855e+09 \n", - "Atlantic Shores Offshore Wind 2 3.837429e+09 \n", - "Ocean Wind 1 2.903101e+09 \n", - "Ocean Wind 2 3.001988e+09 \n", - "Garden State Offshore Energy 2.701792e+09 \n", - "Skipjack 4.753869e+08 \n", - "MarWin 7.576113e+08 \n", - "CVOW Commercial 7.499690e+09 \n", - "Kitty Hawk 6.573760e+09 \n", - "Vineyard Wind South 4.036369e+09 \n", - "Mayflower Res 1.980479e+09 \n", - "Ocean Wind Res 3.178629e+09 \n", - "Hudson North WEA 2.414170e+09 \n", - "Hudson South WEA 2.346922e+09 \n", - "Momentum Wind 2.724897e+09 \n", - "TBD SC Lease 1.020777e+09 \n", - "TOTAL 8.323686e+10 " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "dfcapex = pd.DataFrame.from_dict({(i): total_capex[i]\n", - " for i in total_capex.keys()},\n", - " orient='index')\n", - "\n", - "dfcapex[\"Total\"] = dfcapex.sum(axis=1)\n", - "dfcapex_T = dfcapex.T\n", - "dfcapex_T[\"TOTAL\"] = dfcapex_T.sum(axis=1)\n", - "dfcapex = dfcapex_T.T\n", - "\n", - "display(dfcapex)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f2cb4e83-be91-4a08-812e-1ff6960b5e22", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/shared_transmission_configs/Vineyard Wind South base.yaml b/shared_transmission_configs/Vineyard Wind South base.yaml deleted file mode 100644 index 4235ec94..00000000 --- a/shared_transmission_configs/Vineyard Wind South base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 1500 -site: - depth: 43 - distance: 120 - distance_to_landfall: 50.0 -turbine: - turbine_rating: 15 diff --git a/shared_transmission_configs/Vineyard Wind base.yaml b/shared_transmission_configs/Vineyard Wind base.yaml deleted file mode 100644 index 41eb6524..00000000 --- a/shared_transmission_configs/Vineyard Wind base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 800 -site: - depth: 43 - distance: 100 - distance_to_landfall: 33.0 -turbine: - turbine_rating: 12 diff --git a/shared_transmission_configs/nan base.yaml b/shared_transmission_configs/nan base.yaml deleted file mode 100644 index 66c61c5c..00000000 --- a/shared_transmission_configs/nan base.yaml +++ /dev/null @@ -1,21 +0,0 @@ -array_system: - cables: - - XLPE_630mm_66kV -design_phases: !!set - ElectricalDesign: null -export_cable_install_vessel: example_cable_lay_vessel -export_system_design: - cables: XLPE_630mm_220kV -feeder: future_feeder -install_phases: !!set - ExportCableInstallation: null - OffshoreSubstationInstallation: null -oss_install_vessel: example_heavy_lift_vessel -plant: - capacity: 30795 -site: - depth: 43 - distance: .nan - distance_to_landfall: .nan -turbine: - turbine_rating: .nan diff --git a/test_HVDC.ipynb b/test_HVDC.ipynb deleted file mode 100644 index 3bb39902..00000000 --- a/test_HVDC.ipynb +++ /dev/null @@ -1,235 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "f11c08fd-1397-46cb-bfc0-fe8bec7ccba1", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "76adf9c4-7e6e-41de-bc85-0a765074fd94", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 200},\n", - " 'plant': {'num_turbines': 4, 'capacity': 48},\n", - " 'turbine': {'turbine_rating': 12},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_1200m_300kV_DC\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ebb79d9f-e076-4649-ba7d-5a99c975fd97", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\sbredenk\\ORBIT\\library'\n", - "Design uses HVDC cable\n" - ] - } - ], - "source": [ - "design = ProjectManager(config)\n", - "design.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "00691bac-4378-4e14-9eee-ef24081c25f8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "151249900.0" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "design.capex_breakdown['Export System']" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ba713603-8158-45d7-af4d-2a425515144a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n", - "134000\n", - "1750000\n", - "874.8\n" - ] - } - ], - "source": [ - "print(design.phases[\"ElectricalDesign\"].shunt_reactor_cost)\n", - "print(design.phases[\"ElectricalDesign\"].switchgear_costs)\n", - "print(design.phases[\"ElectricalDesign\"].mpt_cost)\n", - "print(design.phases[\"ElectricalDesign\"].cable.cable_power)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "1dcd7372-003a-42a0-a882-7c287db7123c", - "metadata": {}, - "outputs": [], - "source": [ - "config_ac = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {'distance': 100, 'depth': 20, 'distance_to_landfall': 200},\n", - " 'plant': {'num_turbines': 4, 'capacity': 48},\n", - " 'turbine': {'turbine_rating': 12},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - " 'export_system_design': {\n", - " 'cables': \"XLPE_1000m_220kV\",\n", - " # 'num_redundant': 'int (optional)',\n", - " # 'touchdown_distance': 'm (optional, default: 0)',\n", - " # 'percent_added_length': 'float (optional)'\n", - " },\n", - " # 'substation_design': {\n", - " # 'mpt_cost_rate': 'USD/MW (optional)',\n", - " # 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " # 'topside_design_cost': 'USD (optional)',\n", - " # 'shunt_cost_rate': 'USD/MW (optional)',\n", - " # 'switchgear_costs': 'USD (optional)',\n", - " # 'backup_gen_cost': 'USD (optional)',\n", - " # 'workspace_cost': 'USD (optional)',\n", - " # 'other_ancillary_cost': 'USD (optional)',\n", - " # 'topside_assembly_factor': 'float (optional)',\n", - " # 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " # 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " # 'num_substations': 'int (optional)'\n", - " # },\n", - "\n", - " 'design_phases': [\n", - " 'ElectricalDesign'\n", - " ],\n", - " 'install_phases': [\n", - " 'ExportCableInstallation',\n", - " 'OffshoreSubstationInstallation'\n", - " ],\n", - " }" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "91b3c9e0-8b9b-4ef4-9626-f3cbd775d9bf", - "metadata": {}, - "outputs": [], - "source": [ - "design_ac = ProjectManager(config_ac)\n", - "design_ac.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "96f90240-f258-465d-b099-80fc370b97de", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "62851104.43741779\n", - "134000\n", - "1750000\n", - "0\n" - ] - } - ], - "source": [ - "print(design_ac.phases[\"ElectricalDesign\"].shunt_reactor_cost)\n", - "print(design_ac.phases[\"ElectricalDesign\"].switchgear_costs)\n", - "print(design_ac.phases[\"ElectricalDesign\"].mpt_cost)\n", - "print(design_ac.phases[\"ElectricalDesign\"].converter_cost)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27551ffe-c367-4b3b-bbd7-1a4ba713c3b3", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 2452c85b585edf085acf477ebf21a897dd291ec8 Mon Sep 17 00:00:00 2001 From: jnunemak Date: Mon, 20 Dec 2021 13:29:52 -0600 Subject: [PATCH 020/240] Added docs structure. --- docs/source/api_DesignPhase.rst | 1 + docs/source/doc_DesignPhase.rst | 1 + docs/source/phases/design/api_ElectricalDesign.rst | 8 ++++++++ docs/source/phases/design/doc_ElectricalDesign.rst | 10 ++++++++++ 4 files changed, 20 insertions(+) create mode 100644 docs/source/phases/design/api_ElectricalDesign.rst create mode 100644 docs/source/phases/design/doc_ElectricalDesign.rst diff --git a/docs/source/api_DesignPhase.rst b/docs/source/api_DesignPhase.rst index 63f1f5d3..6a6e271f 100644 --- a/docs/source/api_DesignPhase.rst +++ b/docs/source/api_DesignPhase.rst @@ -14,6 +14,7 @@ trends but are not intended to be used for actual designs. phases/design/api_ScourProtectionDesign phases/design/api_ArraySystemDesign phases/design/api_ExportSystemDesign + phases/design/api_ElectricalDesign phases/design/api_OffshoreSubstationDesign phases/design/api_SemiSubmersibleDesign phases/design/api_SparDesign diff --git a/docs/source/doc_DesignPhase.rst b/docs/source/doc_DesignPhase.rst index f4121504..8d2c6fce 100644 --- a/docs/source/doc_DesignPhase.rst +++ b/docs/source/doc_DesignPhase.rst @@ -13,6 +13,7 @@ the model. phases/design/doc_ScourProtectionDesign phases/design/doc_ArraySystemDesign phases/design/doc_ExportSystemDesign + phases/design/doc_ElectricalDesign phases/design/doc_OffshoreSubstationDesign phases/design/doc_SemiSubmersibleDesign phases/design/doc_SparDesign diff --git a/docs/source/phases/design/api_ElectricalDesign.rst b/docs/source/phases/design/api_ElectricalDesign.rst new file mode 100644 index 00000000..4c65f8d1 --- /dev/null +++ b/docs/source/phases/design/api_ElectricalDesign.rst @@ -0,0 +1,8 @@ +Electrical System Design API +============================ + +For detailed methodology, please see +:doc:`Electrical System Design `. + +.. autoclass:: ORBIT.phases.design.ElectricalDesign + :members: diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst new file mode 100644 index 00000000..ea2640e7 --- /dev/null +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -0,0 +1,10 @@ +Electrical System Design Methodology +==================================== + +For details of the code implementation, please see +:doc:`Electrical System Design API `. + +Overview +-------- + +Overview of module... From cd2dad10657dec76c9691be6d20b2e04451fc63c Mon Sep 17 00:00:00 2001 From: jnunemak Date: Mon, 20 Dec 2021 14:06:46 -0600 Subject: [PATCH 021/240] Added temp default cable type. --- ORBIT/phases/design/_cables.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index f70825f7..1998fb57 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -58,7 +58,7 @@ class Cable: "linear_density", "cost_per_km", "name", - "cable_type", + # "cable_type", ) def __init__(self, cable_specs, **kwargs): @@ -85,6 +85,7 @@ def __init__(self, cable_specs, **kwargs): raise ValueError(f"{needs_value} must be defined in cable_specs") self.line_frequency = cable_specs.get("line_frequency", 60) + self.cable_type = cable_specs.get("cable_type", "HVAC") # Calc additional cable specs if self.cable_type == 'HVAC': From 68d82cdbdee2ec1d851112902eedd654c5b34d53 Mon Sep 17 00:00:00 2001 From: jnunemak Date: Mon, 20 Dec 2021 14:07:13 -0600 Subject: [PATCH 022/240] Fixed issue in export system install test. --- tests/phases/install/cable_install/test_export_install.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 34669075..80889fb1 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -121,7 +121,8 @@ def test_separate_speed_kwargs(): def test_kwargs_for_export_install(): new_export_system = { - "cable": {"linear_density": 50.0, "sections": [1000], "number": 1} + "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, + "system_cost": 200e6, } new_site = {"distance": 50, "depth": 20} From a350dc91cf88c607fc6a377dd3e3debd3e6ff96f Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 21 Dec 2021 08:38:49 -0700 Subject: [PATCH 023/240] cleaned up electrical_export, _cables comments + spacing, fixed test --- ORBIT/phases/design/_cables.py | 28 +++++++++---------- ORBIT/phases/design/electrical_export.py | 17 ++++------- tests/phases/design/test_electrical_design.py | 4 +-- 3 files changed, 21 insertions(+), 28 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 1998fb57..4e259848 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -58,7 +58,7 @@ class Cable: "linear_density", "cost_per_km", "name", - # "cable_type", + "cable_type", ) def __init__(self, cable_specs, **kwargs): @@ -98,19 +98,19 @@ def calc_char_impedance(self): """ Calculate characteristic impedance of cable. """ -# if self.cable_type == 'HVDC': -# self.char_impedance = 0 -# else: - conductance = 1 / self.ac_resistance - - num = complex( - self.ac_resistance, - 2 * math.pi * self.line_frequency * self.inductance, - ) - den = complex( - conductance, 2 * math.pi * self.line_frequency * self.capacitance - ) - self.char_impedance = np.sqrt(num / den) + if self.cable_type == 'HVDC': + self.char_impedance = 0 + else: + conductance = 1 / self.ac_resistance + + num = complex( + self.ac_resistance, + 2 * math.pi * self.line_frequency * self.inductance, + ) + den = complex( + conductance, 2 * math.pi * self.line_frequency * self.capacitance + ) + self.char_impedance = np.sqrt(num / den) def calc_power_factor(self): """ diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 5c86c3f2..ef5b489a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -5,7 +5,6 @@ import numpy as np -# from ORBIT.core.library import extract_library_specs from ORBIT.phases.design._cables import CableSystem @@ -108,12 +107,6 @@ def run(self): "cable_power": cable.cable_power, } - # self._outputs["export_system"] = { - # "power_factor": self.cables.power_factor, - # "interconnection_distance": self._distance_to_interconnection, - # "system_cost": self.total_cost, - # } - # SUBSTATION self.calc_num_substations() self.calc_substructure_length() @@ -185,8 +178,7 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ -# if self.cable.cable_type == 'HVDC': -# print("Design uses HVDC cable") + num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) @@ -253,6 +245,7 @@ def sections_cables(self): def calc_num_substations(self): """Computes number of substations""" + self._design = self.config.get("substation_design", {}) self.num_substations = self._design.get( "num_substations", int(np.ceil(self._plant_capacity / 800)) @@ -274,6 +267,7 @@ def substation_cost(self): def calc_mpt_cost(self): """Computes transformer cost""" + self.num_mpt = self.num_cables self.mpt_cost = ( self.num_mpt * self._design.get("mpt_cost_rate", 1750000) @@ -289,7 +283,7 @@ def calc_mpt_cost(self): def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" - # get distance to shore + touchdown = self.config["site"]["distance_to_landfall"] if self.cable.cable_type == "HVDC": @@ -330,6 +324,7 @@ def calc_ancillary_system_cost(self): ) def calc_converter_cost(self): + """Computes converter cost""" if self.cable.cable_type == "HVDC": self.converter_cost = ( @@ -337,8 +332,6 @@ def calc_converter_cost(self): ) else: self.converter_cost = 0 - - def calc_assembly_cost(self): """ diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 513b4ee3..c8c9a439 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -148,7 +148,7 @@ def test_number_cables(): export = ElectricalDesign(config) export.run() - assert export.num_cables == 11 + assert export.num_cables == 9 def test_cable_length(): export = ElectricalDesign(config) @@ -172,7 +172,7 @@ def test_total_cable(): length = 0.02 + 3 + 30 length += length * 0.01 mass = length * export.cable.linear_density - assert export.total_mass == pytest.approx(mass *11, abs=1e-10) + assert export.total_mass == pytest.approx(mass * 9, abs=1e-10) assert export.total_length == pytest.approx(length * 9, abs=1e-10) def test_cables_property(): From 53d2736fe20d160ee758526486150d9d5a8a1aff Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 11 Jan 2022 09:29:16 -0700 Subject: [PATCH 024/240] first draft of documentation --- .../phases/design/doc_ElectricalDesign.rst | 69 ++++++++++++++++++- 1 file changed, 68 insertions(+), 1 deletion(-) diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index ea2640e7..e943209a 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -7,4 +7,71 @@ For details of the code implementation, please see Overview -------- -Overview of module... +Below is an overview of the process used to design an export cable system and +offshore substation in ORBIT. For more detail on the helper classes used to +support this design please see :doc:`Cabling Helper Classes `, +specifically :class:`Cable` and :class:`CableSystem`. + + +Number of Required Cables +--------- +The number of export cables required is calculated by dividing the windfarm's +capacity by the configured export cable's power rating and adding any user +defined redundnacy as seen below. + +:math:`num\_cables = \lceil\frac{plant\_capacity}{cable\_power}\rceil + num\_redundant` + + +Export Cable Length +--------- +The total length of the export cables is calculated as the sum of the site +depth, distance to landfall and distance to interconnection multiplied by the +user defined :py:attr`percent_added_length` to account for any exclusions or +geotechnical design considerations that make a straight line cable route +impractical. + +:math:`length = (d + distance_\text{landfall} + distance_\text{interconnection} * (1 + length_\text{percent_added})` + + +Number of Required Power Transformer adn Tranformer Rating +--------- +The number of power transformers required is assumed to be equal to the number +of required export cables. The transformer rating is calculated by dividing the +windfarm's capacity by the number of power transformers. + + +Shunt Reactors and Reactive Power Compenation +--------- +The shunt reactor cost is dependent on the amount of reactive power compensation +required based on the distance of the substation to shore. There is assumed to be +one shunt reactor for each HVAC export cable. HVDC export systems do not require +reactive power compensation, thus the shunt reactor cost is zero for HVDC systems. + + +Number of Required Switchgears +--------- +The number of shunt reactors required is assumed to be equal to the number of +required export cables. + + +Number of Required AC\DC Converters +--------- +AC\DC converters are only required for HVDC export cables. The number of converters +is assumed to be equal to the number of HVDC export cables. + + + +Design Result +--------- +The result of this design module (:py:attr:`design_result`) includes the +specifications for both the export cables and offshore substation. This includes +a list of cable sections and their lengths and masses that represent the export +cable system, as well as the offshore substation substructure and topside mass +and cost, and number of substations. This result can then be passed to the +:doc:`export cable installation module <../install/export/doc_ExportCableInstall>` and +:doc:`offshore substation installation module <../install/export/doc_OffshoreSubstationInstall>` +to simulate the installation of the export system. + + + + From dfa7f01f94bf7e872c3939f24d96e790cac31bef Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 31 May 2022 10:20:59 -0600 Subject: [PATCH 025/240] DC cables, additional DC capabilities --- ORBIT/phases/design/_cables.py | 2 +- ORBIT/phases/design/electrical_export.py | 92 ++- ORBIT/phases/design/old_v_new.ipynb | 711 ------------------ ORBIT/phases/install/cable_install/export.py | 12 +- .../phases/design/doc_ElectricalDesign.rst | 13 +- library/cables/HVDC_2000mm_320kV.yaml | 11 + library/cables/HVDC_2000mm_400kV.yaml | 10 + library/cables/HVDC_2500mm_525kV.yaml | 11 + library/cables/XLPE_1200m_300kV_DC.yaml | 2 +- tests/phases/design/test_electrical_design.py | 97 ++- 10 files changed, 209 insertions(+), 752 deletions(-) delete mode 100644 ORBIT/phases/design/old_v_new.ipynb create mode 100644 library/cables/HVDC_2000mm_320kV.yaml create mode 100644 library/cables/HVDC_2000mm_400kV.yaml create mode 100644 library/cables/HVDC_2500mm_525kV.yaml diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 4e259848..b0182aa2 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -127,7 +127,7 @@ def calc_cable_power(self): Calculate maximum power transfer through 3-phase cable in :math:`MW`. """ - if self.cable_type == 'HVDC': + if self.cable_type == 'HVDC-monopole' or 'HVDC-bipole': self.cable_power = ( self.current_capacity * self.rated_voltage * 2 / 1000 ) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index ef5b489a..d1bf636d 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -23,6 +23,10 @@ class ElectricalDesign(CableSystem): "num_redundant": "int (optional)", "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", + "cable_crossings": { + "crossing_number": "int (optional)", + "crossing_unit_cost": "float (optional)" + }, }, "substation_design": { "mpt_cost_rate": "USD/MW (optional)", @@ -52,6 +56,7 @@ class ElectricalDesign(CableSystem): "sections": [("length, km", "speed, km/h (optional)")], "number": "int (optional)", "diameter": "int", + "cable_type": "str", }, }, } @@ -97,6 +102,7 @@ def run(self): self.compute_cable_length() self.compute_cable_mass() self.compute_total_cable() + self.calc_crossing_cost() self._outputs["export_system"] = {"system_cost": self.total_cable_cost} for name, cable in self.cables.items(): @@ -105,6 +111,7 @@ def run(self): "sections": [self.length], "number": self.num_cables, "cable_power": cable.cable_power, + "cable_type": cable.cable_type, } # SUBSTATION @@ -121,6 +128,7 @@ def run(self): self.calc_assembly_cost() self.calc_substructure_mass_and_cost() self.calc_converter_cost() + self.calc_dc_breaker_cost() self._outputs["offshore_substation_substructure"] = { "type": "Monopile", # Substation install only supports monopiles @@ -154,6 +162,7 @@ def detailed_output(self): "substation_topside_cost": self.topside_cost, "substation_substructure_mass": self.substructure_mass, "substation_substructure_cost": self.substructure_cost, + "total_substation_cost": self.total_substation_cost, } return _output @@ -169,19 +178,22 @@ def design_result(self): @property def total_cable_cost(self): - """Returns total array system cable cost.""" - - return sum(self.cost_by_type.values()) + """Returns total export system cable cost.""" + + return sum(self.cost_by_type.values()) + self.crossing_cost def compute_number_cables(self): """ Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ + if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": + num_required = 2 * np.ceil(self._plant_capacity / self.cable.cable_power) + num_redundant = 2 * self._design.get("num_redundant", 0) + else: + num_required = np.ceil(self._plant_capacity / self.cable.cable_power) + num_redundant = self._design.get("num_redundant", 0) - num_required = np.ceil(self._plant_capacity / self.cable.cable_power) - num_redundant = self._design.get("num_redundant", 0) - self.num_cables = int(num_required + num_redundant) def compute_cable_length(self): @@ -240,16 +252,39 @@ def sections_cables(self): """ return np.full(self.num_cables, self.cable.name) + + def calc_crossing_cost(self): + """Compute cable crossing costs""" + self._crossing_design = self.config["export_system_design"].get("cable_crossings",{}) + self.crossing_cost = ( + self._crossing_design.get("crossing_unit_cost", 500000) + * self._crossing_design.get("crossing_number", 0) + ) + #################### SUBSTATION #################### + + @property + def total_substation_cost(self): + return (self.topside_cost + self.substructure_cost + + self.substation_cost) def calc_num_substations(self): """Computes number of substations""" self._design = self.config.get("substation_design", {}) - self.num_substations = self._design.get( - "num_substations", int(np.ceil(self._plant_capacity / 800)) - ) + if self.cable.cable_type == 'HVDC-monopole': + self.num_substations = self._design.get( + "num_substations", int(self.num_cables / 2) + ) + elif self.cable.cable_type == 'HVDC-bipole': + self.num_substations = self._design.get( + "num_substations", int(self.num_cables / 2) + ) + else: + self.num_substations = self._design.get( + "num_substations", int(np.ceil(self._plant_capacity / 800)) + ) @property def substation_cost(self): @@ -258,8 +293,9 @@ def substation_cost(self): return ( self.mpt_cost + self.shunt_reactor_cost - + self.switchgear_costs + + self.switchgear_cost + self.converter_cost + + self.dc_breaker_cost + self.topside_cost + self.ancillary_system_cost + self.land_assembly_cost @@ -286,7 +322,7 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] - if self.cable.cable_type == "HVDC": + if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": compensation = 0 else: for name, cable in self.cables.items(): @@ -299,9 +335,22 @@ def calc_shunt_reactor_cost(self): def calc_switchgear_costs(self): """Computes switchgear cost""" - num_switchgear = self.num_cables - self.switchgear_costs = ( - num_switchgear * self._design.get("switchgear_costs", 134000) + if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": + num_switchgear = 0 + else: + num_switchgear = self.num_cables + self.switchgear_cost = ( + num_switchgear * self._design.get("switchgear_cost", 134000) + ) + + def calc_dc_breaker_cost(self): + """Computes HVDC circuit breaker cost""" + if self.cable.cable_type == "HVAC": + num_dc_breaker = 0 + else: + num_dc_breaker = self.num_cables + self.dc_breaker_cost = ( + num_dc_breaker * self._design.get("dc_breaker_cost", 4000000) #4e6 ) def calc_ancillary_system_cost(self): @@ -326,12 +375,15 @@ def calc_ancillary_system_cost(self): def calc_converter_cost(self): """Computes converter cost""" - if self.cable.cable_type == "HVDC": - self.converter_cost = ( - self.num_cables * self._design.get("converter_cost", 137e6) - ) + if self.cable.cable_type == "HVDC-monopole": + self.num_converters = self.num_cables / 2 + + elif self.cable.cable_type == "HVDC-bipole": + self.num_converters = self.num_cables else: - self.converter_cost = 0 + self.num_converters = 0 + + self.converter_cost = self.num_converters * self._design.get("converter_cost", 137e6) def calc_assembly_cost(self): """ @@ -345,7 +397,7 @@ def calc_assembly_cost(self): _design = self.config.get("substation_design", {}) topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) self.land_assembly_cost = ( - self.switchgear_costs + self.switchgear_cost + self.shunt_reactor_cost + self.ancillary_system_cost ) * topside_assembly_factor diff --git a/ORBIT/phases/design/old_v_new.ipynb b/ORBIT/phases/design/old_v_new.ipynb deleted file mode 100644 index feb48418..00000000 --- a/ORBIT/phases/design/old_v_new.ipynb +++ /dev/null @@ -1,711 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "a52a565e-aae4-473a-86e1-b49bd4e85cdb", - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import ElectricalDesign\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib import cm\n", - "from matplotlib.colors import ListedColormap, LinearSegmentedColormap" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "460416b8-ef30-4109-861a-b8c9208f8d27", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100, \n", - " 'depth': 20, \n", - "# 'distance_to_landfall': 50\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10\n", - "# 'num_turbines': 50, \n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - "# 'export_system_design': {\n", - "# 'cables': 'XLPE_500mm_220kV',\n", - " 'design_phases': ['ExportSystemDesign', 'OffshoreSubstationDesign']\n", - " \n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "03d0cb25-dc29-4fe9-8326-0b6b4747cabb", - "metadata": {}, - "outputs": [], - "source": [ - "parameters = {\n", - " 'export_system_design.cables': ['XLPE_1000m_220kV', 'XLPE_1200m_300kV_DC'],\n", - " 'site.distance_to_landfall': np.arange(15,315,15),\n", - "# 'plant.num_turbines': np.arange(50,250,50), \n", - " 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "11c2d8d2-ab29-4c16-8b7d-0b713209b090", - "metadata": {}, - "outputs": [], - "source": [ - "results = {\n", - " 'cable_cost': lambda project: project.phases['ExportSystemDesign'].total_cable_cost,\n", - " 'oss_cost': lambda project: project.phases['OffshoreSubstationDesign'].substation_cost,\n", - " 'num_substations': lambda project: project.phases['OffshoreSubstationDesign'].num_substations,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "46b78ce1-160d-4b06-ab70-8889c6caf31a", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'c:\\users\\sbredenk\\orbit\\library'\n" - ] - }, - { - "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", - "
export_system_design.cablessite.distance_to_landfallplant.capacitycable_costoss_costnum_substations
0XLPE_1000m_220kV1510015317000.026226375.01
1XLPE_1000m_220kV1520015317000.036682875.01
2XLPE_1000m_220kV1530015317000.047826750.01
3XLPE_1000m_220kV1540030634000.058283250.01
4XLPE_1000m_220kV1550030634000.068739750.01
.....................
795XLPE_1200m_300kV_DC3001600506043400.0101484000.02
796XLPE_1200m_300kV_DC3001700506043400.077269500.03
797XLPE_1200m_300kV_DC3001800759065100.079883625.03
798XLPE_1200m_300kV_DC3001900759065100.082497750.03
799XLPE_1200m_300kV_DC3002000759065100.087726000.03
\n", - "

800 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " export_system_design.cables site.distance_to_landfall plant.capacity \\\n", - "0 XLPE_1000m_220kV 15 100 \n", - "1 XLPE_1000m_220kV 15 200 \n", - "2 XLPE_1000m_220kV 15 300 \n", - "3 XLPE_1000m_220kV 15 400 \n", - "4 XLPE_1000m_220kV 15 500 \n", - ".. ... ... ... \n", - "795 XLPE_1200m_300kV_DC 300 1600 \n", - "796 XLPE_1200m_300kV_DC 300 1700 \n", - "797 XLPE_1200m_300kV_DC 300 1800 \n", - "798 XLPE_1200m_300kV_DC 300 1900 \n", - "799 XLPE_1200m_300kV_DC 300 2000 \n", - "\n", - " cable_cost oss_cost num_substations \n", - "0 15317000.0 26226375.0 1 \n", - "1 15317000.0 36682875.0 1 \n", - "2 15317000.0 47826750.0 1 \n", - "3 30634000.0 58283250.0 1 \n", - "4 30634000.0 68739750.0 1 \n", - ".. ... ... ... \n", - "795 506043400.0 101484000.0 2 \n", - "796 506043400.0 77269500.0 3 \n", - "797 759065100.0 79883625.0 3 \n", - "798 759065100.0 82497750.0 3 \n", - "799 759065100.0 87726000.0 3 \n", - "\n", - "[800 rows x 6 columns]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "parametric = ParametricManager(base_config, parameters, results, product=True)\n", - "parametric.run()\n", - "parametric.results\n", - "# parametric.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", - "# parametric.preview()" - ] - }, - { - "cell_type": "markdown", - "id": "d4b6054d-cd43-4718-8fcc-7af9bb10f457", - "metadata": { - "tags": [] - }, - "source": [ - "# Varying plant capacity for given distance to shore" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "866139bd-732a-435a-8a09-919e9c3e5509", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "400\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHRCAYAAACM4XgiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwAklEQVR4nO3dd1gUV9sG8HtpS+9dQLBhwQKCDaMoamzBXmJvSYwx1hQ1RU1iTIya1xZjvtjyxp5Eo2/sBXsHLFERFAQbSF3qsuzO9wdh40pfyi7L/bsuLtmZc2aeYVj28Zwz54gEQRBAREREpKP0NB0AERERUXViskNEREQ6jckOERER6TQmO0RERKTTmOwQERGRTmOyQ0RERDqNyQ4RERHpNCY7REREpNOY7BAREZFOq7PJTmRkJNasWYMJEyagZcuWMDAwgEgkwldffVUt57tw4QJGjBgBd3d3GBkZwczMDC1btsTHH3+MxMTEajknERERAQaaDkBT1q9fj1WrVtXIuX744QdMnz4dgiDAx8cHHTt2RGZmJi5duoRly5Zhy5YtOH36NJo2bVoj8RAREdUldbZlx8fHBx988AG2bduGu3fvYuzYsdVynoSEBMyePRuCIGDLli24desWdu/ejYMHD+LRo0fo1asXEhMTMWvWrGo5PxERUV1XZ1t2pkyZovJaT6968r5z584hLy8PzZs3x/jx41X2WVhYYOHChTh69CguXrxYLecnIiKq6+psy4668vPz8fPPPyMoKAi2trYQi8Xw8vLCu+++i/j4+CLljY2Ny3Vce3v7qg6ViIiIwGSnQjIyMtCzZ0+89dZbuH79Olq1aoWQkBCIxWL8+OOP8PX1RXh4uEqdjh07wsrKCnfu3MHWrVtV9mVmZmLx4sUAgHfeeafGroOIiKguYbJTAVOnTkVoaCj69++PBw8eIDQ0FHv27MG9e/fw/fffIzk5GSNGjIBcLlfWsbW1xdatW2FmZqZ88mv48OHo168fPDw8cPXqVSxZsgQffvihBq+MiIhIdzHZKae7d+9ix44dcHV1xfbt2+Ho6Kiyf9asWejbty+ioqJw6NAhlX0DBgzA6dOn0bBhQ9y+fRt79uzBwYMHkZqaioCAAAQGBkIkEtXk5RAREdUZTHbK6eDBgxAEAX369IGFhUWxZYKCggAUzKnzsvXr16Njx46ws7NDaGgo0tPTER8fj3Xr1uHSpUvo3r07tmzZUs1XQEREVDfV2aexKurhw4cAgI0bN2Ljxo2lln3x4oXy+/Pnz2PatGlwcXHB0aNHYWVlBQCwtLTEtGnTYGtrizfffBOzZs3CwIEDYW1tXW3XQEREVBcx2SknhUIBAGjTpg1at25datn27dsrvy9ssenbt68y0XnZ0KFDMX78eKSnp+Pq1avo2bNn1QVNRERETHbKy93dHQAQGBiItWvXlrteXFwcgIKWnOIYGBjAzMwMeXl5SElJqXygREREpIJjdsqpT58+AID9+/cjNze33PXq1asHALh8+XKx+yMjI5GamgoA8PLyqmSURERE9ComO+Xk6+uLIUOGID4+HoMHD0ZsbGyRMllZWdi2bRsSEhKU24YOHQqgYNDyd999B0EQlPsSExMxefJkAECTJk3g7+9fvRdBRERUB4mElz9965CwsDBMmzZN+frBgwdISkqCm5ubsjUGAPbu3QsXFxcABZMKDho0CCdOnICRkRFat24NLy8vCIKA2NhY3LhxA3l5ebh7967Kop5Tp07Fhg0bAACNGjVCq1atkJGRgcuXL0MikcDa2hpHjhxBu3btaujqiYiI6o46m+yEhoaiW7duZZaLiYmBp6en8rVCocCuXbvw66+/4vr160hJSYGlpSVcXFwQEBCAkJAQ9OvXD4aGhirH+fPPP7Fx40Zcu3YNSUlJMDAwgJeXF15//XXMmTMHbm5uVX2JREREhDqc7BAREVHdwDE7REREpNOY7BAREZFOq1Pz7CgUCjx9+hQWFhZci4qIiKiWEAQBGRkZcHV1hZ5exdtp6lSy8/TpU+XkgERERFS7xMfHq/VAT51KdgoX8IyPjy9xRmMiIiLSLhKJBO7u7iUuxF2WOpXsFHZdWVpaMtkhIiKqZdQdgsIBykRERKTTmOwQERGRTmOyQ0RERDqNyQ4RERHpNCY7REREpNOY7BAREZFOY7JDREREOo3JDhEREek0JjtERESk05jsEBERkU5jskNEREQ6jckOERER6TQmO0RERKTTmOwQERGRTtPaZCc2NhYikahcX2fOnNF0uERERKSlDDQdQEnMzc0xfvz4EvffuXMHV69ehYWFBdq2bVuDkREREVFtorXJjr29PbZs2VLi/r59+wIARo4cCTMzsxqKioiIiGobre3GKs2TJ09w5MgRAMDkyZM1HA0RERFps1qZ7GzZsgUKhQItWrRA+/btNR0OERERabFam+wAbNUhIiKistW6ZOf06dOIjo6GkZERxo4dq+lwiIiISMtp7QDlkmzatAkAEBISAnt7+1LLSqVSSKVS5WuJRFKtsREREZH2qVUtOxKJBL/99hsAYNKkSWWWX7p0KaysrJRf7u7u1R0iERERaZlalezs3LkT2dnZcHNzw+uvv15m+fnz5yM9PV35FR8fXwNREhERkTapVd1YhV1YEyZMgJ5e2XmaWCyGWCyu7rCIiIhIi9Walp07d+7g8uXLEIlEmDhxoqbDISIiolqi1iQ7GzduBAB069YNDRo00HA0REREVFvUimRHJpPh119/BcC5dYiIiKhiakWy87///Q+JiYmwtrbG4MGDNR0OERER1SK1ItkpHJg8atQoGBsbazgaIiIiqk1qxdNYBw4c0HQIREREVEvVipYdIiIiInUx2SEiIiKdxmSHiIiIdBqTHSIiItJpTHaIiIhIpzHZISIiIp3GZIeIiIh0GpMdIiIi0mlMdoiIiEinMdkhIiIincZkh4iIiHQakx0iIiLSaUx2iIiISKcx2SEiIiKdxmSHiIiIdBqTHSIiItJpTHaIiIhIpzHZISIiIp3GZIeIiIh0GpMdIiIiqhJyhaDpEIploOkAiIiIqPZKy87DsTsJOHz7OZ5LcvHXjNc0HVIRTHaIiIioQpIypTj6dwIO3X6Giw+Skf9Si87DF5lo4GCuweiKYrJDREREZUqQ5OLw7ec4dPsZrsSk4OUeq6bOFujt44y+LV3gZW+muSBLwGSHiIiIivU4NfufBOc5rj9KVdnXsp4Vevs4o4+Ps9a15LyKyQ4REREpxSZl4dA/LTg3H6er7PPzsEYfHxf09nGGu62phiKsOCY7REREdVxUQgYO3X6Og7ee4d7zDOV2PREQ4GmLPj7OeN3HGS5WJhqMUn1MdoiIiOoYQRBw55kEh/9JcB68yFLu09cToVNDO/T2cUav5s5wsBBrMNKqwWSHiIioDhAEATcep+PQ7Wc4dOs54lKylfsM9UV4rbEDevs4o2czJ9iYGWkw0qrHZIeIiEjHKRQCpu8Iw8Fbz5XbxAZ6CPJ2QB8fF3Rv5ghLY0MNRli9mOwQERHpuDUno3Hw1nMY6ovQq4Uz+vq4IMjbAWbiupEG1I2rJCIiqqNORSbiPyfuAwC+HtQSw/zdNRxRzePaWERERDoqLjkbM3eEQxCA0e096mSiA9SCZCcvLw+rV69G586dYWtrC2NjY7i5uaFPnz7YtWuXpsMjIiLSSjl5crzz63VIcvPRxt0an7/RXNMhaYxWd2M9fvwYr7/+Ou7cuQN7e3sEBgbCzMwM8fHxOHPmDMzMzDBixAhNh0lERKRVBEHAJ/tu4e4zCezMjLB+jB/EBvqaDktjtDbZycnJQc+ePXHv3j0sWrQICxYsgKHhvyPFs7Ozcf/+fQ1GSEREpJ1+vfQIf4Q9gZ4IWDPKt9ZOBlhVtDbZWbp0Ke7du4e3334bCxcuLLLf1NQUbdq0qfnAiIiItNj1R6n44n93AADz+jRFp4b2Go5I87RyzI5MJsP69esBAB9++KGGoyEiIqodXmRIMW3bdcjkAvq2dMZbrzXQdEhaQStbdsLCwpCUlARXV1c0atQIt27dwh9//IGnT5/CxsYGr732Gvr06QM9Pa3M1YiIiGpcvlyB6dvDkCCRopGjOZYNbQ2RSKTpsLSCViY7N2/eBAC4ublh3rx5WLZsGQRBUO7/9ttv4evri3379sHDw0NTYRIREWmNbw7dw+WYFJiLDfDjmLYwryMTBpaHVjaNJCcnAwDCw8Px7bffYtq0aYiMjER6ejqOHTuGJk2aIDw8HP369YNMJivxOFKpFBKJROWLiIhI1/zv5lP8fC4GALB8WCs0cjTXcETaRe20Ty6X4/LlywgLC0NCQgJSU1NhY2MDJycntG3bFu3atYO+vnqPuRW24shkMrz55ptYu3atcl+PHj1w7NgxeHt74/bt29i5cyfGjh1b7HGWLl2KxYsXqxUDERFRbXA/IQMf/VbQIzK1a0P09nHRcETap8LJzrlz57Bu3Tr89ddfyMr6d0l4QRBU+gbNzc3Rr18/vPfeewgMDKzQOSwsLJTfv/POO0X2e3h4oF+/fvj9999x/PjxEpOd+fPnY86cOcrXEokE7u51c/ZIIiLSPZJcGab+9zqy8+To1NAOH/RqoumQtFK5k52zZ89i9uzZCA8PhyAI0NPTQ8uWLdGiRQvY2dnB0tIS6enpSE5Oxu3bt3Hnzh3s3LkTu3btgp+fH1auXInXXnutXOdq0KBBsd8XV+bZs2clHkcsFkMsFpf3EomIiGoNhULAB7tv4GFSFlytjLHmTV8Y6Gvl6BSNK1eyM3LkSOzZswcGBgYICQnBhAkT0L17d5UWmFdJJBKcOHECW7ZsweHDhxEUFIThw4djx44dZZ7Pz88PIpEIgiAgKSmp2NaYpKQkAAUtSERERHXNj2ce4OidBBjp62H9mLawM+d/7ktSrhRw7969mDZtGuLi4rB3714MGDCg1EQHACwtLTFo0CD8+eefiIuLw9SpU7F3795yBeXs7IzOnTsDAI4fP15kv0wmw+nTpwEA7dq1K9cxiYiIdMW5qCQsPxIJAFg8oAVau1trNiAtJxJefqa7BLGxsfD09Kz0yWJiYuDl5VWusidOnECPHj1gY2ODgwcPokOHDgCA/Px8zJkzB2vWrIGFhQWioqLg5ORUrmNKJBJYWVkhPT0dlpaWal8HERGRpjxOzcYba84hNVuG4f5u+HZIK52fT6eyn9/lSnY05auvvsJnn30GAwMDtGvXDs7OzggLC0NsbCxMTEywZ88e9OvXr9zHY7JDRES1Wa5MjmE/XsStJ+loWc8Ke6Z2hLGh7i/wWdnPb60eyfTpp5/iyJEjygVBDxw4ALlcjgkTJiAsLKxCiQ4REVFtt2j/37j1JB02poZYP8avTiQ6VUHrp1fs1asXevXqpekwiIiINGrnlTjsvBoPkQhY/aYv3GxMNR1SrVHhlh2FQlHs9oyMDEyZMgX29vYwNzdHr169EBERUdn4iIiI6rwb8Wn4/M+/AQAf9PLGa40dNBxR7VKhZGfhwoUwNDTE5s2bi+wbNGgQNm/ejJSUFGRnZ+P48ePo2rUroqOjqyxYIiKiuiYlKw/v/nodeXIFejZ3wrtdG2o6pFqnQsnO+fPnYWJigmHDhqlsP378OE6ePAkvLy9cv34dycnJmDVrFjIyMrB06dIqDZiIiKiukCsEzNgRjqfpuWhgb4YVw1tDT0+3n7yqDhVKdqKjoxEQEFBkIr/ffvsNIpFIuRq5jY0NVqxYgcaNG+PkyZNVGjAREVFdsfxoJM5FJ8HEUB8/jm0LS2NDTYdUK5VrgHJcXBwAIDExEW3atEF8fDxefmL9/PnzEIlEaN68ubIsAAQEBOC3335TKe/h4VGV8RMREemkw7efY33oAwDAsqGt0MSp9Ml8qWTlmmdHT09POWHRq8VL2l7syUQiyOVydeKsEpxnh4iIaoMHLzIxYO15ZErzMbmzFz7r31zTIWlUjcyzo1AoIJfLIRaL0a9fPygUCuXX+fPnIQgCJk2apLJdoVDgs88+g4WFhfK1JhMdIiKi2iBLmo+p/72OTGk+2nnZYl6fppoOqdar0Jidhg0b4uTJkypdVb/88gtEIhG6detWpPyjR49Qr169ykdJRERUBwiCgI9+u4moxEw4WYqxbpQfDLmSeaVV6Cc4YsQI5OTkoGPHjpg7dy6GDh2KH3/8Eba2thg0aJBKWUEQcPLkSXh7e1dpwERERLrq57Mx+OvWMxjqi/DD6LZwsOBK5lWhQjMof/TRRwgNDcXJkyfx/fffAwCMjIywadMmmJqqzuT4v//9D48fP8Ynn3xSddESERHpiLx8BWKTsxCVkInoxExEJWbg0O3nAIDP+jdH2/o2Go5Qd1Qo2TEyMsLx48dx5MgRREREwNzcHP3790f9+vWLlM3MzMTChQsxYsSIKguWiIiotsnJk+PBi4KEpjCpiUrMxKPkbMgVRR/uGeLnhrEdin6ukvq0etXzqsansYiIqLpk5Mr+SWZUE5vHqTko6ZPWQmyAho7maOxojsZO5mjqbInOjew5ceArKvv5rfULgRIREWmTlKy8f1toEjLx4EUmohIy8VySW2IdG1NDNHa0QCOngsSmkaM5GjtawMlSrJzChaoPkx0iIqIyCIKA/TeeYvnRSMSn5JRYztFCjMZOBYmMssXG0Rx25hxorEnlSnZmzpyJzz//HHZ2dmqf6MWLF/jyyy+xevVqtY9BRERU0+4nZODzP2/j0sMU5bZ61iZo7GSORg4F3U+NHC3QyNEcViZczkEblWvMjoGBAUxNTfHee+9h0qRJaNy4cblPEBkZiZ9//hkbNmxATk4OZDJZpQKuDI7ZISKi8srIlWHV8ShsvhALuUKAsaEe3gtqhImdvWAuZsdITars53e5kp3w8HC8//77uHDhAkQiETp27Ijg4GB07NgRzZo1g52dHczNzZGZmYnk5GTcuXMHFy9exLFjx3DlyhUIgoDAwECsWbMGbdq0Uec6qwSTHSIiKosgCPgz4im+PngXiRlSAECv5k74rH9zuNuallGbqkONJDuFfvvtN3z//fe4ePFimQOqCg/bqVMnzJ49G0OGDKlwcFWNyQ4REZUm8nkGPvvzNq7EFHRZedqZYlFICwR5O2o4srqtRpOdQhEREdi3bx9OnjyJ8PBwZGVlKfeZmZnBz88P3bp1w8CBAzXakvMqJjtERFQcSa4M/zkWha0X/+2ymt6tEd7q0gBiA31Nh1fnaSTZeVV2djbS09NhbW0NExOTyh6u2jDZISKilwmCgH0RT/D1wXt48U+XVe8Wzvi0fzO42bDLSltoxTw7pqamRZaLICIi0mZ3n0mw8M+/cSW2oMvKy94Mi0JaoGsTBw1HRlWNw8mJiKhOkeTK8P2x+/jl4iPIFQJMDPUxvXsjTHnNi11WOorJDhER1QmCIOCPsCdYeugekjILuqz6+Djj0/7NUc9ae4dgUOUx2SEiIp1356kEC/ffxtXYVABAA3szLB7QAq81ZpdVXcBkh4iIdFZ6TmGXVSwUAmBiqI/3gxthcmd2WdUlTHaIiEjnKBQC/gh/gm8O3UVSZh4AoF9LF3zSrxlc2WVV5zDZISIinfL303R8/uffuP7ony4rBzN8EeKDzo3tNRwZaQqTHSIi0gmCIGD50UisD30AhQCYGuljRnBjTAr0gpGBnqbDIw1S6+7/8ssvuHDhQpnlLl26hF9++UWdUxAREVXInuuPse5UQaLTr5ULTsztiqldGzLRIfWSnQkTJuDnn38us9zGjRsxceJEdU5BRERUbtGJGVj4598AgA9f98a6UX5wseLYHCpQreluFaxEQUREVKpcmRzvbQtHjkyOzo3s8W7XhpoOibRMtSY7iYmJXEaCiIiq1Zf/u4PIhAzYmxth5YjW0NMTaTok0jLlHqB85swZldfPnz8vsq1Qfn4+/v77bxw9ehQtW7ZUK7AJEyZg69atpZbJycmBsbGxWscnIqLa76+bz7DtchwA4PsRbeBowc8EKqrcyU5QUBBEon+z5SNHjuDIkSOl1hEEAe+++6760QEIDAxEo0aNit2nr88JoYiI6qr4lGzM++MmAODdoIacDZlKVO5kp0uXLspk5/Tp03B0dETTpk2LLWtkZAQ3NzcMGTIEffv2rVSAU6ZMwYQJEyp1DCIi0i0yuQLv7whHRm4+/DysMadnE02HRFqs3MlOaGio8ns9PT306dMHmzZtqo6YiIiISrX8aCQi4tNgaWyA1W/6wlCfj5dTydSaVPDUqVNwdnau6liIiIjKFBqZiA2nHwIAlg1tBTcbPghDpVMr2enatWtVx1GiU6dO4datW8jIyICdnR3atWuHvn37QiwW11gMRESkHRIluZi7+wYAYGyH+ujt46LhiKg2UCvZiYuLQ0REBPz8/ODm5qbc/vfff2P69OmIiIiAp6cnli1bhp49e1YqwOJmYHZxccGmTZvQu3fvSh2biIhqD7lCwKxdEUjOykNTZwt80q+ZpkOiWkKtTs7ly5dj0KBByMrKUm7LyspCjx49cPr0aaSnp+PGjRsICQlBVFSUWoG1bt0aq1atwu3btyGRSJCQkICjR4+iU6dOePbsGUJCQlTGERVHKpVCIpGofBERUe20PjQaFx4kw8RQH2tH+cHYkE/kUvmoleycOXMGjRs3hre3t3Lb9u3bkZCQgIEDByIiIgJffPEFpFIp1q5dq1Zgs2fPxowZM9CiRQtYWFjA0dERPXv2xLlz5zBgwADIZDLMmjWr1GMsXboUVlZWyi93d3e1YiEiIs26GpuClcfuAwC+HOiDRo7mGo6IahORoMaaDk5OTmjbti0OHjyo3DZkyBDs27cPcXFxqFevHgCgWbNmMDAwwK1bt6ouYgA3btxAmzZtABR0qZWUxEilUkilUuVriUQCd3d3pKenw9LSskpjIiKi6pGWnYc+q87iWXouBvnWw8rhrVXmfSPdJ5FIYGVlpfbnt1otO6mpqbC1tVXZdunSJTRv3lyZ6ABAy5Yt8fjxY3VOUapmzf7tpy3t+GKxGJaWlipfRERUewiCgA/23MSz9Fx42Zvhy4E+THSowtRKdszMzPDixQvl69jYWDx79gyBgYEq5QwMDJCfn1+5CIuRnJys/N7CwqLKj09ERNph64VYHL+bACN9Pax50xfmYrWeq6E6Tq1kp3nz5jh37pwy4dm+fTtEIhFee+01lXLx8fFwcnKqfJSv2LlzJwDA0tJSZdwQERHpjttP0vH1wXsAgAV9m8KnnpWGI6LaSq1kZ/z48cjJyYG/vz8GDRqExYsXw8LCAiEhIcoyubm5CAsLU+lyKq+IiAjs37+/SKuQQqHAxo0bsWDBAgDAjBkzYGhoqM4lEBGRFsuU5uP9HeHIkyvQs7kTxnfy1HRIVIup1R741ltv4dKlS9iyZQvi4+NhYWGBTZs2qXQp7d+/Hzk5OejSpUuFjx8bG4tBgwbBxsYGfn5+cHJyQlpaGm7fvo24uILVbd98800sXLhQnfCJiEiLCYKAz/bdRkxSFlytjPHd0FYcp0OVotbTWIXi4+ORkJCApk2bwtxc9THAiIgIPHr0CB06dKhwV1ZMTAxWr16Na9euISYmBsnJyRAEAU5OTmjXrh0mTpyo1gKjlR3NTURE1W/PtXh8+NtN6OuJsPPtDgjwtC27Eum0yn5+VyrZqW2Y7BARabfoxEy8seYccmRyfNCrCaZ3b6zpkEgLVPbzu0qGtT9//lz5CHi9evXg4sK1SoiIqGJyZXJM3x6GHJkcnRra4d2gRpoOiXSEWgOUC23cuBFNmzZFvXr10L59e7Rv3x5ubm5o1qwZNm3aVFUxEhFRHbDkr7u49zwDdmZG+M+INtDX4zgdqhpqJztvvfUW3n77bdy/fx+CIMDGxgY2NjYQBAGRkZF466238NZbb1VlrEREpKMO3XqG/156BABYMbw1HC2NNRwR6RK1kp09e/Zg48aNsLa2xvLly5GamoqkpCQkJSUhLS0NK1asgI2NDTZt2oTffvutqmMmIiIdEp+SjY9+vwkAeKdrAwR5O2o4ItI1aiU7GzZsgIGBAY4dO4Y5c+bAyurfiZ4sLS0xe/ZsHDt2DPr6+tiwYUOVBUtERLpFJldgxs5wZOTmo427NT7oxYliqeqpleyEh4eja9eu8PPzK7GMr68vunbtirCwMLWDIyIi3bby2H2Ex6XBwtgAa970haF+pYaSEhVLrd+qrKwsODqW3czo6OiIrKwsdU5BREQ67sz9F1gf+gAA8O2QVnC3NdVwRKSr1Ep2nJ2dER4eXma58PDwalkbi4iIarfEjFzM2R0BABjd3gN9W3LKEqo+aiU73bp1Q2RkJL755psSyyxduhSRkZEIDg5WOzgiItI9CoWAObtuICkzD02dLfBZ/+aaDol0nFozKEdGRsLX1xdSqRT+/v4YN24cvLy8AAAPHz7E1q1bERYWBmNjY4SFhWnNyuScQZmISPPWnYrGd0ciYWKojwPvB6KRo0XZlahO08gMyt7e3tizZw9Gjx6Nq1ev4tq1ayr7BUGApaUltm3bpjWJDhERaY4gCIhPycG56CSsPHYfALA4pAUTHaoRai8X0a9fP9y/fx8//fQTTp8+jSdPngAoWC4iKCgIb731VrkGMRMRke6R5MpwMz4dEfGpCI9LQ3h8GlKy8pT7B7RxxTB/Nw1GSHUJFwIlIqJKkSsE3E/IQER8GsLjCpKb6BeZePXTxVBfhOauVghsaIf3ujWCmbhKlmekOkArFgIlIqK6IzEjF+Fxacrk5tbjdGTlyYuUc7c1QRt3G/i6W6ONhzWau1jC2FBfAxFTXVfuZGfevHm4f/8+5s6di8DAwFLLnj9/HitWrECzZs2wZMmSSgdJRESakSuT4++n6cquqIi4NDxJyylSzlxsgFZuVvD1sEYbdxu0cbeGg4VYAxETFVWubqxr166hXbt2CA4OxrFjx8p14F69euHEiRMICwtD69atKx1oVWA3FhFRyQRBwKPkbGWLTUR8Gu48k0AmV/2YEImAJo4W/yQ21vD1sEEjR3OuUk7Vpka6sX799VeIRKIKtdIsXboUAQEB+OWXX7BixYoKB0ZERNUrPUeGm4/TVLqkUrNlRcrZmxsVdEd5WMPX3Rot3axgYWyogYiJ1FOuZOfs2bOoX78+2rVrV+4Dt23bFp6enjh9+rTawRERUdXIlytwPyET4f88HRURn4boxMwi5Yz09dDc1RJ+HjZo809y42ZjApGIrTZUe5Ur2Xn48CG6dOlS4YO3atUKZ86cqXA9IiKqnARJ7j/jbFIREZeGm4/TkSMrOojYw9ZUpTuqmYsFxAYcREy6pVzJTlZWFiwsKj7xk7m5ORcCJSKqZrkyOW4/SVfpjnqanluknIXYAK3dCxObgn/tzDmImHRfuZIda2trJCYmVvjgiYmJsLKyqnA9IiIqWYIkF+ejk/5JbNJw95kE+QrVQcR6IqCJkwV8PQoe/fb1sEZDB3PocRAx1UHlSnYaNmyIy5cvQyaTwdCwfIPS8vLycPnyZTRr1qxSARIR0b8i4tPw5k+XinRJOViIlfPZ+LrboJWbFSftI/pHud4JwcHBuHLlCtatW4dZs2aV68Dr1q1DRkYGevToUZn4iIjoH+nZMry3LQw5MjkaO5qjSxMHZXdUPWsOIiYqSbnm2Xn8+DEaNWoEANi9ezdCQkJKLf/nn39ixIgRAICoqCi4u7tXQaiVx3l2iKi2EgQBb//3Oo7dSUB9O1MceL8zLPn4N9URlf381itPITc3N3zxxRfIy8vDoEGDMHjwYOzbtw9PnjyBTCaDTCbDkydPsG/fPuV+mUyGRYsWaU2iQ0RUm208F4NjdxJgpK+HdaP8mOgQVUCFFgKdN28eli1bVmpTaeHhPvjgAyxbtqzyEVYhtuwQUW0UFpeK4T9eRL5CwJcDfTC2Q31Nh0RUo2qkZafQN998g2PHjqFLly4QiUQQBEHlSyQSoWvXrjh69KjWJTpERLVRWnYe3t8ejnyFgP6tXDCmvYemQyKqdSo8VD84OBjBwcFIT09HWFgYXrx4AQBwcHCAr68vrK2tqzpGIqI6SRAEfLDnBp6k5cDTzhRLB7fkIGQiNaj9XKKVlRW6detWlbEQEdFLfj4bg+N3E2FkoId1o/24HhWRmirUjUVERDXj+qNUfHv4HgBg4RvN0cKVE7QSqYvJDhGRlknNysP728OQrxAQ0toVo9pxnA5RZTDZISLSIgqFgLl7buBpei4a2Jvha47TIao0JjtERFrkp7MPcfJeIsT/jNMx55IPRJVWq5Kdjz76CCKRCCKRCF999ZWmwyEiqlLXYlPw3ZFIAMCikBZo5sL5wIiqQq1Jdi5cuIAVK1awOZeIdFJKVh6mbw+HXCFgYBtXjAzg7PNEVaVWJDvZ2dmYMGECXFxcMGDAAE2HQ0RUpRQKAXN2R+C5JBcNHMywZBDH6RBVJbWSne7du5drhuTly5eje/fu6pxCxfz58xEVFYWffvoJVlZ8/JKIdMuPZx4gNPIFxAZ6+GG0H8w4ToeoSqmV7ISGhuLevXtllouMjMTp06fVOYXKudasWYNx48ahb9++lToWEZG2uRKTghVH7wMAvhjQAk2dOU6HqKpVazeWTCaDnp76p8jMzMSkSZPg5OSE//znP1UXGBGRFkjOlOL9HWGQKwQM9q2H4f4cp0NUHaq1rfTWrVuws7NTu/4HH3yAmJgY7N27FzY2NlUYGRGRZikUAmbvvoEEiRSNHM3x1SAfjtMhqiblTnYmTZqk8vrcuXNFthXKz8/HnTt3EBERgZCQELUCO3r0KDZs2ICRI0di4MCBah1DKpVCKpUqX0skErWOQ0RU1daffoAz91/A2FAP60b5wdSI43SIqku5311btmxRfi8SiRAdHY3o6OhS67i6umLJkiUVDio9PR2TJ0+Gg4MD1qxZU+H6hZYuXYrFixerXZ+IqDpcepiMFUcL5tP5coAPvJ0tNBwRkW4rd7KzefNmAIAgCJg0aRI6d+6MyZMnF1vWyMgIbm5u6NChAwwNK75K76xZs/D48WPs2rUL9vb2Fa5faP78+ZgzZ47ytUQigbs7+8SJSHOSMqWYsSMcCgEY4ueGYRynQ1TtRIIgCBWt5OXlhWHDhpXr8XN1WFtbIysrC4GBgUX23bt3DwkJCfD09ET9+vXh7OyMnTt3luu4EokEVlZWSE9Ph6Uln3ggopolVwiYsPkKzkYlobGjOf6cHsjuK6JyqOznt1rvskWLFsHY2FidquWWn59f6mPrsbGxiI2NRf369as1DiKiqrLuVDTORiXBxFAfP4zmOB2imqLWc+GTJk1SGcNT1dLS0iAIQrFf48ePBwB8+eWXEAQBsbGx1RYHEVFVufAgCf85XjCfzlcDfdDYieN0iGqKWsmOnZ0dbG1tqzoWIiKd9CJDipk7I6AQgOH+bhjS1k3TIRHVKWolO+3bt8fNmzerOhYiIp0jVwiYtSscLzKk8HaywOIQH02HRFTnqJXsfPTRR7h79y42bNhQ1fEQEemUNSejcD46GaZG+lg32g8mRvqaDomozlHraawzZ85g9+7dWL9+PYKDgzFkyBB4enrCxMSk2PJdunSpdKBVgU9jEVFNOh+dhDEbL0MQgO9HtMYgX3ZfEamjsp/faiU7enp6EIlEKKxa2hTnIpEI+fn5FQ6sOjDZIaKakpiRi76rziEpU4qRAe74ZkgrTYdEVGtp5NHzLl26cA0XIqISyBUCZu6IQFKmFE2dLbAopIWmQyKq09RKdkJDQ6s4DCKi2i9BkovwuFQcvPUcFx/+O07H2JDjdIg0iTNaERGpIVcmx60n6YiIS0N4fCrC49LwLD1XpczSwS3R0MFcQxESUSEmO0REZRAEATFJWYiIT0P4P8nNvWcZyFeoDnnUEwHezpZo426Nns0d0b2pk4YiJqKXVSrZuXv3LlatWoVTp07hyZMnAIB69eqhe/fumDFjBpo1a1YlQRIR1aT0bBkiHqchPK6gxebG4zSkZcuKlHOwEMPX3Rq+HjZo426NVm5WMBPz/5BE2katp7EAYMuWLZg6dSpkMhmKO4SRkRE2bNigXN5BG/BpLCJ6lUyuQOTzDITHFyQ3EfFpePgiq0g5IwM9tKxnBV93a7TxKEhwXK2M+bAGUQ3QyKPn169fR4cOHSCXy9G/f39MnjwZDRs2BAA8fPgQGzduxIEDB2BgYIALFy7A39+/woFVByY7RJSWnYersam4FpuC8Lg03HyShlyZokg5TztTZYuNr4c1mjpbwshArXlYiaiSNPLo+XfffQeFQoGNGzdi4sSJKvt8fHwQEhKCLVu2YNKkSVixYgV27NihzmmIiCotOVOKKzEpuByTgksPkxGZkIFX/4tnYWxQkNT80yXV2t0atmZGmgmYiKqcWi079erVg7OzM65fv15qOX9/fzx79kw5nkfT2LJDpPsSM3Jx+WEKLsck4/LDFEQlZhYp08DBDO29bOHnYQNfD2s0sDeHnh67o4i0lUZadpKSktCtW7cyyzVt2hS3bt1S5xREROXyNC0Hl2OSC1pvHqbgYVLR8TbeThZo52WL9g1s0c7LFo4WxhqIlIg0Ra1kx9raGnFxcWWWi4uLg5WVlTqnICIqQhAEPE7NwaWHybgcU9B6E5+So1JGJAKaOVuifQNbtPeyQzsvW3ZJEdVxaiU7AQEBOHz4ME6ePInu3bsXW+bkyZM4f/48+vbtW6kAiajuEgQBscnZuFyY3DxMxtNXJu7T1xPBx9US7RvYoZ2nLQI8bWFlaqihiIlIG6mV7Lz//vs4ePAg3njjDbz33nsYP348vLy8ABQ8jbVlyxasX79eWZaIqCJSsvKw9OBdnL7/AokZUpV9BnoitHKzQvsGdmjvZQt/T1uYc24bIiqF2vPsfPbZZ1iyZEmJc0wIgoDPPvsMixcvrlSAVYkDlIm0n1whYPymKzgXnQQAMNLXQxt3a2W3lF99a5gaMbkhqks0MkAZAL788ksEBgZi+fLluHDhAnJzC5qWxWIxOnfujLlz56J3797qHp6I6qh1p6JxLjoJJob6+GG0Hzo2tONCmkRUKWq37LxMLpcjOTkZAGBnZwd9fe38w8SWHSLtduFBEsb8fBkKAVg+rDWGtnXTdEhEpAU01rLzMn19fTg6OlbFoYiojnqRIcXMnRFQCMCwtm5MdIioylQ62cnLy0NYWBgeP34MQRDg5uaGtm3bwsiIj3oSUfnIFQJm7gzHiwwpmjiZ44sBPpoOiYh0iNrJTl5eHhYvXowffvgBEolEZZ+FhQXeffddLFq0CGKxuNJBEpFuW3MyChceJMPUqGCcjomRdnaFE1HtpFayk5ubi169euH8+fMQBAF2dnbw9PQEAMTGxiI5ORnLli3DuXPncOzYMRgbc7ZSIire+egkrDoRBQBYMsgHjRwtNBwREekatZbw/fbbb3Hu3Dk0btwYBw4cwIsXL3D16lVcvXoVL168wP/+9z80adIEFy5cwLJly6o6ZiLSEYkZuZi5MwKCAIzwd8cgX47TIaKqp9bTWN7e3nj27Bnu3bsHV1fXYss8ffoU3t7ecHV1RWRkZKUDrQp8GotIe8gVAsb8fBkXHyajqbMF9r0XyEfMiahYlf38VqtlJy4uDt26dSsx0QEAV1dXdO/evVxraBFR3bPqRBQuPiwYp7N2lB8THSKqNmolOzY2NjAxMSmznLGxMWxsbNQ5BRHpsLNRL7DmZME4na8HtUQjR3MNR0REukytZKdHjx44c+YMpFJpiWVyc3Nx9uzZEhcKJaK6KUGSi1n/jNN5s507BvrW03RIRKTj1Ep2vvrqK8hkMowaNQqJiYlF9iclJWHMmDGQyWRYsmRJpYMkIt2QL1dgxo5wJGfloamzBRa+0ULTIRFRHaDWo+dbtmxBv3798Msvv+DIkSPo1auXctXzmJgYHD16FDk5ORg3bhy2bt2qUlckEuGzzz6rfOREVOusOhGFyzEpMPtnPh2O0yGimqDW01h6enoQiUQoq+rLZQq/F4lEkMvl6kVbSXwai0hzztx/gfGbr0AQgNVv+iKkdckPOBARvUwja2N9/vnnEIlE6lQlojroeXouZu0qGKczur0HEx0iqlFqJTuLFi2q4jCISFcVjtNJycpDcxdLfNa/uaZDIqI6Rq0BykRE5fX98fu4EpsCc7EB1nGcDhFpgFrJzsWLF8tdds2aNeqcAtu2bcO4cePQunVrODo6wtDQEFZWVmjXrh2WLl2KzMxMtY5LRDUnNDIR6049AAB8M6QlvOzNNBwREdVFaiU7QUFBWLlyZallJBIJhgwZglmzZqlzCqxfvx6//vor8vPz4efnh2HDhsHf3x+3b9/GggUL4Ovri6dPn6p1bCKqfs/SczBn9w0AwNgO9dG/FcfpEJFmqDVmR19fHx9++CHOnDmDLVu2wNraWmV/WFgYhg8fjocPH6JBgwZqBbZixQo0btwYtra2KtuTk5MxcOBAnDt3DnPnzsWOHTvUOj4RVZ+Xx+m0cLXEJ/2aaTokIqrD1GrZuXTpEho1aoT9+/fDz88P165dU+5bu3YtAgMD8fDhQwwdOhRhYWFqBda+ffsiiQ4A2NnZ4euvvwYAHD16VK1jE1H1WnHsPq7GpsJCbMD5dIhI49RKdlq1aoXr169jxIgRiI2NRefOnbF8+XIMGzYMM2bMAFCQ9Ozevbta5rMxMChokBKLxVV+bCKqnFP3ErE+tGCczrdDW6G+HcfpEJFmqdWNBQDm5ubYsWMHunTpgjlz5uDjjz8GADRq1Ai7du2Cr69vlQX5soyMDOWj7yEhIdVyDiJSz9O0HMzeHQEAGN+xPvq2dNFsQEREqESyU6hwcsHC2ZHd3NxQr17VLex39OhRbN++HQqFAgkJCbh48SIyMjLQu3dvfPvtt1V2HiKqHJlcgfd3hCMtW4aW9aywgON0iEhLqJ3sZGVl4e2338bOnTthaGiIJUuWYM+ePQgNDYWvry+2bduGoKCgSgd4586dIutrjRo1CitXroSVlVWpdaVSqcrK7BKJpNLxEFHxlh+JxPVHqbAwNsC6UX4QG3CcDhFpB7XG7Ny8eRNt27bFjh074OnpifPnz2P+/Pm4ePEi3n77bTx79gw9e/bEl19+WekAZ82aBUEQkJeXh+joaKxYsQKHDh1C8+bNcebMmVLrLl26FFZWVsovd3f3SsdDREWduJuADWceAgC+G9oKHnamGo6IiOhfai0EampqitzcXAwcOBCbN28u0sKyY8cOvPPOO8jKykJwcHCVPzV1+fJldOzYEW5uboiMjISJiUmx5Ypr2XF3d+dCoERV6ElaDvqtPou0bBkmdPLEopAWmg6JiHRMZRcCVatlRy6XY+XKlfjjjz+K7Up68803cfXqVbRo0QInTpxQ5xSlat++PZo3b474+HiVx95fJRaLYWlpqfJFRFVHJldg+vYwpGXL0NrNCgv6cpwOEWkftcbsnDlzBu3bty+1jLe3N65cuYL3339frcDKYmZW8DhrYmJitRyfiMq27PA9hMelwdLYAGtH+cHIgMvtEZH2UesvU1mJTiFjY2P83//9nzqnKFVSUhJu3CiYhr5JkyZVfnwiKtuxOwn4v7MxAIDvhrWGuy3H6RCRdtLK/4bduXMH27ZtQ25ubpF99+/fx7BhwyCVStGhQwe0bNlSAxES1V2Z0nysOh6FmTvDAQCTAr3wegtnDUdFRFSycnVjde/eHb1798ZHH31UZN/q1avRvHlz9OjRo8i+9957Dzt37kRycnKFgkpMTMSYMWPwzjvvwNfXF25ubsjLy0NcXBzCwsKgUCjQrFkz7Nq1q0LHJSL1SfPl2H45DmtPRiM5Kw8A0KmhHeb1aarhyIiISleuZCc0NBSenp7F7ps1axYmTJhQbLKTnZ2NtLS0CgfVokULLFmyBGfPnsW9e/cQHh4OmUwGW1tbBAcHY/DgwZg4cSKXiyCqAXKFgL3hT/D9sft4kpYDAPCyN8PcXk3Q18cFenoiDUdIRFS6Ss+gXB0cHBywYMECTYdBVKcJgoBjdxKw/Ggk7idkAgCcLMWY1aMJhrZ1g6G+VvaCExEVoZXJDhFp1sUHyVh2pOBJKwCwMjHEtKCGGN/JkyuYE1Gtw2SHiJRuP0nHsiOROHP/BQDAxFAfkzp74u0uDWFlYqjh6IiI1MNkh4gQk5SFFUcj8b+bzwAABnoijGrvgendG8HRwljD0RERVQ6THaI67Hl6LladiMLua/GQKwSIRMCA1q6Y09Ob61sRkc5gskNUB6Vl52H96QfYcj4W0nwFACC4qSM+eN0bzVy4rAoR6ZZyJzuHDx9G9+7dK7Tv7t276kdGRFUuOy8fm8/H4sfTD5CRmw8ACPC0wUe9myLA01bD0RERVY9yJzvPnz/H8+fPK7xPJOIcHESalpevwK6rcVh1IhpJmVIAQFNnC3zcuymCvB34PiUinVauZGfhwoXVHQcRVQOFQsD+G0+x8th9xKVkAwA8bE0xt1cTvNHKlRMCElGdIBIEQdB0EDVFIpHAysoK6enpsLTkuATSTQqFgIdJmbgSk4pfLsbi3vMMAICDhRgzujfCiAAPrk5ORLVKZT+/OUCZqJbLlclx60k6rsam4HpsKq7HpSItW6bcb2FsgKldG2JioCdMjfiWJ6K6h3/5iGqZ5Ewprj9KxbVHqbgWm4LbTyTIkytUyhgb6qGNuzU6NbTHuI71YW1qpKFoiYg0j8kOkRYTBAEPk7JwPTa1oOXmUSoeJmUVKedgIYZ/fRu0rW8Df09btHC15NpVRET/YLJDpEWk+XLcfpKOa7GpuBqbirC4VKRk5RUp18TJHG3r28K/vg38PW3gYWvKJ6qIiErAZIdIg1Kz8lS6pG4+SUdevmqXlNhAD63drZWJjZ+HDbuliIgqgMkOkYb8cjEWiw/cgVyh+kCkvblRQXdUfVu09bSBj6sVn54iIqoEJjtEGnAtNkWZ6DR0MEOAp61yvI2nHbukiIiqEpMdohqWkpWH93eEQ64QMKCNK/4zog2TGyKiasS2caIapFAImLM7As/Sc9HA3gxLBrVkokNEVM3K1bITFxdXqZN4eHhUqj6RrvjxzAOERr6A2EAP60b7wVzMxlUioupWrr+0np6eav/vUyQSIT8/X626RLrkSkwKVhy9DwBYHNICzVy4ZAkRUU0oV7Lj4eHBpnaiSkjOlOL9HWGQKwQM8q2HEQHumg6JiKjOKFeyExsbW81hEOkuhULA7N03kCCRoqGDGb4a6MP/PBAR1SAOUCaqZutPP8CZ+y9gbKiHH0a3hRnH6RAR1SgmO0TV6PLDZKw4GgkA+CLEB97OFhqOiIio7mGyQ1RNkjKleH9HOBQCMNivHob5u2k6JCKiOkntZEcmk2HFihXo0KEDbGxsoK+vX+yXgQGb7KnukSsEzN4VgcQMKRo5mnOcDhGRBqmViUilUgQHB+PixYsQBKHUsmXtJ9JFP5yKxtmoJJgY6uOH0X4wNWLST0SkKWq17KxatQoXLlxAr169EBkZiXHjxkEkEkEqleL27dv4+OOPIRaL8dlnn0GhUJR9QCIdcuFBEr4/XjCfzpcDfdDEieN0iIg0Sa3/bu7ZswcWFhbYuXMnrKyslM3zhoaGaN68OZYuXYpOnTph4MCBaNmyJYYOHVqlQRNpqxcZUszcGQGFAAxt64ahbTlOh4hI09Rq2bl//z7at28PKysrAFAmO3K5XFnmjTfegK+vL9asWVMFYRJpP7lCwKxd4XiRIUUTJ3N8OcBH0yERERHUTHZkMhkcHByUr01MTAAAEolEpZy3tzdu3bpVifCIao+1J6NxPjoZJob6WDfKDyZG+poOiYiIoGay4+zsjGfPnilfu7i4AADu3r2rUu7p06cqrT1EuupCdBL+c6JgnM5XA33QmON0iIi0hlrJTrNmzRAdHa183alTJwiCgGXLlikHJJ8+fRpnz56Ft7d3hY8vk8lw4sQJfPjhhwgICIC1tTUMDQ3h7OyMkJAQ/PXXX+qETVQtEjNyMWNnBAQBGO7vhiEcp0NEpFXUGqD8+uuv49ChQ7hy5QratWuHoKAgNG/eHAcOHEC9evXg6uqKW7duQRAETJs2rcLHP336NHr27AmgoBWpc+fOMDMzw507d3DgwAEcOHAAb7/9Nn788UfOXUIaJVcImLkjAkmZUng7WWBxCMfpEBFpG7WSnVGjRsHOzk45QFlPTw/79u3DkCFDcOvWLSQkJEBfXx8zZszAhAkTKnx8PT09DBkyBDNnzsRrr72msm/Xrl0YPXo0fvrpJwQGBmLcuHHqXAJRlVh1IgoXHybD1Egf60ZznA4RkTYSCVU8619kZCRSUlLQpEkT2NnZVeWhlaZMmYKNGzciODgYx48fL3c9iUQCKysrpKenw9LSslpio7rjXFQSxm66DEEA/jOiDQb61tN0SEREOqmyn99VPq2rOmN0KsrX1xcAEB8fX+3nIipOoiQXs3aFQxCAkQHuTHSIiLSYWgOUGzRogI8//rjMcvPnz0fDhg3VOUWpoqKiAPz7FBhRTcqXK/D+jnAkZeahqbMFFoW00HRIRERUCrWSndjYWLx48aLMcklJSYiNjVXnFCV6/vw5tmzZAgAYMmRIlR6bqDxWnYjC5ZgUmP0zTsfYkON0iIi0WbWuTpibm1ulq57n5+djzJgxSE9PR8uWLfHOO++UWl4qlUIqlSpfvzrpIVFFnbn/AmtPFUy78PXglmjoYK7hiIiIqCxqteyUh1wux7Vr11RmWq6sqVOn4sSJE7Czs8Nvv/0GIyOjUssvXboUVlZWyi93d/cqi4XqnufpuZi1q2A+nVHtPTCgDcfpEBHVBuV+Gqt79+7K70NDQ+Hs7IymTZsWWzY/Px9RUVFITEzEqFGj8N///rfSgc6cOROrV6+GjY0NTpw4oRykXJriWnbc3d35NBZVWL5cgVH/dxlXYlPQzMUSe6d1YvcVEVENqbGnsUJDQ5Xfi0QiPH/+HM+fPy+1jr+/P5YuXVrhoF41d+5crF69GtbW1jh69Gi5Eh0AEIvFEIvFlT4/0ffH7+NKbME4nR84ToeIqFYpd7Jz6tQpAIAgCOjevTt69+5d4hNZRkZGcHNzq5Juo48++ggrV66ElZUVjh49Cn9//0ofk6giQiMTse7UAwDAN0NawcveTMMRERFRRZQ72enatavK90FBQSrbqsO8efPw3XffwcrKCseOHUNAQEC1no/oVc/SczBn9w0AwJgOHnijtauGIyIioopS61Gpwlae6vTpp5/i22+/VXZdMdGhmiTNl+PW43QsPXQPKVl5aOFqiU/7Ndd0WEREpIZKPxeel5eH69ev48mTJwCAevXqoW3btmU+KVWa/fv3Y8mSJQCARo0aYd26dcWWs7e3x/Lly9U+D1GhlKw8XH+UimuPUnA9NhU3n6QjL18BADAXG2DdKI7TISKqrdROdvLz87F48WKsWbMGGRkZKvssLCwwY8YMfP7552rNs5OSkqL8/tq1a7h27Vqx5erXr89khypMEATEJmfjamxBYnPtUQoevMgqUs7OzAht69vgna4N4clxOkREtZZaC4EqFAr0798fR44cgSAIsLGxgZeXFwAgJiYGqampEIlE6N27Nw4cOAA9vWqbzqdCuBBo3ZSXr8Dtp+m4FpuCa7GpuP4oFclZeUXKNXQwQ4CnLdrWt4G/py087UwhEok0EDEREb1MIwuB/vzzzzh8+DA8PT2xfPlyDB48WGX/3r17MXfuXBw+fBgbN27EW2+9pc5piNSSlp2HsLhUXI1NxfXYVNx4nAbpP11ShYwM9NCqnhX8PW3hX98GbevbwMZM/a5XIiLSXmq17HTu3Bnh4eH4+++/4enpWWyZmJgYtGjRAn5+fjh37lxl46wSbNnRPYIgIC4lG9f+6Y66FpuKqMTMIuVsTA2ViY2/pw186llBbMAxOEREtYFGWnZu376NoKCgEhMdAPDy8kL37t21JtEh3ZApzcfN+DSEx6chPC4NEfGpSMos2iXVwN4M/p428K9vi7aeNmhgb8YuKSKiOkqtZEcqlcLKyqrMchYWFirLNRBVhFwhIDoxE+FxqYj4J7m5n5iBV9sijfT14FPPUjnepm19G9iZc+ZsIiIqoFay4+7ujosXL0Iul0Nfv/iuALlcjkuXLsHNza1SAVLd8SJDioj4gtaa8Lg03HycjkxpfpFy9axN4OthjTbu1vD1sEELV0s+Fk5ERCVSK9l5/fXX8cMPP2DmzJn4/vvvYWhoqLI/Ly8Ps2fPRlxcHN57770qCZR0izRfjr+fShARV9AlFRGfiviUnCLlTI300drNGm08rOHrXvCvo4WxBiImIqLaqlwDlAvXwvroo48AAE+ePEGrVq2QlpYGV1dXjBw5Uvno+cOHD7Fr1y48ffoUtra2iIiIQL169ar3KsqJA5Q1QxAEPE7NQVhc6j/jbNJw56kEeXLVJ6REIqCxo7myxaaNuzWaOFlAX49jbYiI6rIaGaAcGhqqMhi5Xr16OHz4MIYNG4a4uDisXLlSpbwgCPDw8MBvv/2mNYkOacZ/Lz3CquP3ix1EbGdm9E9iY4027jZo5W4FS2PDYo5CRESkPrVnUA4ICMD9+/exZ88ehIaGqiwXERQUhGHDhlVqyQiq/c5GvcDnf96GIACG+iI0d7WC7z/Jja+7DdxtTfiEFBERVbtKrY1lZGSE0aNHY/To0VUVD+mIBEkuZu2MgCAAIwPcsSikBQcRExGRRmjHOg6kU/LlCszYEY7krDw0c7FkokNERBrFZIeq3H+OR+FyTArMjPSxbpQvEx0iItKocic7W7duhb6+foW/1Fn1nGqv0/dfYF1oNADgmyGt0MDBXMMRERFRXVfuTESNJbSojnmenovZuwrG6Yzp4IE3WrtqOiQiIqLyJzu9e/fGxx9/XJ2xUC1WOE4nJSsPLVwt8Wm/5poOiYiICEAFkh1nZ2d07dq1OmOhWmzlsfu4EpsCc7EB1o3y4zgdIiLSGhygTJV2KjIRP4Q+AAB8O6QVPO3NNBwRERHRv5jsUKU8S8/BnF0RAIBxHeujXysXzQZERET0CiY7pDaZXIH3t4cjNVsGn3qW+KRfM02HREREVASTHVLb8qORuPYoFRb/jNMRG3CcDhERaZ9yDVBWKBRlF6I65eS9BGw4/RAAsGxoK9S34zgdIiLSTmzZoQp7kpaDObtvAAAmdPJEn5Ycp0NERNqLyQ5VSME4nTCkZcvQys0K8/s21XRIREREpWKyQxXy3ZFIhMWlwcLYAGvf5DgdIiLSfkx2qNyO30nAT2cKxul8N7Q1POxMNRwRERFR2ZjsULk8Ts3G3D0F43QmBnqit4+zhiMiIiIqHyY7VKa8fAWmbw9Heo4Mrd2sML8P59MhIqLag8kOlWnZ4XuIiE+DpbEB1o7yg5EBf22IiKj24KcWlero38/x87kYAMB3w1rD3ZbjdIiIqHZhskMlik/Jxgf/jNOZ3NkLr7fgOB0iIqp9mOxQsfLyFZi+IxyS3Hy0cbfGx705nw4REdVOTHaoWN8cuocb8WmwMjHE2lG+HKdDRES1ltZ+gkVGRmLNmjWYMGECWrZsCQMDA4hEInz11VeaDk3nHb79HJvOF4zTWTGsNdxsOE6HiIhqr3ItBKoJ69evx6pVqzQdRp0Tl5yND38rGKfz1mte6NHcScMRERERVY7Wtuz4+Pjggw8+wLZt23D37l2MHTtW0yHpPGm+HNN3hCEjNx++Htb4iON0iIhIB2hty86UKVNUXuvpaW1epjOWHryHm4/TYW1qiLWj/GCoz585ERHVfvw0IwDAoVvPsOVCLICCcTr1rE00GxAREVEVYbJDeJSchY9+uwkAeKdLAwQ34zgdIiLSHUx26rjkTCne2x6GDGk+2ta3wQeve2s6JCIioiqltWN2qoJUKoVUKlW+lkgkGoxG8wRBwMOkLFyLTcG12FRcf5SKh0lZAAAbU0OsedOX43SIiEjn6HSys3TpUixevFjTYWiMNF+O20/ScTU2FddiUxEWl4qUrLwi5bydLPDFgBZw5TgdIqoiMpkMcrlc02GQltHX14ehoWGNn1enk5358+djzpw5ytcSiQTu7u4ajKh6pWbl4fqjVFx9lILrsam4+SQdefkKlTJiAz20drNGW08bBHjawM/DBtamRhqKmIh0jUQiQVJSkkqrOtHLxGIx7O3tYWlpWWPn1OlkRywWQywWazqMaiEIAmKTs3EtNqUgwYlNwYMXWUXK2ZkZoW19G/h72sDf0xY+rlZc+oGIqoVEIsGTJ09gbm4Oe3t7GBoaQiQSaTos0hKCIEAmkyE9PR1PnjwBgBpLeHQ62dElefkK3H6ajuuxqbj2qCDBScos2iXV0MEM/vVt/2m5sYWnnSn/2BBRjUhKSoK5uTnc3Nz4d4eKZWJiAgsLCzx+/BhJSUlMduq65+m5iIhPRXhcGsLj0nDjcRqkr3RJGenroZWbVUFiU98WfvVtYGvGLikiqnkymQxSqRT29vZMdKhUIpEIVlZWePLkCWQyWY2M4WGyowVy8uS4/TQd4XEFyU1EfBqepecWKWdjaoi29W3h/894G596VhAb6GsgYiIiVYWDkTUx+JRqn8LfE7lcXreTnbCwMEybNk35+sGDBwCADRs24H//+59y+969e+Hi4lLj8alLoRAQk5yFiLg0hMenIiI+DXefZUCuEFTK6YkAb2dL+HpYw9fdGr4eNmjoYMb/MRGRVuPfKCqPmv490dpkRyKR4PLly0W2P378GI8fP1a+1vYR/2nZeYiIL+iKCo9Pw434NKTnyIqUc7QQFyQ2HjZo426NlvWsYCbW2ttDRERUa2jtp2lQUBAEQSi7oBaRyRWIfJ6h0h1VOGnfy8QGemhZzwpt/mmx8fWwhouVMf9HREREVA20NtmpLTJyZVh9IgoR8Wm4+Ti9yCBiAPCyN/snsbGGr7sNmrpYcKZiIiKiGsJP3EoyMdTHr5ficDU2FdJ8BSyNDfBaY3vMCG6MzRMCEPZZT5z6IAjfj2iDcR090dLNiokOEVEd5enpCZFIhC1btpRaLigoCCKRCIsWLUJGRgbMzc0hEolw+PDhcp2nTZs2EIlEWLZsWZF9f/zxB0QiEUQiEebOnVvu2OPj4/Hpp5+iQ4cOcHBwgKGhIaytreHn54eZM2fi6tWr5T5WTWPLTiUZ6Othds/GsDE1gq+HDRrYm0FPj91RRERUNSwsLDBs2DBs2bIFmzZtQu/evUstf/36ddy4cQMGBgYYN25ckf0bN25Ufv/rr7/im2++KfOJqGXLluGzzz5DXl4ezM3N0b59ezg6OiIjIwO3bt3C6tWrsXr1anz44YfFJliaxiaGKvB2l4YY5u+ORo7mTHSIiKjKTZ48GQCwf/9+pKSklFp206ZNAIB+/frB2dlZZd+TJ09w5MgR6Ovrw9nZGYmJiThw4ECpx5s3bx4+/vhjCIKA5cuXIykpCcePH8f27dtx4MABxMbG4uLFi+jevTvu379fiausPkx2iIiItFznzp3h7e0NqVSKbdu2lVhOKpVix44dAIBJkyYV2b9lyxbI5XL06tULU6dOBaDa0vOqEydO4NtvvwUA7Nq1C3Pnzi12GaYOHTrg+PHjFeoWq0lMdoiIiGqBwtadwpab4uzduxepqalwdnZG3759VfYJgqCsO3nyZEycOBF6eno4cuSIcq2qV3311VcAgJCQEAwaNKjU+EQiEV577bVyX09NYrJDRERUC4wbNw4GBgaIiIhAeHh4sWUKk5nx48fDwEB1WO6pU6fw8OFD2NvbIyQkBB4eHggODoZcLsfWrVuLHCstLQ1nzpxRHq82Y7JDRETVShAEZOfl19ovbZnzzcnJCf379wcAbN68ucj++Ph4nDhxAkDxXViF3VVjxoxRDkguLLdp06Yi1xkWFgaFomA6lYCAgCq6Cs3g01hERFStcmRyNP/8iKbDUNudL16HqVHVflxOnDgREydOrHC9yZMnY9++fdi+fTuWL18OI6N/F3/esmULFAoFOnfujCZNmqjUS0tLwx9//KE8RqFBgwbB1tYWDx48wOnTpxEUFKTc9+LFC+X3jo6OFY5VmzDZISIiqmGBgYFo1KhRifsPHz6MhISEItv79OkDV1dXPH36FPv27cPw4cMBFLSeFc7d83IyU+jXX39Fbm4uAgIC4OPjo9wuFosxatQorF27Fhs3blRJdnQJkx0iIqpWJob6uPPF65oOQ20mhvpVfswpU6ZgwoQJJe4PCgoqNtnR19fHhAkT8PXXX2PTpk3KZCc0NBQPHz5UzsnzqsIurOK6tyZNmoS1a9fi999/x9q1a2FlZQUAcHBwUJZJTEyEu7t7ha5RmzDZISKiaiUSiaq8G6gumzRpEpYuXYpjx47h8ePHcHNzU47hGTlyJMzMzFTKh4WFISIiAgDw008/4ddffy1yTD09PeTk5GDHjh3KR9J9fX2hp6cHhUKBq1ev1upkhwOUiYiIapGGDRuia9euUCgU2Lp1KyQSCX7//XcApQ9MBoDw8HCcP3++yFfhQOSXy9rY2CgfJS/uaa3ahMkOERFRLTNlyhQABYOSd+7ciezsbDRv3hwdOnRQKZeTk4Pt27cDAA4dOgRBEIr9Sk1NhVgsxrVr13Dz5k1l/U8++QRAwczNe/fuLTUmQRBw7ty5qrzMKsNkh4iIqJYZMmQIrK2tER0djU8//RRA8QOTf//9d6SlpcHFxQU9e/Ys8XjW1tZ44403AKhOWtizZ0/lrMgjR47EypUrIZVKi9S/fv06Xn/9dSxfvrxS11VdmOwQERHVMsbGxhg1ahSAgkfEDQ0NMXbs2CLlXp5bR1+/9IHWhYuG/vrrr8jLy1NuX758OZYsWQJBEDB37lw4ODigZ8+eGD16NAYMGAAvLy/4+/vj2LFjaNq0aVVdYpViskNERFQLvdyS88Ybb6g8PQVAOXcOUL4ZkPv06QMHBwckJydj3759KvsWLFiAqKgozJ8/H02bNkV4eDh2796N06dPw8bGBjNnzkRYWBi++eabyl9YNRAJ2jI1ZA2QSCSwsrJCeno6LC0tNR0OEZHOyM3NRUxMDLy8vGBsbKzpcEjLVfT3pbKf32zZISIiIp3GZIeIiIh0GpMdIiIi0mlMdoiIiEinMdkhIiIincZkh4iIiHQakx0iIiLSaUx2iIioytShqduoEmr694TJDhERVZqeXsHHiVwu13AkVBsU/p4U/t5UNyY7RERUaYaGhtDX10dOTo6mQ6FaICcnB/r6+jA0NKyR8zHZISKiShOJRDA1NUV6ejpbd6hUcrkc6enpMDU1hUgkqpFzGtTIWYiISOc5OjoiNjYWjx49gq2tLcRicY19mJH2EwQBUqkUKSkpUCgUcHR0rLFzM9khIqIqYWRkBDc3NyQlJeHZs2eaDoe0lJmZGZydnWFkZFRj52SyQ0REVcbU1BQeHh7Iz89Hfn6+psMhLWNgYAADg5pPPZjsEBFRldPUhxpRcbR+gPKePXsQFBQEGxsbmJmZoXXr1li2bBlkMpmmQyMiIqJaQKuTnVmzZmH48OE4f/482rVrh969eyMuLg4ff/wxunfvzkcciYiIqExam+zs27cPq1atgrm5OS5fvowjR47g999/R1RUFFq2bIlz587hs88+03SYREREpOW0Ntn5+uuvAQDz5s2Dn5+fcru9vT1++OEHAMDatWuRnp6ukfiIiIiodtDKZOfJkye4evUqAGDUqFFF9nfu3Bnu7u6QSqU4ePBgTYdHREREtYhWJjvh4eEAAFtbW3h5eRVbxt/fX6UsERERUXG0MtmJiYkBAHh4eJRYxt3dXaUsERERUXG0chKEjIwMAAWzLJbE3NwcACCRSEosI5VKIZVKla8Lx/eUVoeIiIi0S+HntiAIatXXymSnqixduhSLFy8usr2wVYiIiIhqj4yMDFhZWVW4nlYmOxYWFgCArKysEstkZmYCACwtLUssM3/+fMyZM0f5WqFQICUlBXZ2dlycTkdIJBK4u7sjPj6+1N8Fqn14b3UT76vuqs57KwgCMjIy4OrqqlZ9rUx2PD09AQDx8fEllincV1i2OGKxGGKxWGWbtbV1ZcMjLWRpack/nDqK91Y38b7qruq6t+q06BTSygHKvr6+AIDk5OQSByBfu3YNAFTm4CEiIiJ6lVYmO25ubggICAAAbN++vcj+c+fOIT4+HmKxGH379q3p8IiIiKgW0cpkBwAWLFgAAPjmm28QFham3J6cnIxp06YBAKZPn16pZi2q/cRiMRYuXFiku5JqP95b3cT7qru0+d6KBHWf46oBM2fOxOrVq2FoaIjg4GCYmZnhxIkTSEtLQ2BgII4dOwYTExNNh0lERERaTKuTHQDYvXs31q1bh4iICMhkMjRs2BBjxozB7NmzYWRkpOnwiIiISMtpfbJDREREVBlaO2aHdNuECRMgEolK/crNzS227vXr1zFs2DA4OTnB2NgYXl5eeP/995GYmFjqORMSEjB9+nR4eXlBLBbDyckJw4YNUxkTRuUTGRmJNWvWYMKECWjZsiUMDAwgEonw1VdflVn3+PHj6Nu3L+zt7WFiYoKmTZvik08+Uc6dVZLo6GhMmDABbm5uEIvFcHNzw4QJE/Dw4cNS62VkZGDBggXw9vaGiYkJ7O3t0a9fP5w8ebJC11wXqHNfFy1aVOZ7+d69eyXW532tfjKZDCdOnMCHH36IgIAAWFtbw9DQEM7OzggJCcFff/1Van2deM8KRBowfvx4AYAQGBgojB8/vtivvLy8IvX27NkjGBgYCACEgIAAYfjw4UKDBg0EAIKTk5MQFRVV7PkiIyMFR0dHAYDQoEEDYfjw4UJAQIAAQDAwMBD++OOP6r5knTJz5kwBQJGvL7/8stR6K1euFAAIIpFI6NKlizBs2DDB2dlZACB4e3sLL168KLbeuXPnBFNTUwGA0KJFC2HEiBFCixYtBACCmZmZcPHixWLrJSQkCE2aNBEACC4uLsKwYcOELl26CCKRSBCJRMLq1asr/bPQJerc14ULFwoAhNatW5f4Xn769GmxdXlfa8axY8eU99LZ2Vno16+fMHz4cMHHx0e5/e233xYUCkWRurrynmWyQxpRmOxs3ry53HWePHmifPNs2LBBuT0/P18YM2aMMgF69Q2rUCgEX19fAYAwduxYIT8/X7lvw4YNAgDB3NxcePbsWaWvq674v//7P+GDDz4Qtm3bJty9e1cYO3ZsmR+KYWFhgkgkEvT19YWDBw8qt2dlZQnBwcECAGHIkCFF6mVlZQmurq4CAGH+/Pkq++bPny8AENzd3YXs7OwidQcMGCAAEIKDg4WsrCzl9r/++kvQ19cX9PT0hBs3bqjzI9BJ6tzXwmRn4cKFFToX72vNOXHihDBkyBDhzJkzRfbt3LlT0NfXFwAIW7duVdmnS+9ZJjukEeokOx9++KEAQOjRo0eRfRkZGYKVlZUAQDh8+LDKvr/++ksAIFhbWwsZGRlF6ha+aefNm1fh66AChfeztA/FYcOGCQCEKVOmFNkXGxsr6OnpCQCEu3fvquxbt26dAEBo0qSJIJfLVfbJ5XLl/wJ//PFHlX1///23AEDQ19cXYmNji5xz8uTJAgBh5MiRFbnUOqU891XdZIf3VXsU/syCg4NVtuvSe5ZjdqjW2Lt3LwBg1KhRRfaZm5sjJCQEAPDHH38UWy8kJATm5uZF6hYe79V6VHXy8vKU4wKKu3/169dHYGAggH/vV6HC1yNHjoSenuqfLD09PYwYMQJAyfc9MDAQ9evXL3LOwjgOHDgAmUxW4WuiyuF91R6Fqxa8vESTrr1ntXJtLKo7Tp06hVu3biEjIwN2dnZo164d+vbtW2RSqoyMDERHRwMA/P39iz2Wv78//vvf/yI8PFxle+Hr0uoBQFRUFLKysmBmZlapa6Ki7t+/j+zsbACl34ezZ8+qff/UrZeVlYWoqCg0b968PJdCJQgLC8O8efOQkpICKysr+Pr64o033lAu7Pwq3lftERUVBQBwcXFRbtO19yyTHdKoX375pcg2FxcXbNq0Cb1791Zui42NVX7v4eFR7LHc3d0BoMh6aoWvy6onCAJiY2PRokWL8l8AlUvhPbC2ti7xw6+4+5eRkYHk5GQAZd+/Fy9eqCSrZd33wsUKJRIJYmJi+KFYSQcOHMCBAwdUtllZWWH16tUYN26cynbeV+3x/PlzbNmyBQAwZMgQ5XZde8+yG4s0onXr1li1ahVu374NiUSChIQEHD16FJ06dcKzZ88QEhKC0NBQZfmMjAzl9yW1vBR2UUkkEpXthXXLqldcXaoaZd0DoPj7V5H7XlLdip6TKqZhw4b4+uuvER4ejpSUFKSkpODcuXPo378/0tPTMX78eGzbtk2lDu+rdsjPz8eYMWOQnp6Oli1b4p133lHu07X3LFt2SCNmz56t8trCwgI9e/ZEjx49MGjQIPz555+YNWsWIiIiNBMgEZXL2LFji2wLDAzEgQMHMGPGDKxZswazZ8/GsGHDOOu9lpk6dSpOnDgBOzs7/Pbbbzp9f9iyQ1pFJBJh8eLFAIAbN24oB8y93IyalZVVbN3CCa4sLS1VthfWLatecXWpapR1D4Di719F7ntJdSt6Tqo6ixYtgr6+Pl68eIHLly8rt/O+at7MmTOxceNG2NjY4NixY2jSpInKfl17zzLZIa3TrFkz5fePHz8GAJWR+XFxccXWK0yMPD09VbYXvi6rnkgkKvYJAKq8wnuQlpam0sz9suLun4WFBWxtbQGUff/s7e1Vmr/Luu8SiUTZFP7q7wxVDVtbWzg6OgL4970M8L5q2ty5c7F69WpYW1vj6NGjyqexXqZr71kmO6R1Cge3Af9m+paWlmjUqBEA4Nq1a8XWK9zu5+ensr3wdVn1GjduXOyj6VR53t7eMDU1BVB990/demZmZkX+V0tVQy6XIz09HQCKDHLlfdWMjz76CCtXroSVlRWOHj1a4pNPuvaeZbJDWmfnzp0AChIcb29v5fZBgwYBALZv316kTmZmpvJJkMGDB6vsK6y3f//+YptHC4/3aj2qOkZGRujXrx+A4u/fo0ePcOHCBQD/3q9Cha937twJhUKhsk+hUGDXrl0Ait6/gQMHAgDOnz9f7P8UC+N44403YGhoWNFLonLYv38/srOzIRKJinyo8r7WvHnz5uG7776DlZUVjh07hoCAgBLL6tx7tsLTEBJVUnh4uPDnn38KMplMZbtcLhd+/vlnwdjYWAAgfPrppyr7X14u4qefflJuz8/PV05rX9ZyEePGjeNyEdWgPDPtXr9+XTn1/KFDh5TbKzL1/IIFC1T2LViwQAAguLm5lTr1fI8ePVT2Hzx4kMsKlENZ9/XRo0fCf//7XyEnJ6fIvr179wq2trYCAGHMmDFF9vO+1qxPPvlEOZP8lStXylVHl96zTHaoxu3du1cAINjY2AjBwcHCqFGjhL59+woeHh7KRenefPPNIsmQIAjC7t27leu4tG/fXhgxYkS5FgK9d++e4ODgIOCfhUBHjBghtGvXTgAXAlXL9evXhfbt2yu/7O3tlX/AXt7+6gKQLy8qGBQUJAwfPlxwcXGp0KKCPj4+wsiRI5WLGJa1qGDjxo2ViwoOHz5cCAoKEkQikQBAWLVqVZX/bGqzit7X8PBw5X8WXnvtNWHkyJHCgAEDlD9zAEK3bt2KXaZFEHhfa8qff/6pvB/+/v4lLtg6d+7cInV15T3LZIdq3MOHD4VZs2YJnTt3FurVqycYGxsLYrFY8PDwEIYOHSr89ddfpda/du2aMHjwYMHBwUEwMjIS6tevL7z33nvC8+fPS6337Nkz4b333hPq168vGBkZCQ4ODsLgwYOF69evV+Xl1QmnTp1S/vEs7SsmJqZI3WPHjgm9e/cWbG1tBbFYLDRu3FiYP3++IJFISj1nVFSUMG7cOMHV1VUwNDQUXF1dhXHjxgnR0dGl1ktPTxfmzZsnNG7cWBCLxYKtra3Qu3dv4fjx45X5Eeikit7XpKQk4eOPPxa6d+8ueHh4CGZmZoKhoaHg4uIi9O/fX9i+fXuRtZFexfta/TZv3lyu+1q/fv1i6+vCe1YkCIJQsY4vIiIiotqDA5SJiIhIpzHZISIiIp3GZIeIiIh0GpMdIiIi0mlMdoiIiEinMdkhIiIincZkh4iIiHQakx0iIiLSaUx2iIiISKcx2SF6haenJ0QikcqXWCyGh4cHRowYgbNnzxaps2jRIohEIixatKjmA64md+/exZw5c+Dr6ws7OzsYGhrCzs4OHTt2xPz583H37l1Nh1gjtPXezp49G3p6erh27ZrK9gkTJih/b9u0aVPqMa5evarye37u3Dnlvtdeew0ikQjLly8vtm5eXh5MTU0hEonQo0ePEs/Rv39/iEQifPbZZ8ptU6ZMgYGBAW7dulWOKyWqPCY7RCUIDAzE+PHjMX78ePTp0wcKhQK7d+9G165dsXLlSk2HV6yq+GDOz8/H7Nmz4ePjg++//x5xcXEICAjA8OHD0aFDB8TExOCbb76Bj48P1q5dW3XB1zKhoaEQiUQICgqq8XPfvXsXa9euxZAhQ+Dv719iuRs3buD69esl7t+4cWOJ+7p16wag4DqLc/nyZeTk5AAALl68iLy8vCJl5HK58j8HhccDCn5PDQ0NMWPGjBLPT1SVmOwQlWDKlCnYsmULtmzZgn379iE6Ohrjxo2DIAj46KOPcP/+fU2HWC3GjBmD//znPzA3N8fmzZuRmJiIw4cPY9u2bfjrr7/w7NkzHDlyBG3atEF0dLSmw61206dPx927dzF9+nRNh6L04YcfIj8/v9SktjAJ2rRpU7H7c3JysHPnTri4uMDNza3I/sLk5OzZs5DL5UX2FyZBfn5+yM7OxpUrV4qUCQsLg0QigVgsRqdOnZTb3dzcMGXKFISGhmL//v0lXgNRVWGyQ1ROxsbGWLduHczMzCCXy/HHH39oOqQqt2nTJuzatQuGhoY4evQoJkyYAH19fZUyIpEIvXr1wqVLlzBixAgNRVpz7O3t0bRpU9jb22s6FADA/fv3cfDgQXTo0AEtWrQosVy/fv3g5OSEHTt2IDc3t8j+3377Denp6Rg3blyRewwAHTt2hFgshkQiKbZ1KDQ0FPr6+vjkk08AAKdOnSpSpnBbhw4dYGxsrLJv8uTJAID//Oc/JV8sURVhskNUAebm5vD29gYAxMbGllleJpPh119/xejRo9G0aVNYWlrCxMQE3t7emDFjBp4+fVpsvaCgIIhEIoSGhiIiIgKDBw+Gvb09xGIxmjdvjhUrVkAQBJU6IpEIixcvBgAsXrxYZSzGhAkTyoxVEAQsWbIEAPDuu++iffv2pZY3NDREx44dVbb98ccfmDJlCnx8fGBjYwNjY2N4eXlh0qRJiIyMLPY4hWNMtmzZghs3bmDw4MFwcHCAiYkJWrVqhVWrVhXbspCRkYH/+7//w+DBg9G4cWOYmZnBzMwMLVu2xCeffIK0tLQSY8/Pz8emTZvQo0cP5c/Vzc0NPXr0wJo1a1TKFtc1GBQUpGz5OH36tMrP2tPTEwDQtWtXiEQi7Nixo8Q4li1bBpFIhOHDh5dY5lXr1q2DIAhl3lMDAwOMHTsWqamp2Lt3b5H9hS0+kyZNKra+sbGx8v6+2pWVl5eHixcvwtfXF71794ahoWGx3V2F217uwirUpk0btG7dGqdOnaoz479Ic5jsEFWQRCIBAIjF4jLLJiQkYOzYsfjrr79gY2OD3r17o3v37sjMzMSaNWvK7Ao6cuQI2rdvj3v37qFnz57o2LEj7t+/jw8++ACzZ89WKTt+/Hi0bt0aANC6dWvleKPx48ejc+fOZcZ669YtPHz4UHksdQwfPhw7duyAiYkJunfvjtdffx16enrYvHkz2rZtiwsXLpRY98qVK+jQoQPCw8MRHByMLl26IDIyErNmzcLIkSOLJHc3btzA22+/jXPnzsHZ2RlvvPEGOnfujGfPnuHrr79GQEAAkpOTi5wnPT0d3bp1w+TJk3HmzBn4+PhgyJAhaNKkCW7evFmucSS9e/fG66+/DgBwcnJS+VkPHToUADBz5kwAKHFck0KhwPr16wGgQl1k+/btA4BSBwUXKkxkXu3KevDgAU6fPo3AwEA0adKkxPqFScqrrTaF43W6du0KU1NT+Pv74+LFi5BKpcoy+fn5ygHPxSU7ANCzZ0+VayKqNgIRqahfv74AQNi8eXORfTdu3BD09PQEAMKmTZuU2xcuXCgAEBYuXKhSXiKRCH/++acglUpVtufl5Qnz588XAAh9+/Ytcp6uXbsKAAQAwo8//qiy78SJE4JIJBL09fWF+Ph4lX0lxVEeGzduFAAIRkZGgkwmq3B9QRCEnTt3CpmZmSrbFAqFsG7dOgGA0KJFC0GhUKjsHz9+vPJap02bpnLu27dvCw4ODsX+HOLj44Xjx48LcrlcZXtWVpYwbtw45fFeNXjwYAGA4OvrK8TExKjsk8lkwr59+1S2lfQzPXXqlABA6Nq1a7E/i/z8fOXvUlhYWJH9Bw4cEAAIrVq1KrZ+caKjowUAgoODQ4llCn+eX375pSAIgtCxY0dBT09PePTokbLMJ598ovI7XBjn2bNnVY515swZAYBgbm6ucl+++OILAYBw4MABQRAEYd68eQIA4fTp08oyly5dEgAIJiYmRX7/C/3xxx8CACE4OLjcPwMidbBlh6gc0tPTcfDgQQwePBgKhQKurq7l6nqwsLBASEgIjIyMVLYbGhri66+/hqurKw4fPoyMjIxi6w8ePBjvvPOOyrbCFhO5XF7sOAl1vXjxAgBga2sLAwMDtY4xYsQImJmZqWwTiUSYNm0aOnbsiL///rvELgsXFxesWLFC5dwtWrTA559/DgBYsWKFSnk3NzcEBwdDT0/1z5ipqSnWr18PAwMD7NmzR2XfjRs38Mcff8DY2BgHDhxQdjkVMjAwwIABAyp0zSXR19fHe++9B6Cg6+lVhS0+hWXKIzw8HADQrFmzcteZNGkSFAoFNm/eDKCgRWnr1q0wNzcv83e4ffv2MDExQWZmJq5evarcfurUKejp6eG1114DUNBlV7j95TIA0KlTpyK//4UKxxyFhYWV+3qI1KHeXzSiOmDixImYOHFike0NGzbE77//XuRDvTQ3btzAiRMnEBMTg6ysLCgUCgAFTf0KhQLR0dHw9fUtUu+NN94o9njNmjXD4cOH8eTJk3LHUFOio6Nx+PBhREdHIyMjQzneJiEhAQAQGRmJ5s2bF6k3fPjwIoNYgYIutffffx9RUVF4+vQpXF1dVfZfuHABZ8+eRVxcHLKzs5XdXUZGRnjx4gVSU1NhY2MDADh8+DCAgsG79erVq7qLLsGUKVOwaNEibN++Hd99950yjujoaBw9ehTW1tYYM2ZMuY9X+DO0s7Mrd50RI0Zg1qxZ2LJlCz7//HMcOXIEjx8/xqRJk8r8HTYyMkJgYCCOHz+O0NBQdOzYEVKpFJcuXUKbNm1gZWUFoGCaBn19fYSGhmLhwoUASh+vU6jwOlJTU5GXl1diUkRUWUx2iEoQGBiIRo0aASj4o+/o6IgOHTqgd+/e5W75yMrKwtixY4sdIPqywnFAr/Lw8Ch2u6WlJQAU+5SNuhwcHAAAKSkpkMvlxT6hUxq5XI7p06djw4YNRcbXvKyka/Xy8ip2u4WFBezs7JCcnIzHjx8rk53ExEQMGTJEZSK8ks5XmGQ8evQIANC0adMyr6cq2NjYYOzYsdiwYQM2btyIDz74AADwww8/QBAETJw4EaampuU+Xnp6OoB/7395WFhYYOjQodi6dStOnjxZ5sDkV3Xr1g3Hjx/HqVOnMH/+fOV4nZfnF7KwsICfnx8uXboEqVQKfX19nD9/Xlm/JC9fR1paGhwdHct9XUQVwW4sohK8PM/OTz/9hK+++gr9+/evUBfP/PnzsXfvXjRt2hT79u3DkydPIJVKIQgCBEFQPu1SUnLwahdNdWrbti2Agidtbty4UeH6q1atwo8//ggnJyds374dsbGxyMnJUV7rm2++CaDkay2Pl+tOmTIF586dQ8eOHXH06FEkJCQgLy9PeT4XF5dKn68qFA54Xr9+PRQKBbKzs7F582aIRKIKdWEBgLW1NYCSE8aSFCY23333Hfbv3w9vb28EBgaWq25hsnL+/Hnk5eUpW2xenUyxa9euyM3NxcWLF3H16lVkZmbCzMwMAQEBJR67MHkDoExIiaoDW3aIqtHu3bsBALt27UKrVq2K7I+KiqrpkErUqlUreHl5ISYmBlu3boWfn1+F6hde64YNGxASElJkf1nXGhMTU+z2jIwM5VNVhZPfZWVl4eDBg9DT08PBgweVSUChrKwsPH/+vMixClvK7t27V/rFVKHmzZujR48eOH78OA4dOoSnT58iLS0Nffr0QcOGDSt0rMKWj+KeMitNly5d0KhRIxw5cgQAiu2eLUlAQADMzc2RmZmJK1euIDQ0VGW8TqGuXbti+fLlCA0NVT6p2LlzZxgaGpZ47MLrsLGxKbUcUWWxZYeoGqWkpAAA6tevX2TfkSNHkJSUVKXnKxzzkJ+fX+G6IpEICxYsAFDQClHcjLgvy8/Px6VLl5SvS7vWv//+GxEREaUeb8+ePSqPLhf673//CwBo1KiRcpxNeno65HI5LC0tiyQ6APDrr78W26LTu3dvAMDBgwdLnOOovCrys375MfTCwcrqzMhcmICqMy/N1KlTYWdnB0dHR4wbN67c9QwMDJRTFxw5cgSXLl1C69ati/zcO3fuDD09PZw6dUo5OLm0LiwAuH37NoB/WxWJqguTHaJqVPjUzKsT1UVGRmLq1KlVfr7Clo+///5brfpTpkzB0KFDIZPJ0LNnT2zdurXIhH6CIODkyZPo1KkTdu7cqdxeeK3r1q1TDsAGgGfPnmHcuHFlJgVPnz7FBx98oHK+u3fv4osvvgAAlXmFnJycYGNjg7S0NGUyVOjSpUuYP39+sedo06YNBgwYgJycHAwYMABxcXEq+/Pz88u9fEHhzzoqKgoymazUsn379kWjRo1w+PBh3LhxAw0bNkSfPn3KdZ6XNWjQAB4eHnjx4kWFl+qYO3cukpKSkJCQoOziK6/CpOWHH34oMl6nkLW1NVq3bo3Lly8r51MqK9kpLNe9e/cKxUNUUUx2iKrRwoULlSs+t2rVCm+++SaCg4PRsmVLNGjQQGW9oKrw+uuvw8zMDPv27UPnzp0xceJETJkyRfnYcXls374d06dPR0ZGBiZMmAAnJyf06dMHo0ePRv/+/VGvXj0EBwcjLCxMZUK6BQsWwMjICP/3f/8Hb29vjBgxQtlVI5VKMWjQoFLPO3XqVPz8889o3Lgx3nzzTfTu3Rtt2rRBQkICBg0ahHfffVdZVl9fX/lI+rhx49ChQweMGjUKnTt3RqdOndC/f/9iW5gAYPPmzejQoQOuXbuGxo0bo1u3bhg9ejSCg4Ph6upa7kfPPTw84O/vj8TERLRs2RJjxozBlClTMG/evCJl9fT0VFpypk2bBpFIVK7zvGrgwIEAgGPHjqlVXx2FSUth613ho+av6tq1K6RSKbKysmBpaVlmi83x48cBoMoe9ycqCZMdomo0ePBgnD59GsHBwXj27Bn279+PxMRELFq0CIcOHarycQpOTk44dOgQevTogTt37uCXX37Bxo0bcfr06XIfw9DQEGvWrMHt27cxc+ZMuLm54dKlS9i9ezcuXLgADw8PLFiwAHfv3sW0adOU9dq3b49r164hJCQEWVlZ2L9/Px48eID3338fFy9eLPMJovbt2+PChQvw8fHBsWPHEBoaisaNG2PlypXYvXt3keRg1qxZ2LdvHzp16oTIyEgcOHAAUqkU69atw9atW0s8j42NDU6fPo3169ejffv2iIiIwG+//Yb79++jTZs2xc6JU5Lff/8do0aNgkQiwa5du7Bx40aV1q6XFc64bGpqWu4noYrz3nvvKZfXqCl+fn7K+6enp4cuXboUW+7lJOi1114r9Ym+8PBw3Lx5E926dSt2KgKiqiQSNP2oAhHVaRMmTMDWrVuxefPmcq3hVVt9+umnWLJkCd5++21s2LChUsfq378//vrrL9y8eRMtW7asoghr1vvvv4+1a9fizz//LHZAO1FVYssOEVE1e/bsGdatWwc9PT3MmjWr0sdbtmwZDAwMlAu/1jbx8fH4+eefERQUxESHagSTHSKiajJv3jyMHTsWfn5+SEtLw9tvv12hpR5K0rx5c0yfPh2///47rl27VgWR1qzFixdDJpNh1apVmg6F6gh2YxGRRulyN5anpyfi4uLg7OyMESNG4JtvvlHOQUNENYfJDhEREek0dmMRERGRTmOyQ0RERDqNyQ4RERHpNCY7REREpNOY7BAREZFOY7JDREREOo3JDhEREek0JjtERESk05jsEBERkU77f2yhIOFLeySSAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# number per line = total / 4\n", - "# 0 - (num-1), num - (2num-1), etc \n", - "# \n", - "num = int(len(parametric.results) / 2)\n", - "print(num)\n", - "\n", - "sub_cost = parametric.results.oss_cost * parametric.results.num_substations\n", - "\n", - "index = 3\n", - "# Cable Cost\n", - "plt.step(np.arange(100,2100,100), parametric.results.cable_cost[0+20*index:20*(index+1)])\n", - "# plt.plot(np.arange(100,2100,100), parametric.results.cable_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,7.5e8])\n", - "plt.show()\n", - "\n", - "# Substation Cost\n", - "plt.plot(np.arange(100,2100,100), sub_cost[0+20*index:20*(index+1)])\n", - "# plt.plot(np.arange(100,2100,100), parametric.results.oss_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Substation Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,7.5e8])\n", - "plt.show()\n", - "\n", - "#Total Export System Cost\n", - "total_cost = sub_cost + parametric.results.cable_cost\n", - "plt.plot(np.arange(100,2100,100), total_cost[0+20*index:20*(index+1)])\n", - "# plt.plot(np.arange(100,2100,100), total_cost[num+20*index:num+20*(index+1)])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Total Export Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.ylim([0,7.5e8])\n", - "plt.rcParams.update({'font.size':16})\n", - "plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "id": "4518cd2a-1f1b-4a9f-bfa8-e17638e81182", - "metadata": { - "tags": [] - }, - "source": [ - "# Varying distance to shore for given plant capacity" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "54227dd3-14c9-418f-b6cb-00d78ac56039", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "20\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "cable_vec = np.zeros((40,20))\n", - "oss_vec = np.zeros((40,20))\n", - "total_vec = np.zeros((40,20))\n", - "num2 = int(len(cable_vec) / 2)\n", - "print(num2)\n", - "for i in np.arange(20):\n", - " for j in np.arange(40):\n", - " index = 20 * j + i \n", - " cable_vec[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec[j,i] = parametric.results.oss_cost[index]\n", - " total_vec[j,i] = parametric.results.cable_cost[index] + parametric.results.oss_cost[index]\n", - "\n", - "ind = 19\n", - "# Cable Cost\n", - "plt.plot(np.arange(15,315,15), cable_vec[0:num2,ind])\n", - "plt.plot(np.arange(15,315,15), cable_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.ylabel(\"Cable Cost ($)\")\n", - "plt.show()\n", - "\n", - "# Substation Cost\n", - "plt.plot(np.arange(15,315,15), oss_vec[0:num2,ind])\n", - "plt.plot(np.arange(15,315,15), oss_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Substation Cost ($)\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.show()\n", - "\n", - "# Total Export System Cost\n", - "plt.plot(np.arange(15,315,15), total_vec[0:num2,ind])\n", - "plt.plot(np.arange(15,315,15), total_vec[num2:40,ind])\n", - "\n", - "plt.legend([\"HVAC\",\"HVDC\"], loc = \"lower right\")\n", - "plt.ylabel(\"Export System Cost ($)\")\n", - "plt.xlabel(\"Distance to Shore (km)\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "43c40ba5-5014-4b45-b9e1-9a5bfd4f5fb8", - "metadata": { - "tags": [] - }, - "source": [ - "# Contour for which is cheaper" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "fd400f16-b4b7-400b-a803-b02126008ce8", - "metadata": {}, - "outputs": [], - "source": [ - "cable_vec_ac = np.zeros((20,20))\n", - "oss_vec_ac = np.zeros((20,20))\n", - "total_vec_ac = np.zeros((20,20))\n", - "# dist = np.zeros((20,20))\n", - "\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " index = 20 * j + i \n", - " cable_vec_ac[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec_ac[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", - " total_vec_ac[j,i] = parametric.results.cable_cost[index] + oss_vec_ac[j,i]\n", - "# dist[j,i] = parameters.site.distance_to_landfall[index]\n", - "\n", - "\n", - "\n", - "# plt.colormap" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "6bb532b3-c160-49ab-b71c-ddf0ab8a4f51", - "metadata": {}, - "outputs": [], - "source": [ - "cable_vec_dc = np.zeros((20,20))\n", - "oss_vec_dc = np.zeros((20,20))\n", - "total_vec_dc = np.zeros((20,20))\n", - "# dist = np.zeros((20,20))\n", - "\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " index = 20 * j + i + 400\n", - " cable_vec_dc[j,i] = parametric.results.cable_cost[index]\n", - " oss_vec_dc[j,i] = parametric.results.oss_cost[index] * parametric.results.num_substations[index]\n", - " total_vec_dc[j,i] = parametric.results.cable_cost[index] + oss_vec_dc[j,i]\n", - "# dist[j,i] = parameters.site.distance_to_landfall[index]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "e322b0ac-16e5-4da0-bb20-e58edc0f3fb3", - "metadata": {}, - "outputs": [], - "source": [ - "contour_binary = np.ones((20,20))\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " if total_vec_dc[j,i] < total_vec_ac[j,i]:\n", - " contour_binary[j,i] = 0" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "d01fea0b-01ba-4417-b734-01b32fa6c34a", - "metadata": {}, - "outputs": [], - "source": [ - "cmap = LinearSegmentedColormap.from_list('custom_div_cmap',['#d73027', '#ffffbf','#1a9641'], 2)" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "6b7bd029-1285-4283-94aa-86d6e5684da3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_binary, cmap=cmap, shading='auto')\n", - "# plt.colorbar()\n", - "plt.xlabel('Plant Capacity (MW)')\n", - "plt.ylabel('Distance to Shore (km)')\n", - "plt.title('HVDC is cheaper where green')\n", - "plt.suptitle('Cheaper Transmission Type (HVAC v HVDC)')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "bec28390-032b-4265-a6bb-56d87b79dd36", - "metadata": {}, - "outputs": [], - "source": [ - "contour_cost = np.zeros((20,20))\n", - "for i in np.arange(20):\n", - " for j in np.arange(20):\n", - " if total_vec_dc[j,i] > total_vec_ac[j,i]:\n", - " contour_cost[j,i] = total_vec_ac[j,i]\n", - " else: \n", - " contour_cost[j,i] = total_vec_dc[j,i]\n" - ] - }, - { - "cell_type": "markdown", - "id": "86c53d30-1959-4b82-882e-07d52b33fa98", - "metadata": { - "tags": [] - }, - "source": [ - "# Color Map of Total Cost of Cheaper Option" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "82e6f4b7-fd6f-4f44-83a9-5cb0aabafa10", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.pcolormesh(np.arange(100,2100,100), np.arange(15,315,15),contour_cost, shading='auto')\n", - "plt.colorbar()\n", - "plt.xlabel('Plant Capacity (MW)')\n", - "plt.ylabel('Distance to Shore (km)')\n", - "# plt.title('HVDC is cheaper where green')\n", - "plt.suptitle('Cheaper Transmission Type Cost (HVAC v HVDC)')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "6ff5f19d-e474-4800-bada-c4b682ad451e", - "metadata": { - "tags": [] - }, - "source": [ - "# Overall Bar Chart" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "840bbe59-471c-424f-bba2-c1bc2d7b3fa0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ind = np.arange(0,20)\n", - "index = 3\n", - "width = 0.4\n", - "plt.figure(figsize=(12,5))\n", - "plant_cap = np.arange(100,2100,100)\n", - "\n", - "cable_data_ac = parametric.results.cable_cost[20*index:20*(index+1)]\n", - "# print(len(parametric.results.cable_cost[20*index:20*(index+1)]))\n", - "substation_data_ac = parametric.results.oss_cost[20*index:20*(index+1)]\n", - "plt.bar(ind,cable_data_ac, width, label = 'ac cable', color = 'lightsteelblue')\n", - "plt.bar(ind,substation_data_ac, width, label = 'ac oss', color = 'cornflowerblue', bottom = cable_data_ac)\n", - "\n", - "cable_data_dc = parametric.results.cable_cost[num+20*index:num+20*(index+1)]\n", - "substation_data_dc = parametric.results.oss_cost[num+20*index:num+20*(index+1)]\n", - "plt.bar(ind+width, cable_data_dc, width, label = 'dc cable', color = 'lightcoral')\n", - "plt.bar(ind+width, substation_data_dc, width, label = 'dc oss', color = 'indianred', bottom = cable_data_dc)\n", - "plant_cap_str = np.char.mod('%d',plant_cap)\n", - "# print(plant_cap)\n", - "\n", - "total_cost = parametric.results.oss_cost + parametric.results.cable_cost\n", - "plt.plot(ind, total_cost[0+20*index:20*(index+1)], color = 'blue', label = 'HVAC')\n", - "plt.plot(ind, total_cost[num+20*index:num+20*(index+1)], color = 'red', label = 'HVDC')\n", - "\n", - "plt.xticks(ind,plant_cap_str)\n", - "plt.legend(loc = 'upper left')\n", - "plt.ylabel(\"Project Cost ($)\")\n", - "plt.xlabel(\"Plant Capacity (MW)\")\n", - "plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "83910fe9-93e7-4a11-bd62-6603d766d76c", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index 30cfb55b..3c79cd41 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -51,6 +51,7 @@ class ExportCableInstallation(InstallPhase): "linear_density": "t/km", "sections": [("length, km", "speed, km/h (optional)")], "number": "int (optional)", + "cable_type": "str" }, "interconnection_distance": "km (optional); default: 3km", "interconnection_voltage": "kV (optional); default: 345kV", @@ -91,8 +92,13 @@ def setup_simulation(self, **kwargs): self.free_cable_length = system.get("free_cable_length", depth / 1000) self.cable = Cable(system["cable"]["linear_density"]) + self.cable_type = system["cable"]["cable_type"] self.sections = system["cable"]["sections"] - self.number = system["cable"].get("number", 1) + + if self.cable_type == "HVDC-monopole": + self.number = int(system["cable"].get("number", 2) / 2) + else: + self.number = system["cable"].get("number", 1) self.initialize_installation_vessel() self.initialize_burial_vessel() @@ -193,14 +199,14 @@ def calculate_onshore_transmission_cost(self, **kwargs): distance ** (1 - 0.1063) ) - onshore_transmission_cost = ( + self.onshore_transmission_cost = ( switchyard_cost + onshore_substation_cost + onshore_misc_cost + transmission_line_cost ) - return onshore_transmission_cost + return self.onshore_transmission_cost def initialize_installation_vessel(self): """Creates the export cable installation vessel.""" diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index e943209a..96538d82 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -30,17 +30,17 @@ user defined :py:attr`percent_added_length` to account for any exclusions or geotechnical design considerations that make a straight line cable route impractical. -:math:`length = (d + distance_\text{landfall} + distance_\text{interconnection} * (1 + length_\text{percent_added})` +:math:`length = (d + distance_\text{landfall} + distance_\text{interconnection}) * (1 + length_\text{percent_added})` -Number of Required Power Transformer adn Tranformer Rating +Number of Required Power Transformer and Tranformer Rating --------- The number of power transformers required is assumed to be equal to the number of required export cables. The transformer rating is calculated by dividing the windfarm's capacity by the number of power transformers. -Shunt Reactors and Reactive Power Compenation +Shunt Reactors and Reactive Power Compensation --------- The shunt reactor cost is dependent on the amount of reactive power compensation required based on the distance of the substation to shore. There is assumed to be @@ -60,6 +60,13 @@ AC\DC converters are only required for HVDC export cables. The number of convert is assumed to be equal to the number of HVDC export cables. +Cable Crossing Cost +--------- +Optional inputs for both number of cable crossings and unit cost per cable +crossing. The default number of cable crossings is 0 and cost per cable +crossing is $500,000. This cost includes materials, installation, etc. Crossing +cost is calculated as product of number of crossings and unit cost. + Design Result --------- diff --git a/library/cables/HVDC_2000mm_320kV.yaml b/library/cables/HVDC_2000mm_320kV.yaml new file mode 100644 index 00000000..04ee329a --- /dev/null +++ b/library/cables/HVDC_2000mm_320kV.yaml @@ -0,0 +1,11 @@ +# Copper from Prysmian +ac_resistance: 0 # ohm/km +capacitance: 295000 # nF/km +conductor_size: 2000 # mm^2 +cost_per_km: 500000 # $ +current_capacity: 1900 # A # ESTIMATE +inductance: 0.127 # mH/km +linear_density: 53 # t/km +cable_type: HVDC-monopole # HVDC vs HVAC +name: HVDC_2000mm_320kV +rated_voltage: 320 \ No newline at end of file diff --git a/library/cables/HVDC_2000mm_400kV.yaml b/library/cables/HVDC_2000mm_400kV.yaml new file mode 100644 index 00000000..b1c86b35 --- /dev/null +++ b/library/cables/HVDC_2000mm_400kV.yaml @@ -0,0 +1,10 @@ +ac_resistance: 0 # ohm/km +capacitance: 255000 # nF/km +conductor_size: 2000 # mm^2 +cost_per_km: 620000 # $ +current_capacity: 1900 # A +inductance: 0.141 # mH/km +linear_density: 59 # t/km +cable_type: HVDC-monopole # HVDC vs HVAC +name: HVDC_2000mm_400kV +rated_voltage: 400 \ No newline at end of file diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml new file mode 100644 index 00000000..23f1c1b2 --- /dev/null +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -0,0 +1,11 @@ +# Copper from Prysmian +ac_resistance: 0 # ohm/km +capacitance: 227000 # nF/km +conductor_size: 2500 # mm^2 +cost_per_km: 825000 # $ +current_capacity: 1905 # A +inductance: 0.149 # mH/km +linear_density: 74 # t/km +cable_type: HVDC-bipole # HVDC vs HVAC +name: HVDC_2500mm_525kV +rated_voltage: 525 \ No newline at end of file diff --git a/library/cables/XLPE_1200m_300kV_DC.yaml b/library/cables/XLPE_1200m_300kV_DC.yaml index b19ccd23..151b69f5 100644 --- a/library/cables/XLPE_1200m_300kV_DC.yaml +++ b/library/cables/XLPE_1200m_300kV_DC.yaml @@ -5,6 +5,6 @@ cost_per_km: 835000 # $ current_capacity: 1458 # A inductance: 0 # mH/km linear_density: 44 # t/km -cable_type: HVDC # HVDC vs HVAC +cable_type: HVDC-monopole # HVDC vs HVAC name: XLPE_1200m_300kV rated_voltage: 300 \ No newline at end of file diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index c8c9a439..746e8894 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -1,4 +1,4 @@ -__author__ = "Jake Nunemaker" +__author__ = "Jake Nunemaker, Sophie Bredenkamp" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" __email__ = "Jake.Nunemaker@nrel.gov" @@ -57,7 +57,7 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): assert 1e6 <= o.total_cost <= 1e9 -def test_oss_kwargs(): +def test_ac_oss_kwargs(): test_kwargs = { "mpt_cost_rate": 13500, @@ -72,12 +72,11 @@ def test_oss_kwargs(): "oss_substructure_cost_rate": 7250, "oss_pile_cost_rate": 2500, "num_substations": 4, - "converter_cost": 300e6 } o = ElectricalDesign(base) o.run() - base_cost = o.total_cost + base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): @@ -87,11 +86,35 @@ def test_oss_kwargs(): o = ElectricalDesign(config) o.run() - cost = o.total_cost - + cost = o.detailed_output["total_substation_cost"] + print("passed") assert cost != base_cost - +def test_dc_oss_kwargs(): + test_kwargs = { + "converter_cost": 300e6, + "dc_breaker_cost": 300e6 + } + dc_base = deepcopy(base) + dc_base["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" + o = ElectricalDesign(dc_base) + o.run() + base_cost = o.detailed_output["total_substation_cost"] + + for k, v in test_kwargs.items(): + + config = deepcopy(base) + config["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" + config["substation_design"] = {} + config["substation_design"][k] = v + + o = ElectricalDesign(config) + o.run() + cost = o.detailed_output["total_substation_cost"] + print("passed") + assert cost != base_cost + + def test_hvdc_substation(): config = deepcopy(base) config["export_system_design"] = {"cables": "XLPE_1200m_300kV_DC"} @@ -99,6 +122,17 @@ def test_hvdc_substation(): o.run() assert o.converter_cost != 0 assert o.shunt_reactor_cost == 0 + assert o.dc_breaker_cost != 0 + assert o.switchgear_cost == 0 + assert o.num_converters / o.num_cables == 2 + + config = deepcopy(base) + config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} + + o = ElectricalDesign(config) + o.run() + + assert o.num_converters == o.num_cables # EXPORT CABLE TESTING @@ -134,7 +168,7 @@ def test_export_system_creation(): export = ElectricalDesign(config) export.run() - assert export.num_cables + assert isinstance(export.num_cables, int) assert export.length assert export.mass assert export.cable @@ -233,12 +267,49 @@ def test_floating_length_calculations(): assert new.total_length < base_length +def test_HVDC_cable(): + + base = deepcopy(config) + base["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} + + sim = ElectricalDesign(base) + sim.run() + + assert sim.num_cables % 2 == 0 + + base = deepcopy(config) + base["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} + + sim = ElectricalDesign(base) + sim.run() + + assert sim.num_cables % 2 == 0 - - - - - +def test_num_crossing(): + + base_sim = ElectricalDesign(config) + base_sim.run() + + cross = deepcopy(config) + cross["export_system_design"]["cable_crossings"] = {"crossing_number": 2} + + cross_sim = ElectricalDesign(cross) + cross_sim.run() + + assert cross_sim.crossing_cost != base_sim.crossing_cost + +def test_cost_crossing(): + + base_sim = ElectricalDesign(config) + base_sim.run() + + cross = deepcopy(config) + cross["export_system_design"]["cable_crossings"] = {"crossing_unit_cost": 100000} + + cross_sim = ElectricalDesign(cross) + cross_sim.run() + + assert cross_sim.crossing_cost != base_sim.crossing_cost From 3e7074a3c95259b13dbd3e7f48d0f175298b4509 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 31 May 2022 10:21:58 -0600 Subject: [PATCH 026/240] DC updates part 2 --- ORBIT/phases/design/_cables.py | 32 ++-- ORBIT/phases/design/electrical_export.py | 136 ++++++++------- ORBIT/phases/install/cable_install/export.py | 7 +- .../phases/design/doc_ElectricalDesign.rst | 34 ++-- library/cables/HVDC_2000mm_320kV.yaml | 2 +- library/cables/HVDC_2000mm_400kV.yaml | 2 +- library/cables/HVDC_2500mm_525kV.yaml | 2 +- library/cables/XLPE_1200m_300kV_DC.yaml | 2 +- tests/phases/design/test_electrical_design.py | 164 ++++++++---------- 9 files changed, 186 insertions(+), 195 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index b0182aa2..0a2b3b01 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -11,7 +11,6 @@ import numpy as np from scipy.optimize import fsolve - from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import DesignPhase @@ -88,7 +87,7 @@ def __init__(self, cable_specs, **kwargs): self.cable_type = cable_specs.get("cable_type", "HVAC") # Calc additional cable specs - if self.cable_type == 'HVAC': + if self.cable_type == "HVAC": self.calc_char_impedance(**kwargs) self.calc_power_factor() self.calc_compensation_factor() @@ -98,17 +97,18 @@ def calc_char_impedance(self): """ Calculate characteristic impedance of cable. """ - if self.cable_type == 'HVDC': + if self.cable_type == "HVDC": self.char_impedance = 0 else: conductance = 1 / self.ac_resistance - + num = complex( self.ac_resistance, 2 * math.pi * self.line_frequency * self.inductance, ) den = complex( - conductance, 2 * math.pi * self.line_frequency * self.capacitance + conductance, + 2 * math.pi * self.line_frequency * self.capacitance, ) self.char_impedance = np.sqrt(num / den) @@ -127,7 +127,7 @@ def calc_cable_power(self): Calculate maximum power transfer through 3-phase cable in :math:`MW`. """ - if self.cable_type == 'HVDC-monopole' or 'HVDC-bipole': + if self.cable_type == "HVDC-monopole" or "HVDC-bipole": self.cable_power = ( self.current_capacity * self.rated_voltage * 2 / 1000 ) @@ -139,18 +139,24 @@ def calc_cable_power(self): * self.power_factor / 1000 ) - - + def calc_compensation_factor(self): """ Calculate compensation factor for shunt reactor cost """ - capacitive_reactance = 1 / (2 * np.pi * self.line_frequency * (self.capacitance / 10e8)) - capacitive_losses = self.rated_voltage ** 2 / capacitive_reactance - inductive_reactance = 2 * np.pi * self.line_frequency * (self.inductance / 1000) - inductive_losses = 3 * inductive_reactance * (self.current_capacity / 1000) ** 2 + capacitive_reactance = 1 / ( + 2 * np.pi * self.line_frequency * (self.capacitance / 10e8) + ) + capacitive_losses = self.rated_voltage**2 / capacitive_reactance + inductive_reactance = ( + 2 * np.pi * self.line_frequency * (self.inductance / 1000) + ) + inductive_losses = ( + 3 * inductive_reactance * (self.current_capacity / 1000) ** 2 + ) self.compensation_factor = capacitive_losses - inductive_losses + class Plant: """ A "data class" to create the windfarm specifications for @@ -354,7 +360,7 @@ def _get_touchdown_distance(self): else: self.touchdown = depth * 0.3 - #TODO: Update this scaling function - should be closer to cable bend radius. Unrealistic for deep water + # TODO: Update this scaling function - should be closer to cable bend radius. Unrealistic for deep water @staticmethod def _catenary(a, *data): diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index d1bf636d..4a15906f 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -4,7 +4,6 @@ __email__ = [] import numpy as np - from ORBIT.phases.design._cables import CableSystem @@ -24,8 +23,8 @@ class ElectricalDesign(CableSystem): "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", "cable_crossings": { - "crossing_number": "int (optional)", - "crossing_unit_cost": "float (optional)" + "crossing_number": "int (optional)", + "crossing_unit_cost": "float (optional)", }, }, "substation_design": { @@ -179,7 +178,7 @@ def design_result(self): @property def total_cable_cost(self): """Returns total export system cable cost.""" - + return sum(self.cost_by_type.values()) + self.crossing_cost def compute_number_cables(self): @@ -187,13 +186,20 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ - if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": - num_required = 2 * np.ceil(self._plant_capacity / self.cable.cable_power) + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): + num_required = 2 * np.ceil( + self._plant_capacity / self.cable.cable_power + ) num_redundant = 2 * self._design.get("num_redundant", 0) - else: - num_required = np.ceil(self._plant_capacity / self.cable.cable_power) + else: + num_required = np.ceil( + self._plant_capacity / self.cable.cable_power + ) num_redundant = self._design.get("num_redundant", 0) - + self.num_cables = int(num_required + num_redundant) def compute_cable_length(self): @@ -252,34 +258,35 @@ def sections_cables(self): """ return np.full(self.num_cables, self.cable.name) - + def calc_crossing_cost(self): """Compute cable crossing costs""" - self._crossing_design = self.config["export_system_design"].get("cable_crossings",{}) - self.crossing_cost = ( - self._crossing_design.get("crossing_unit_cost", 500000) - * self._crossing_design.get("crossing_number", 0) - ) - + self._crossing_design = self.config["export_system_design"].get( + "cable_crossings", {} + ) + self.crossing_cost = self._crossing_design.get( + "crossing_unit_cost", 500000 + ) * self._crossing_design.get("crossing_number", 0) #################### SUBSTATION #################### - + @property def total_substation_cost(self): - return (self.topside_cost + self.substructure_cost - + self.substation_cost) + return ( + self.topside_cost + self.substructure_cost + self.substation_cost + ) def calc_num_substations(self): """Computes number of substations""" - + self._design = self.config.get("substation_design", {}) - if self.cable.cable_type == 'HVDC-monopole': + if self.cable.cable_type == "HVDC-monopole": self.num_substations = self._design.get( - "num_substations", int(self.num_cables / 2) + "num_substations", int(self.num_cables / 2) ) - elif self.cable.cable_type == 'HVDC-bipole': + elif self.cable.cable_type == "HVDC-bipole": self.num_substations = self._design.get( - "num_substations", int(self.num_cables / 2) + "num_substations", int(self.num_cables / 2) ) else: self.num_substations = self._design.get( @@ -303,56 +310,58 @@ def substation_cost(self): def calc_mpt_cost(self): """Computes transformer cost""" - + self.num_mpt = self.num_cables - self.mpt_cost = ( - self.num_mpt * self._design.get("mpt_cost_rate", 1750000) + self.mpt_cost = self.num_mpt * self._design.get( + "mpt_cost_rate", 1750000 ) self.mpt_rating = ( - round( - (self._plant_capacity * 1.15 - / self.num_mpt) - / 10.0 - ) - * 10.0 + round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 ) def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" - + touchdown = self.config["site"]["distance_to_landfall"] - - if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": + + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): compensation = 0 else: for name, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - compensation * self._design.get("shunt_cost_rate", 99000) + compensation + * self._design.get("shunt_cost_rate", 99000) * self.num_cables ) - + def calc_switchgear_costs(self): """Computes switchgear cost""" - if self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole": + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): num_switchgear = 0 else: num_switchgear = self.num_cables - self.switchgear_cost = ( - num_switchgear * self._design.get("switchgear_cost", 134000) + self.switchgear_cost = num_switchgear * self._design.get( + "switchgear_cost", 134000 ) - + def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost""" if self.cable.cable_type == "HVAC": num_dc_breaker = 0 else: num_dc_breaker = self.num_cables - self.dc_breaker_cost = ( - num_dc_breaker * self._design.get("dc_breaker_cost", 4000000) #4e6 - ) - + self.dc_breaker_cost = num_dc_breaker * self._design.get( + "dc_breaker_cost", 4000000 + ) # 4e6 + def calc_ancillary_system_cost(self): """ Calculates cost of ancillary systems. @@ -369,21 +378,23 @@ def calc_ancillary_system_cost(self): other_ancillary_cost = self._design.get("other_ancillary_cost", 3e6) self.ancillary_system_cost = ( - (backup_gen_cost + workspace_cost + other_ancillary_cost) * self.num_substations - ) - - def calc_converter_cost(self): + backup_gen_cost + workspace_cost + other_ancillary_cost + ) * self.num_substations + + def calc_converter_cost(self): """Computes converter cost""" - + if self.cable.cable_type == "HVDC-monopole": self.num_converters = self.num_cables / 2 elif self.cable.cable_type == "HVDC-bipole": - self.num_converters = self.num_cables + self.num_converters = self.num_cables else: self.num_converters = 0 - - self.converter_cost = self.num_converters * self._design.get("converter_cost", 137e6) + + self.converter_cost = self.num_converters * self._design.get( + "converter_cost", 137e6 + ) def calc_assembly_cost(self): """ @@ -419,7 +430,7 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass ** 0.5574 + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate @@ -454,8 +465,8 @@ def calc_topside_deck_space(self): def calc_topside_mass_and_cost(self): """ - Calculates the mass and cost of the substation topsides. - + Calculates the mass and cost of the substation topsides. + Parameters ---------- topside_fab_cost_rate : int | float @@ -466,9 +477,10 @@ def calc_topside_mass_and_cost(self): topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) topside_design_cost = _design.get("topside_design_cost", 4.5e6) - self.topside_mass = 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 - self.topside_cost = ( - (self.topside_mass * topside_fab_cost_rate + topside_design_cost) * self.num_substations + self.topside_mass = ( + 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + + 285 ) - - + self.topside_cost = ( + self.topside_mass * topside_fab_cost_rate + topside_design_cost + ) * self.num_substations diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index 3c79cd41..fd809b3a 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -10,7 +10,6 @@ from math import ceil from marmot import process - from ORBIT.core import Vessel from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase @@ -51,7 +50,7 @@ class ExportCableInstallation(InstallPhase): "linear_density": "t/km", "sections": [("length, km", "speed, km/h (optional)")], "number": "int (optional)", - "cable_type": "str" + "cable_type": "str", }, "interconnection_distance": "km (optional); default: 3km", "interconnection_voltage": "kV (optional); default: 345kV", @@ -94,7 +93,7 @@ def setup_simulation(self, **kwargs): self.cable = Cable(system["cable"]["linear_density"]) self.cable_type = system["cable"]["cable_type"] self.sections = system["cable"]["sections"] - + if self.cable_type == "HVDC-monopole": self.number = int(system["cable"].get("number", 2) / 2) else: @@ -194,7 +193,7 @@ def calculate_onshore_transmission_cost(self, **kwargs): onshore_substation_cost = ( 0.165 * 1e6 ) * capacity # From BNEF Tomorrow's Cost of Offshore Wind - onshore_misc_cost = 11795 * capacity ** 0.3549 + 350000 + onshore_misc_cost = 11795 * capacity**0.3549 + 350000 transmission_line_cost = (1176 * voltage + 218257) * ( distance ** (1 - 0.1063) ) diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index 96538d82..0a4ee232 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -7,9 +7,9 @@ For details of the code implementation, please see Overview -------- -Below is an overview of the process used to design an export cable system and -offshore substation in ORBIT. For more detail on the helper classes used to -support this design please see :doc:`Cabling Helper Classes `, +Below is an overview of the process used to design an export cable system and +offshore substation in ORBIT. For more detail on the helper classes used to +support this design please see :doc:`Cabling Helper Classes `, specifically :class:`Cable` and :class:`CableSystem`. @@ -36,21 +36,21 @@ impractical. Number of Required Power Transformer and Tranformer Rating --------- The number of power transformers required is assumed to be equal to the number -of required export cables. The transformer rating is calculated by dividing the +of required export cables. The transformer rating is calculated by dividing the windfarm's capacity by the number of power transformers. Shunt Reactors and Reactive Power Compensation --------- The shunt reactor cost is dependent on the amount of reactive power compensation -required based on the distance of the substation to shore. There is assumed to be -one shunt reactor for each HVAC export cable. HVDC export systems do not require +required based on the distance of the substation to shore. There is assumed to be +one shunt reactor for each HVAC export cable. HVDC export systems do not require reactive power compensation, thus the shunt reactor cost is zero for HVDC systems. Number of Required Switchgears --------- -The number of shunt reactors required is assumed to be equal to the number of +The number of shunt reactors required is assumed to be equal to the number of required export cables. @@ -62,23 +62,19 @@ is assumed to be equal to the number of HVDC export cables. Cable Crossing Cost --------- -Optional inputs for both number of cable crossings and unit cost per cable -crossing. The default number of cable crossings is 0 and cost per cable -crossing is $500,000. This cost includes materials, installation, etc. Crossing -cost is calculated as product of number of crossings and unit cost. +Optional inputs for both number of cable crossings and unit cost per cable +crossing. The default number of cable crossings is 0 and cost per cable +crossing is $500,000. This cost includes materials, installation, etc. Crossing +cost is calculated as product of number of crossings and unit cost. Design Result --------- -The result of this design module (:py:attr:`design_result`) includes the -specifications for both the export cables and offshore substation. This includes -a list of cable sections and their lengths and masses that represent the export -cable system, as well as the offshore substation substructure and topside mass +The result of this design module (:py:attr:`design_result`) includes the +specifications for both the export cables and offshore substation. This includes +a list of cable sections and their lengths and masses that represent the export +cable system, as well as the offshore substation substructure and topside mass and cost, and number of substations. This result can then be passed to the :doc:`export cable installation module <../install/export/doc_ExportCableInstall>` and :doc:`offshore substation installation module <../install/export/doc_OffshoreSubstationInstall>` to simulate the installation of the export system. - - - - diff --git a/library/cables/HVDC_2000mm_320kV.yaml b/library/cables/HVDC_2000mm_320kV.yaml index 04ee329a..17ad7bf1 100644 --- a/library/cables/HVDC_2000mm_320kV.yaml +++ b/library/cables/HVDC_2000mm_320kV.yaml @@ -8,4 +8,4 @@ inductance: 0.127 # mH/km linear_density: 53 # t/km cable_type: HVDC-monopole # HVDC vs HVAC name: HVDC_2000mm_320kV -rated_voltage: 320 \ No newline at end of file +rated_voltage: 320 diff --git a/library/cables/HVDC_2000mm_400kV.yaml b/library/cables/HVDC_2000mm_400kV.yaml index b1c86b35..986c387a 100644 --- a/library/cables/HVDC_2000mm_400kV.yaml +++ b/library/cables/HVDC_2000mm_400kV.yaml @@ -7,4 +7,4 @@ inductance: 0.141 # mH/km linear_density: 59 # t/km cable_type: HVDC-monopole # HVDC vs HVAC name: HVDC_2000mm_400kV -rated_voltage: 400 \ No newline at end of file +rated_voltage: 400 diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml index 23f1c1b2..9d9aee22 100644 --- a/library/cables/HVDC_2500mm_525kV.yaml +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -8,4 +8,4 @@ inductance: 0.149 # mH/km linear_density: 74 # t/km cable_type: HVDC-bipole # HVDC vs HVAC name: HVDC_2500mm_525kV -rated_voltage: 525 \ No newline at end of file +rated_voltage: 525 diff --git a/library/cables/XLPE_1200m_300kV_DC.yaml b/library/cables/XLPE_1200m_300kV_DC.yaml index 151b69f5..54dd1064 100644 --- a/library/cables/XLPE_1200m_300kV_DC.yaml +++ b/library/cables/XLPE_1200m_300kV_DC.yaml @@ -7,4 +7,4 @@ inductance: 0 # mH/km linear_density: 44 # t/km cable_type: HVDC-monopole # HVDC vs HVAC name: XLPE_1200m_300kV -rated_voltage: 300 \ No newline at end of file +rated_voltage: 300 diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 746e8894..9c7bef85 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -8,27 +8,28 @@ from itertools import product import pytest - from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ElectricalDesign - # OSS TESTING base = { "site": {"distance_to_landfall": 50, "depth": 30}, "landfall": {}, "plant": {"capacity": 500}, - "export_system_design": {"cables":"XLPE_630mm_220kV"}, + "export_system_design": {"cables": "XLPE_630mm_220kV"}, "substation_design": {}, } @pytest.mark.parametrize( "distance_to_landfall,depth,plant_cap,cable", - product(range(10,201,50), range(10, 51, 10), range(100, 2001, 500), - ["XLPE_630mm_220kV","XLPE_800mm_220kV","XLPE_1000m_220kV"] - ), + product( + range(10, 201, 50), + range(10, 51, 10), + range(100, 2001, 500), + ["XLPE_630mm_220kV", "XLPE_800mm_220kV", "XLPE_1000m_220kV"], + ), ) def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): @@ -60,18 +61,18 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_ac_oss_kwargs(): test_kwargs = { - "mpt_cost_rate": 13500, - "topside_fab_cost_rate": 17000, - "topside_design_cost": 7e6, - "shunt_cost_rate": 40000, - "switchgear_cost": 15e5, - "backup_gen_cost": 2e6, - "workspace_cost": 3e6, - "other_ancillary_cost": 4e6, - "topside_assembly_factor": 0.09, - "oss_substructure_cost_rate": 7250, - "oss_pile_cost_rate": 2500, - "num_substations": 4, + "mpt_cost_rate": 13500, + "topside_fab_cost_rate": 17000, + "topside_design_cost": 7e6, + "shunt_cost_rate": 40000, + "switchgear_cost": 15e5, + "backup_gen_cost": 2e6, + "workspace_cost": 3e6, + "other_ancillary_cost": 4e6, + "topside_assembly_factor": 0.09, + "oss_substructure_cost_rate": 7250, + "oss_pile_cost_rate": 2500, + "num_substations": 4, } o = ElectricalDesign(base) @@ -89,12 +90,10 @@ def test_ac_oss_kwargs(): cost = o.detailed_output["total_substation_cost"] print("passed") assert cost != base_cost - + + def test_dc_oss_kwargs(): - test_kwargs = { - "converter_cost": 300e6, - "dc_breaker_cost": 300e6 - } + test_kwargs = {"converter_cost": 300e6, "dc_breaker_cost": 300e6} dc_base = deepcopy(base) dc_base["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" o = ElectricalDesign(dc_base) @@ -114,29 +113,29 @@ def test_dc_oss_kwargs(): print("passed") assert cost != base_cost - + def test_hvdc_substation(): - config = deepcopy(base) - config["export_system_design"] = {"cables": "XLPE_1200m_300kV_DC"} - o = ElectricalDesign(config) - o.run() - assert o.converter_cost != 0 - assert o.shunt_reactor_cost == 0 - assert o.dc_breaker_cost != 0 - assert o.switchgear_cost == 0 - assert o.num_converters / o.num_cables == 2 - - config = deepcopy(base) - config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} - - o = ElectricalDesign(config) - o.run() - - assert o.num_converters == o.num_cables + config = deepcopy(base) + config["export_system_design"] = {"cables": "XLPE_1200m_300kV_DC"} + o = ElectricalDesign(config) + o.run() + assert o.converter_cost != 0 + assert o.shunt_reactor_cost == 0 + assert o.dc_breaker_cost != 0 + assert o.switchgear_cost == 0 + assert o.num_converters / o.num_cables == 2 + + config = deepcopy(base) + config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} + + o = ElectricalDesign(config) + o.run() + + assert o.num_converters == o.num_cables # EXPORT CABLE TESTING - + def test_export_kwargs(): @@ -161,9 +160,11 @@ def test_export_kwargs(): cost = o.total_cost assert cost != base_cost - + + config = extract_library_specs("config", "export_design") + def test_export_system_creation(): export = ElectricalDesign(config) export.run() @@ -178,12 +179,14 @@ def test_export_system_creation(): assert export.topside_mass assert export.substructure_mass + def test_number_cables(): export = ElectricalDesign(config) export.run() assert export.num_cables == 9 + def test_cable_length(): export = ElectricalDesign(config) export.run() @@ -191,6 +194,7 @@ def test_cable_length(): length = (0.02 + 3 + 30) * 1.01 assert export.length == length + def test_cable_mass(): export = ElectricalDesign(config) export.run() @@ -199,6 +203,7 @@ def test_cable_mass(): mass = length * export.cable.linear_density assert export.mass == pytest.approx(mass, abs=1e-10) + def test_total_cable(): export = ElectricalDesign(config) export.run() @@ -209,6 +214,7 @@ def test_total_cable(): assert export.total_mass == pytest.approx(mass * 9, abs=1e-10) assert export.total_length == pytest.approx(length * 9, abs=1e-10) + def test_cables_property(): export = ElectricalDesign(config) export.run() @@ -217,6 +223,7 @@ def test_cables_property(): export.sections_cables == export.cable.name ).sum() == export.num_cables + def test_cable_lengths_property(): export = ElectricalDesign(config) export.run() @@ -226,6 +233,7 @@ def test_cable_lengths_property(): export.cable_lengths_by_type[cable_name] == export.length ).sum() == export.num_cables + def test_total_cable_len_property(): export = ElectricalDesign(config) export.run() @@ -235,6 +243,7 @@ def test_total_cable_len_property(): export.total_length, abs=1e-10 ) + def test_design_result(): export = ElectricalDesign(config) export.run() @@ -268,80 +277,49 @@ def test_floating_length_calculations(): def test_HVDC_cable(): - + base = deepcopy(config) base["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} - + sim = ElectricalDesign(base) sim.run() - + assert sim.num_cables % 2 == 0 - + base = deepcopy(config) base["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} - + sim = ElectricalDesign(base) sim.run() - + assert sim.num_cables % 2 == 0 + def test_num_crossing(): - + base_sim = ElectricalDesign(config) base_sim.run() - + cross = deepcopy(config) cross["export_system_design"]["cable_crossings"] = {"crossing_number": 2} - + cross_sim = ElectricalDesign(cross) cross_sim.run() - + assert cross_sim.crossing_cost != base_sim.crossing_cost + def test_cost_crossing(): - + base_sim = ElectricalDesign(config) base_sim.run() - + cross = deepcopy(config) - cross["export_system_design"]["cable_crossings"] = {"crossing_unit_cost": 100000} - + cross["export_system_design"]["cable_crossings"] = { + "crossing_unit_cost": 100000 + } + cross_sim = ElectricalDesign(cross) cross_sim.run() - - assert cross_sim.crossing_cost != base_sim.crossing_cost - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + assert cross_sim.crossing_cost != base_sim.crossing_cost From 9cbb9a4b27baa4e727e05226470bc4e6a9108ace Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 7 Jun 2022 10:16:47 -0600 Subject: [PATCH 027/240] 275 kV cables (no costs) --- ORBIT/phases/design/electrical_export.py | 12 ++++++++++++ library/cables/XLPE_1200mm_275kV.yaml | 11 +++++++++++ library/cables/XLPE_1600mm_275kV.yaml | 11 +++++++++++ library/cables/XLPE_1900mm_275kV.yaml | 11 +++++++++++ 4 files changed, 45 insertions(+) create mode 100644 library/cables/XLPE_1200mm_275kV.yaml create mode 100644 library/cables/XLPE_1600mm_275kV.yaml create mode 100644 library/cables/XLPE_1900mm_275kV.yaml diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 4a15906f..1df85c1c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -128,6 +128,7 @@ def run(self): self.calc_substructure_mass_and_cost() self.calc_converter_cost() self.calc_dc_breaker_cost() + self.calc_onshore_cost() self._outputs["offshore_substation_substructure"] = { "type": "Monopile", # Substation install only supports monopiles @@ -484,3 +485,14 @@ def calc_topside_mass_and_cost(self): self.topside_cost = ( self.topside_mass * topside_fab_cost_rate + topside_design_cost ) * self.num_substations + + + def calc_onshore_cost(self): + """ Minimum Cost of Onshore Substation Connection """ + + self.onshore_cost = ( + self.converter_cost + + self.dc_breaker_cost + + self.mpt_cost + + self.switchgear_cost + ) diff --git a/library/cables/XLPE_1200mm_275kV.yaml b/library/cables/XLPE_1200mm_275kV.yaml new file mode 100644 index 00000000..84fed976 --- /dev/null +++ b/library/cables/XLPE_1200mm_275kV.yaml @@ -0,0 +1,11 @@ +# from Prysmian +ac_resistance: 0.026 # ohm/km +capacitance: 196 # nF/km +conductor_size: 1200 # mm^2 +cost_per_km: 0 # $ +current_capacity: 547 # A # ESTIMATE +inductance: 0.37 # mH/km +linear_density: 148 # t/km +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1200mm_275kV +rated_voltage: 275 diff --git a/library/cables/XLPE_1600mm_275kV.yaml b/library/cables/XLPE_1600mm_275kV.yaml new file mode 100644 index 00000000..2a1f97cf --- /dev/null +++ b/library/cables/XLPE_1600mm_275kV.yaml @@ -0,0 +1,11 @@ +# from Prysmian +ac_resistance: 0.022 # ohm/km +capacitance: 221 # nF/km +conductor_size: 1600 # mm^2 +cost_per_km: 0 # $ +current_capacity: 730 # A # ESTIMATE +inductance: 0.35 # mH/km +linear_density: 176 # t/km +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1600mm_275kV +rated_voltage: 275 diff --git a/library/cables/XLPE_1900mm_275kV.yaml b/library/cables/XLPE_1900mm_275kV.yaml new file mode 100644 index 00000000..43c2a1eb --- /dev/null +++ b/library/cables/XLPE_1900mm_275kV.yaml @@ -0,0 +1,11 @@ +# from Prysmian +ac_resistance: 0.020 # ohm/km +capacitance: 224 # nF/km +conductor_size: 1900 # mm^2 +cost_per_km: 0 # $ +current_capacity: 910 # A # ESTIMATE +inductance: 0.35 # mH/km +linear_density: 185 # t/km +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1900mm_275kV +rated_voltage: 275 From ce29cb84644f7b527d075c7fa23ca2e6979b15e8 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Mon, 20 Jun 2022 10:25:45 -0600 Subject: [PATCH 028/240] Misc formatting. --- ORBIT/phases/design/export_system_design.py | 1 - library/cables/XLPE_630mm_33kV.yaml | 2 -- 2 files changed, 3 deletions(-) diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 23aaf27e..6c6ae0a0 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -1,4 +1,3 @@ - """Provides the `ExportSystemDesign` class.""" __author__ = "Rob Hammond" diff --git a/library/cables/XLPE_630mm_33kV.yaml b/library/cables/XLPE_630mm_33kV.yaml index 0ffd37cd..04875131 100644 --- a/library/cables/XLPE_630mm_33kV.yaml +++ b/library/cables/XLPE_630mm_33kV.yaml @@ -8,5 +8,3 @@ linear_density: 42.5 cable_type: HVAC name: XLPE_630mm_33kV rated_voltage: 33 - - From 6bf913409d9e2f3f704d1f2449da939caf5cb41c Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 1 Nov 2022 13:24:42 -0600 Subject: [PATCH 029/240] cables typo, updates to design+install --- ORBIT/phases/design/_cables.py | 2 +- ORBIT/phases/design/electrical_export.py | 22 ++++++++++---------- ORBIT/phases/install/cable_install/export.py | 8 +++---- 3 files changed, 16 insertions(+), 16 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 0a2b3b01..4e3164c8 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -97,7 +97,7 @@ def calc_char_impedance(self): """ Calculate characteristic impedance of cable. """ - if self.cable_type == "HVDC": + if self.cable_type == "HVDC-monopole" or "HVDC-bipole": self.char_impedance = 0 else: conductance = 1 / self.ac_resistance diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 1df85c1c..5173641a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -32,7 +32,8 @@ class ElectricalDesign(CableSystem): "topside_fab_cost_rate": "USD/t (optional)", "topside_design_cost": "USD (optional)", "shunt_cost_rate": "USD/MW (optional)", - "switchgear_costs": "USD (optional)", + "switchgear_cost": "USD (optional)", + "dc_breaker_cost": "int (optional)", "backup_gen_cost": "USD (optional)", "workspace_cost": "USD (optional)", "other_ancillary_cost": "USD (optional)", @@ -360,7 +361,7 @@ def calc_dc_breaker_cost(self): else: num_dc_breaker = self.num_cables self.dc_breaker_cost = num_dc_breaker * self._design.get( - "dc_breaker_cost", 4000000 + "dc_breaker_cost", 40000000 ) # 4e6 def calc_ancillary_system_cost(self): @@ -485,14 +486,13 @@ def calc_topside_mass_and_cost(self): self.topside_cost = ( self.topside_mass * topside_fab_cost_rate + topside_design_cost ) * self.num_substations - - + def calc_onshore_cost(self): - """ Minimum Cost of Onshore Substation Connection """ - + """Minimum Cost of Onshore Substation Connection""" + self.onshore_cost = ( - self.converter_cost - + self.dc_breaker_cost - + self.mpt_cost - + self.switchgear_cost - ) + self.converter_cost + + self.dc_breaker_cost + + self.mpt_cost + + self.switchgear_cost + ) diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index fd809b3a..7ca9d230 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -199,10 +199,10 @@ def calculate_onshore_transmission_cost(self, **kwargs): ) self.onshore_transmission_cost = ( - switchyard_cost - + onshore_substation_cost - + onshore_misc_cost - + transmission_line_cost + transmission_line_cost + # + switchyard_cost + # + onshore_substation_cost + # + onshore_misc_cost ) return self.onshore_transmission_cost From b7675b31e3caa1acba38005649ddf9fc98fa2c03 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 2 Nov 2022 11:24:23 -0600 Subject: [PATCH 030/240] fix DC power factor div by zero --- ORBIT/phases/design/_cables.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 4e3164c8..fe3ba8e5 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -117,10 +117,13 @@ def calc_power_factor(self): Calculate power factor. """ - phase_angle = math.atan( - np.imag(self.char_impedance) / np.real(self.char_impedance) - ) - self.power_factor = math.cos(phase_angle) + if self.cable_type == "HVDC-monopole" or "HVDC-bipole": + self.power_factor = 0 + else: + phase_angle = math.atan( + np.imag(self.char_impedance) / np.real(self.char_impedance) + ) + self.power_factor = math.cos(phase_angle) def calc_cable_power(self): """ From 0d78abf38571d44a81155f8b6627daa7669e4ae7 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Fri, 25 Nov 2022 18:27:14 -0700 Subject: [PATCH 031/240] PR changes - new onshore methods --- ORBIT/phases/design/electrical_export.py | 2 +- ORBIT/phases/install/cable_install/export.py | 10 +++++----- .../source/phases/design/doc_ElectricalDesign.rst | 15 +++++++++++---- library/vessels/example_feeder.yaml | 2 +- 4 files changed, 18 insertions(+), 11 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 5173641a..42f5011d 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -62,7 +62,7 @@ class ElectricalDesign(CableSystem): } def __init__(self, config, **kwargs): - """Creates an instance of `TemplateDesign`.""" + """Creates an instance of ElectricalDesign.""" config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index 7ca9d230..3f7058fc 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -50,7 +50,7 @@ class ExportCableInstallation(InstallPhase): "linear_density": "t/km", "sections": [("length, km", "speed, km/h (optional)")], "number": "int (optional)", - "cable_type": "str", + "cable_type": "str(optional, defualt: 'HVAC')", }, "interconnection_distance": "km (optional); default: 3km", "interconnection_voltage": "kV (optional); default: 345kV", @@ -91,7 +91,7 @@ def setup_simulation(self, **kwargs): self.free_cable_length = system.get("free_cable_length", depth / 1000) self.cable = Cable(system["cable"]["linear_density"]) - self.cable_type = system["cable"]["cable_type"] + self.cable_type = system["cable"].get("cable_type", "HVAC") self.sections = system["cable"]["sections"] if self.cable_type == "HVDC-monopole": @@ -200,9 +200,9 @@ def calculate_onshore_transmission_cost(self, **kwargs): self.onshore_transmission_cost = ( transmission_line_cost - # + switchyard_cost - # + onshore_substation_cost - # + onshore_misc_cost + # + switchyard_cost + # + onshore_substation_cost + # + onshore_misc_cost ) return self.onshore_transmission_cost diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index 0a4ee232..d2fae8ff 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -8,19 +8,26 @@ Overview -------- Below is an overview of the process used to design an export cable system and -offshore substation in ORBIT. For more detail on the helper classes used to -support this design please see :doc:`Cabling Helper Classes `, -specifically :class:`Cable` and :class:`CableSystem`. +offshore substation in ORBIT using the ElectricalDesign module. This module is to be +used in place of both the ExportSystemDesign module and the OffshoreSubstationDesign +module as it codesigns the export cables and offshore substation. For more detail on the +helper classes used to support this design please see :doc:`Cabling Helper Classes +`, specifically :class:`Cable` and :class:`CableSystem`. Number of Required Cables --------- -The number of export cables required is calculated by dividing the windfarm's +The number of export cables required for HVAC is calculated by dividing the windfarm's capacity by the configured export cable's power rating and adding any user defined redundnacy as seen below. :math:`num\_cables = \lceil\frac{plant\_capacity}{cable\_power}\rceil + num\_redundant` +For HVDC cables (both monopole and bipole), the number of cables is twice the number as +calculated abpve because HVDC systems require a pair of cables per implementation. +The equation for this calculation is shown below. + +:math:`num\_cables = 2 * \lceil\frac{plant\_capacity}{cable\_power}\rceil + num\_redundant` Export Cable Length --------- diff --git a/library/vessels/example_feeder.yaml b/library/vessels/example_feeder.yaml index 4979d4ba..2990d889 100644 --- a/library/vessels/example_feeder.yaml +++ b/library/vessels/example_feeder.yaml @@ -7,7 +7,7 @@ jacksys_specs: speed_above_depth: 0.5 # m/min speed_below_depth: 0.5 # m/min storage_specs: - max_cargo: 1200 # t + max_cargo: 12000 # t max_deck_load: 8 # t/m^2 max_deck_space: 1000 # m^2 transport_specs: From dadf1cbf3202a288ee6bede6128a6c84c87e0e9c Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Fri, 2 Dec 2022 09:11:24 -0700 Subject: [PATCH 032/240] Removed cable_type requirement. --- ORBIT/phases/design/_cables.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index fe3ba8e5..807e763f 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -57,7 +57,6 @@ class Cable: "linear_density", "cost_per_km", "name", - "cable_type", ) def __init__(self, cable_specs, **kwargs): From d080dde45c6ef8e487672bf63a5f67ac39fd257f Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Fri, 13 Jan 2023 11:37:37 -0700 Subject: [PATCH 033/240] Updated mooring system installation and hookup times. --- ORBIT/core/defaults/process_times.yaml | 2 +- ORBIT/phases/install/mooring_install/mooring.py | 4 +++- ORBIT/phases/install/quayside_assembly_tow/moored.py | 6 +++--- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/ORBIT/core/defaults/process_times.yaml b/ORBIT/core/defaults/process_times.yaml index 1c141c78..c1b94b26 100644 --- a/ORBIT/core/defaults/process_times.yaml +++ b/ORBIT/core/defaults/process_times.yaml @@ -66,7 +66,7 @@ "mooring_system_load_time": 5 # hr "mooring_site_survey_time": 4 # hr "suction_pile_install_time": 11 # hr -"drag_embed_install_time": 5 # hr +"drag_embed_install_time": 12 # hr # Increased from 5h so it now includes proof loading. This time increases with depth (in mooring.py) # Misc. "site_position_time": 2 # hr diff --git a/ORBIT/phases/install/mooring_install/mooring.py b/ORBIT/phases/install/mooring_install/mooring.py index 3b3573b9..296d82fc 100644 --- a/ORBIT/phases/install/mooring_install/mooring.py +++ b/ORBIT/phases/install/mooring_install/mooring.py @@ -268,7 +268,7 @@ def install_mooring_line(vessel, depth, **kwargs): ------ vessel.task representing time to install mooring line. """ - + install_time = 0.005 * depth yield vessel.task_wrapper( @@ -320,6 +320,7 @@ def release(**kwargs): return "", 0 +''' # commented anchor_install_time because this overwrites what is called from process_times.yaml . def anchor_install_time(self, depth): """ Returns time to install anchor. Varies by depth. @@ -342,3 +343,4 @@ def anchor_install_time(self, depth): ) return fixed + 0.005 * depth +''' \ No newline at end of file diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index c38908b2..c79fbe66 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -383,14 +383,14 @@ def install_moored_substructures( constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) yield vessel.task_wrapper( - "Connect Mooring Lines", - 22, + "Connect Mooring Lines, Pre-tension and pre-stretch", + 20, suspendable=True, constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) yield vessel.task_wrapper( "Check Mooring Lines", - 12, + 6, suspendable=True, constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) From 1d1432eef8683b7c2199803ed06c54bd8f79fdd8 Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Thu, 19 Jan 2023 13:21:14 -0700 Subject: [PATCH 034/240] working on mooring update --- ORBIT/phases/design/mooring_system_design.py | 50 +++++--------------- 1 file changed, 13 insertions(+), 37 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 383a4924..f6af0053 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -29,7 +29,7 @@ class MooringSystemDesign(DesignPhase): output_config = { "mooring_system": { "num_lines": "int", - "line_diam": "m, float", + #"line_diam": "m, float", "line_mass": "t", "line_cost": "USD", "line_length": "m", @@ -64,7 +64,7 @@ def run(self): """ self.determine_mooring_line() - self.calculate_breaking_load() + #self.calculate_breaking_load() self.calculate_line_length_mass() self.calculate_anchor_mass_cost() @@ -75,48 +75,24 @@ def determine_mooring_line(self): Returns the diameter of the mooring lines based on the turbine rating. """ - tr = self.config["turbine"]["turbine_rating"] - fit = -0.0004 * (tr ** 2) + 0.0132 * tr + 0.0536 + self.line_cost = 999 # this is the result of a function of depth - if fit <= 0.09: - self.line_diam = 0.09 - self.line_mass_per_m = 0.161 - self.line_cost_rate = 399.0 + #def calculate_breaking_load(self): + # """ + # Returns the mooring line breaking load. + # """ - elif fit <= 0.12: - self.line_diam = 0.12 - self.line_mass_per_m = 0.288 - self.line_cost_rate = 721.0 - - else: - self.line_diam = 0.15 - self.line_mass_per_m = 0.450 - self.line_cost_rate = 1088.0 - - def calculate_breaking_load(self): - """ - Returns the mooring line breaking load. - """ - - self.breaking_load = ( - 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 - ) + # self.breaking_load = ( + # 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 + # ) def calculate_line_length_mass(self): """ Returns the mooring line length and mass. """ - if self.anchor_type == "Drag Embedment": - fixed = self._design.get("drag_embedment_fixed_length", 500) - - else: - fixed = 0 - depth = self.config["site"]["depth"] - self.line_length = ( - 0.0002 * (depth ** 2) + 1.264 * depth + 47.776 + fixed - ) + self.line_length = 999 # fill this in with fitted eqn result of total semitaut line length self.line_mass = self.line_length * self.line_mass_per_m @@ -134,7 +110,7 @@ def calculate_anchor_mass_cost(self): else: self.anchor_mass = 50 - self.anchor_cost = sqrt(self.breaking_load / 9.81 / 1250) * 150000 + self.anchor_cost = 999 # make this output the cost as a function of depth (Matt H.) # sqrt(self.breaking_load / 9.81 / 1250) * 150000 @property def line_cost(self): @@ -158,7 +134,7 @@ def detailed_output(self): return { "num_lines": self.num_lines, - "line_diam": self.line_diam, + #"line_diam": self.line_diam, "line_mass": self.line_mass, "line_length": self.line_length, "line_cost": self.line_cost, From 15c5c3efef911476e2c9f9a226468592e63093aa Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Fri, 20 Jan 2023 16:09:01 -0700 Subject: [PATCH 035/240] Added the Semi-taut mooring system design module --- .../design/SemiTaut_mooring_system_design.py | 171 ++++++++++++++++++ ORBIT/phases/design/mooring_system_design.py | 151 ---------------- examples/4. Example Fixed Project.ipynb | 6 +- ...ample_floating_project_mooring_update.yaml | 55 ++++++ 4 files changed, 229 insertions(+), 154 deletions(-) create mode 100644 ORBIT/phases/design/SemiTaut_mooring_system_design.py delete mode 100644 ORBIT/phases/design/mooring_system_design.py create mode 100644 examples/configs/example_floating_project_mooring_update.yaml diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py new file mode 100644 index 00000000..fcd68a37 --- /dev/null +++ b/ORBIT/phases/design/SemiTaut_mooring_system_design.py @@ -0,0 +1,171 @@ +"""`MooringSystemDesign` and related functionality.""" + +__author__ = "Jake Nunemaker" +__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" +__maintainer__ = "Jake Nunemaker" +__email__ = "jake.nunemaker@nrel.gov" + + +from math import sqrt +from scipy import optimize +from scipy.interpolate import interp1d +import numpy as np + +from ORBIT.phases.design import DesignPhase + + +class SemiTautMooringSystemDesign(DesignPhase): + """Mooring System and Anchor Design.""" + + expected_config = { + "site": {"depth": "float"}, + "turbine": {"turbine_rating": "int | float"}, + "plant": {"num_turbines": "int"}, + "mooring_system_design": { + "num_lines": "int | float (optional, default: 4)", + "anchor_type": "str (optional, default: 'Drag Embedment')", + "mooring_line_cost_rate": "int | float (optional)", + "drag_embedment_fixed_length": "int | float (optional, default: .5km)", + }, + } + + output_config = { + "mooring_system": { + "num_lines": "int", + #"line_diam": "m, float", # this is not needed for mooring.py + "line_mass": "t", # you need this for mooring.py (mooring installation module) + "line_cost": "USD", # you can calculate this based on each rope&chain length & diameter. + "line_length": "m", # this can be calculated from rope length and chain length (which you get from an empirical eqn as function of depth) + "anchor_mass": "t", # you need this for mooring.py (mooring installation module) + "anchor_type": "str", # keep, changed default to drag embedment. + "anchor_cost": "USD", # this can be calculated also as a function of (depth?) from the empirical data you have. + } + } + + def __init__(self, config, **kwargs): + """ + Creates an instance of MooringSystemDesign. + + Parameters + ---------- + config : dict + """ + + config = self.initialize_library(config, **kwargs) + self.config = self.validate_config(config) + self.num_turbines = self.config["plant"]["num_turbines"] + + self._design = self.config.get("mooring_system_design", {}) + self.num_lines = self._design.get("num_lines", 4) + self.anchor_type = self._design.get("anchor_type", "Drag Embedment") + + self._outputs = {} + + def run(self): + """ + Main run function. + """ + + self.calculate_line_length_mass() + self.determine_mooring_line_cost() + self.calculate_anchor_mass_cost() + + self._outputs["mooring_system"] = {**self.design_result} + + def calculate_line_length_mass(self): + """ + Returns the mooring line length and mass. + """ + + depth = self.config["site"]["depth"] + chain_diam = self.config["mooring_system"]["chain_diameter"] + rope_diam = self.config["mooring_system"]["rope_diameter"] + + # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California + depths = np.array([500, 750, 1000, 1250, 1500]) + rope_lengths = np.array([478.41, 830.34, 1229.98, 1183.93, 1079.62]) + rope_diameters = np.array([0.2, 0.2, 0.2, 0.2, 0.2]) # you need the diameter for the cost data + chain_lengths = np.array([917.11, 800.36, 609.07, 896.42, 1280.57]) + chain_diameters = np.array([0.13, 0.17, 0.22, 0.22, 0.22]) + + # Interpolate + finterp_rope = interp1d(depths, rope_lengths) + finterp_chain = interp1d(depths, chain_lengths) + finterp_rope_diam = interp1d(depths, rope_diameters) + finterp_chain_diam = interp1d(depths, chain_diameters) + + # Rope and chain length at project depth + self.chain_length = finterp_chain(depth) + self.rope_length = finterp_rope(depth) + # Rope and chain diameter at project depth + self.rope_diameter = finterp_rope_diam(depth) + self.chain_diameter = finterp_chain_diam(depth) + + self.line_length = self.rope_length + self.chain_length + + chain_kg_per_m = 19900 * (self.chain_diameter**2) # 19,900 kg/m^2 (diameter)/m (length) + rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) + self.line_mass = (self.chain_length * chain_kg_per_m) + (self.rope_length * rope_kg_per_m) # kg + print('total hybrid line mass is ' + str(self.line_mass)) + + def calculate_anchor_mass_cost(self): + """ + Returns the mass and cost of anchors. + + TODO: Anchor masses are rough estimates based on initial literature + review. Should be revised when this module is overhauled in the future. + """ + + if self.anchor_type == "Drag Embedment": + self.anchor_mass = 20 # t. This should be updated, but I don't have updated data right now for this. + # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California + depths = np.array([500, 750, 1000, 1250, 1500]) + anchor_costs = np.array([112766, 125511, 148703, 204988, 246655]) # [USD] + + # interpolate anchor cost to project depth + depth = self.config["site"]["depth"] + finterp_anchor_cost = interp1d(depths, anchor_costs) + self.anchor_cost = finterp_anchor_cost(depth) # replace this with interp. function based on depth of hybrid mooring line + + @property + def line_cost(self): + """Returns cost of one line mooring line.""" + # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California + depths = np.array([500, 750, 1000, 1250, 1500]) # [m] + total_line_costs = np.array([826598, 1221471, 1682208, 2380035, 3229700]) # [USD] + finterp_total_line_cost = interp1d(depths, total_line_costs) + depth = self.config["site"]["depth"] + self.line_cost = finterp_total_line_cost(depth) + return self.line_cost + + @property + def total_cost(self): + """Returns the total cost of the mooring system.""" + + return ( + self.num_lines + * self.num_turbines + * (self.anchor_cost + self.line_cost) + ) + + @property + def detailed_output(self): + """Returns detailed phase information.""" + + return { + "num_lines": self.num_lines, + #"line_diam": self.line_diam, + "line_mass": self.line_mass, + "line_length": self.line_length, + "line_cost": self.line_cost, + "anchor_type": self.anchor_type, + "anchor_mass": self.anchor_mass, + "anchor_cost": self.anchor_cost, + "system_cost": self.total_cost, + } + + @property + def design_result(self): + """Returns the results of the design phase.""" + + return {"mooring_system": self.detailed_output} diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py deleted file mode 100644 index f6af0053..00000000 --- a/ORBIT/phases/design/mooring_system_design.py +++ /dev/null @@ -1,151 +0,0 @@ -"""`MooringSystemDesign` and related functionality.""" - -__author__ = "Jake Nunemaker" -__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" -__maintainer__ = "Jake Nunemaker" -__email__ = "jake.nunemaker@nrel.gov" - - -from math import sqrt - -from ORBIT.phases.design import DesignPhase - - -class MooringSystemDesign(DesignPhase): - """Mooring System and Anchor Design.""" - - expected_config = { - "site": {"depth": "float"}, - "turbine": {"turbine_rating": "int | float"}, - "plant": {"num_turbines": "int"}, - "mooring_system_design": { - "num_lines": "int | float (optional, default: 4)", - "anchor_type": "str (optional, default: 'Suction Pile')", - "mooring_line_cost_rate": "int | float (optional)", - "drag_embedment_fixed_length": "int | float (optional, default: .5km)", - }, - } - - output_config = { - "mooring_system": { - "num_lines": "int", - #"line_diam": "m, float", - "line_mass": "t", - "line_cost": "USD", - "line_length": "m", - "anchor_mass": "t", - "anchor_type": "str", - "anchor_cost": "USD", - } - } - - def __init__(self, config, **kwargs): - """ - Creates an instance of MooringSystemDesign. - - Parameters - ---------- - config : dict - """ - - config = self.initialize_library(config, **kwargs) - self.config = self.validate_config(config) - self.num_turbines = self.config["plant"]["num_turbines"] - - self._design = self.config.get("mooring_system_design", {}) - self.num_lines = self._design.get("num_lines", 4) - self.anchor_type = self._design.get("anchor_type", "Suction Pile") - - self._outputs = {} - - def run(self): - """ - Main run function. - """ - - self.determine_mooring_line() - #self.calculate_breaking_load() - self.calculate_line_length_mass() - self.calculate_anchor_mass_cost() - - self._outputs["mooring_system"] = {**self.design_result} - - def determine_mooring_line(self): - """ - Returns the diameter of the mooring lines based on the turbine rating. - """ - - self.line_cost = 999 # this is the result of a function of depth - - #def calculate_breaking_load(self): - # """ - # Returns the mooring line breaking load. - # """ - - # self.breaking_load = ( - # 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 - # ) - - def calculate_line_length_mass(self): - """ - Returns the mooring line length and mass. - """ - - depth = self.config["site"]["depth"] - self.line_length = 999 # fill this in with fitted eqn result of total semitaut line length - - self.line_mass = self.line_length * self.line_mass_per_m - - def calculate_anchor_mass_cost(self): - """ - Returns the mass and cost of anchors. - - TODO: Anchor masses are rough estimates based on initial literature - review. Should be revised when this module is overhauled in the future. - """ - - if self.anchor_type == "Drag Embedment": - self.anchor_mass = 20 - self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 - - else: - self.anchor_mass = 50 - self.anchor_cost = 999 # make this output the cost as a function of depth (Matt H.) # sqrt(self.breaking_load / 9.81 / 1250) * 150000 - - @property - def line_cost(self): - """Returns cost of one line mooring line.""" - - return self.line_length * self.line_cost_rate - - @property - def total_cost(self): - """Returns the total cost of the mooring system.""" - - return ( - self.num_lines - * self.num_turbines - * (self.anchor_cost + self.line_length * self.line_cost_rate) - ) - - @property - def detailed_output(self): - """Returns detailed phase information.""" - - return { - "num_lines": self.num_lines, - #"line_diam": self.line_diam, - "line_mass": self.line_mass, - "line_length": self.line_length, - "line_cost": self.line_cost, - "anchor_type": self.anchor_type, - "anchor_mass": self.anchor_mass, - "anchor_cost": self.anchor_cost, - "system_cost": self.total_cost, - } - - @property - def design_result(self): - """Returns the results of the design phase.""" - - return {"mooring_system": self.detailed_output} diff --git a/examples/4. Example Fixed Project.ipynb b/examples/4. Example Fixed Project.ipynb index f8a4c389..e80ef45c 100644 --- a/examples/4. Example Fixed Project.ipynb +++ b/examples/4. Example Fixed Project.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -899,7 +899,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -913,7 +913,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.15" } }, "nbformat": 4, diff --git a/examples/configs/example_floating_project_mooring_update.yaml b/examples/configs/example_floating_project_mooring_update.yaml new file mode 100644 index 00000000..baad61c0 --- /dev/null +++ b/examples/configs/example_floating_project_mooring_update.yaml @@ -0,0 +1,55 @@ +# Site + Plant Parameters +site: + depth: 900 + distance: 100 + distance_to_landfall: 100 +plant: + layout: ring + num_turbines: 50 + row_spacing: 7 + substation_distance: 1 + turbine_spacing: 7 +port: + monthly_rate: 2000000.0 + sub_assembly_lines: 1 + turbine_assembly_cranes: 1 +# Vessels +array_cable_install_vessel: example_cable_lay_vessel +export_cable_install_vessel: example_cable_lay_vessel +mooring_install_vessel: example_support_vessel +oss_install_vessel: floating_heavy_lift_vessel +support_vessel: example_support_vessel +towing_vessel: example_towing_vessel +towing_vessel_groups: + station_keeping_vessels: 2 + towing_vessels: 3 +wtiv: floating_heavy_lift_vessel +# Module Specific +substructure: + takt_time: 168 +OffshoreSubstationInstallation: + feeder: floating_barge +array_system: + free_cable_length: 0.5 +array_system_design: + cables: + - XLPE_630mm_66kV +export_system_design: + cables: XLPE_500mm_132kV + percent_added_length: 0.0 +# Configured Phases +design_phases: +- ArraySystemDesign +- ExportSystemDesign +- MooringSystemDesign +- OffshoreSubstationDesign +- SemiSubmersibleDesign +install_phases: + ArrayCableInstallation: 0 + ExportCableInstallation: 0 + MooredSubInstallation: 0 + MooringSystemInstallation: 0 + OffshoreSubstationInstallation: 0 + TurbineInstallation: 0 +# Project Inputs +turbine: 12MW_generic From 5b4023f553fc51801e9d0476b719aa5dfa38a90e Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Fri, 20 Jan 2023 16:56:38 -0700 Subject: [PATCH 036/240] Added SemiTaut design phase to design init --- examples/4. Example Fixed Project.ipynb | 2 +- ...5. Example Floating Project-SemiTaut.ipynb | 210 ++++++++++++++++++ ...=> example_floating_project_SemiTaut.yaml} | 2 +- 3 files changed, 212 insertions(+), 2 deletions(-) create mode 100644 examples/5. Example Floating Project-SemiTaut.ipynb rename examples/configs/{example_floating_project_mooring_update.yaml => example_floating_project_SemiTaut.yaml} (97%) diff --git a/examples/4. Example Fixed Project.ipynb b/examples/4. Example Fixed Project.ipynb index e80ef45c..d01275cb 100644 --- a/examples/4. Example Fixed Project.ipynb +++ b/examples/4. Example Fixed Project.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb new file mode 100644 index 00000000..0ef7f6b3 --- /dev/null +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Jake Nunemaker\n", + "\n", + "National Renewable Energy Lab\n", + "\n", + "Last updated: 12/23/2020" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "from ORBIT import ProjectManager, load_config \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" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num turbines: 50\n", + "Turbine: 12MW_generic\n", + "\n", + "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" + ] + } + ], + "source": [ + "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\") \n", + "\n", + "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", + "print(f\"Turbine: {fixed_config['turbine']}\")\n", + "print(f\"\\nSite: {fixed_config['site']}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Phases" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Design phases: ['ArraySystemDesign', 'ExportSystemDesign', 'SemiTautMooringSystemDesign', 'OffshoreSubstationDesign', 'SemiSubmersibleDesign']\n", + "\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'OffshoreSubstationInstallation', 'TurbineInstallation']\n" + ] + } + ], + "source": [ + "print(f\"Design phases: {fixed_config['design_phases']}\")\n", + "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")\n", + "# This now says \"SemiTautMooringSystemDesign\" in the design phases" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n" + ] + }, + { + "ename": "PhaseNotFound", + "evalue": "Unrecognized phase 'SemiTautMooringSystemDesign'.", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mPhaseNotFound\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[4], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m project \u001b[38;5;241m=\u001b[39m ProjectManager(fixed_config, weather\u001b[38;5;241m=\u001b[39mweather)\n\u001b[1;32m----> 2\u001b[0m \u001b[43mproject\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:157\u001b[0m, in \u001b[0;36mProjectManager.run\u001b[1;34m(self, **kwargs)\u001b[0m\n\u001b[0;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(install_phases, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m 155\u001b[0m install_phases \u001b[38;5;241m=\u001b[39m [install_phases]\n\u001b[1;32m--> 157\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_all_design_phases(design_phases, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 159\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(install_phases, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mset\u001b[39m)):\n\u001b[0;32m 160\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_multiple_phases_in_serial(install_phases, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:610\u001b[0m, in \u001b[0;36mProjectManager.run_all_design_phases\u001b[1;34m(self, phase_list, **kwargs)\u001b[0m\n\u001b[0;32m 605\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 606\u001b[0m \u001b[38;5;124;03mRuns multiple design phases and adds '.design_result' to self.config.\u001b[39;00m\n\u001b[0;32m 607\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 609\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m phase_list:\n\u001b[1;32m--> 610\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_design_phase(name, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", + "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:624\u001b[0m, in \u001b[0;36mProjectManager.run_design_phase\u001b[1;34m(self, name, **kwargs)\u001b[0m\n\u001b[0;32m 613\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 614\u001b[0m \u001b[38;5;124;03mRuns a design phase defined by 'name' and merges the '.design_result'\u001b[39;00m\n\u001b[0;32m 615\u001b[0m \u001b[38;5;124;03minto self.config.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 620\u001b[0m \u001b[38;5;124;03m Name of design phase that partially matches a key in `phase_dict`.\u001b[39;00m\n\u001b[0;32m 621\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 623\u001b[0m _catch \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcatch_exceptions\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m--> 624\u001b[0m _class \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_phase_class\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 625\u001b[0m _config \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_config_for_phase(name)\n\u001b[0;32m 627\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _catch:\n", + "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:600\u001b[0m, in \u001b[0;36mProjectManager.get_phase_class\u001b[1;34m(self, phase)\u001b[0m\n\u001b[0;32m 598\u001b[0m phase_class \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfind_key_match(phase)\n\u001b[0;32m 599\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m phase_class \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 600\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m PhaseNotFound(phase)\n\u001b[0;32m 602\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m phase_class\n", + "\u001b[1;31mPhaseNotFound\u001b[0m: Unrecognized phase 'SemiTautMooringSystemDesign'." + ] + } + ], + "source": [ + "project = ProjectManager(fixed_config, weather=weather)\n", + "project.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top Level Outputs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", + "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", + "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", + "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", + "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", + "\n", + "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "project.capex_breakdown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Actions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pd.DataFrame(project.actions)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/configs/example_floating_project_mooring_update.yaml b/examples/configs/example_floating_project_SemiTaut.yaml similarity index 97% rename from examples/configs/example_floating_project_mooring_update.yaml rename to examples/configs/example_floating_project_SemiTaut.yaml index baad61c0..05ef5a8d 100644 --- a/examples/configs/example_floating_project_mooring_update.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -41,7 +41,7 @@ export_system_design: design_phases: - ArraySystemDesign - ExportSystemDesign -- MooringSystemDesign +- SemiTautMooringSystemDesign - OffshoreSubstationDesign - SemiSubmersibleDesign install_phases: From c5b72f99f11c6ffd80c0588c1697cc8a6fbaf171 Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Fri, 20 Jan 2023 17:40:50 -0700 Subject: [PATCH 037/240] fixed import so new semitaut design module is running. might be giving too low of a cost for the hybrid mooring system compared to other projects --- ORBIT/manager.py | 2 + .../design/SemiTaut_mooring_system_design.py | 18 +- ORBIT/phases/design/__init__.py | 1 + ORBIT/phases/design/mooring_system_design.py | 175 ++++++++ ...5. Example Floating Project-SemiTaut.ipynb | 396 +++++++++++++++++- 5 files changed, 559 insertions(+), 33 deletions(-) create mode 100644 ORBIT/phases/design/mooring_system_design.py diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 6aeb5ba1..d87e5d00 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -30,6 +30,7 @@ ArraySystemDesign, ExportSystemDesign, MooringSystemDesign, + SemiTautMooringSystemDesign, ScourProtectionDesign, SemiSubmersibleDesign, CustomArraySystemDesign, @@ -69,6 +70,7 @@ class ProjectManager: ScourProtectionDesign, OffshoreSubstationDesign, MooringSystemDesign, + SemiTautMooringSystemDesign, SemiSubmersibleDesign, SparDesign, ) diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py index fcd68a37..bcd62465 100644 --- a/ORBIT/phases/design/SemiTaut_mooring_system_design.py +++ b/ORBIT/phases/design/SemiTaut_mooring_system_design.py @@ -1,13 +1,10 @@ """`MooringSystemDesign` and related functionality.""" -__author__ = "Jake Nunemaker" +__author__ = "Jake Nunemaker, modified by Becca F." __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" -__email__ = "jake.nunemaker@nrel.gov" +__email__ = "jake.nunemaker@nrel.gov & rebecca.fuchs@nrel.gov" - -from math import sqrt -from scipy import optimize from scipy.interpolate import interp1d import numpy as np @@ -78,9 +75,7 @@ def calculate_line_length_mass(self): """ depth = self.config["site"]["depth"] - chain_diam = self.config["mooring_system"]["chain_diameter"] - rope_diam = self.config["mooring_system"]["rope_diameter"] - + # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California depths = np.array([500, 750, 1000, 1250, 1500]) rope_lengths = np.array([478.41, 830.34, 1229.98, 1183.93, 1079.62]) @@ -106,7 +101,9 @@ def calculate_line_length_mass(self): chain_kg_per_m = 19900 * (self.chain_diameter**2) # 19,900 kg/m^2 (diameter)/m (length) rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) self.line_mass = (self.chain_length * chain_kg_per_m) + (self.rope_length * rope_kg_per_m) # kg - print('total hybrid line mass is ' + str(self.line_mass)) + print('total hybrid line mass is ' + str(self.line_mass) + 'kg') + # convert kg to metric tonnes + self.line_mass = self.line_mass/1e3 def calculate_anchor_mass_cost(self): """ @@ -127,8 +124,7 @@ def calculate_anchor_mass_cost(self): finterp_anchor_cost = interp1d(depths, anchor_costs) self.anchor_cost = finterp_anchor_cost(depth) # replace this with interp. function based on depth of hybrid mooring line - @property - def line_cost(self): + def determine_mooring_line_cost(self): """Returns cost of one line mooring line.""" # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California depths = np.array([500, 750, 1000, 1250, 1500]) # [m] diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index d234df4c..7d74fa37 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -13,5 +13,6 @@ from .array_system_design import ArraySystemDesign, CustomArraySystemDesign from .export_system_design import ExportSystemDesign from .mooring_system_design import MooringSystemDesign +from .SemiTaut_mooring_system_design import SemiTautMooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py new file mode 100644 index 00000000..383a4924 --- /dev/null +++ b/ORBIT/phases/design/mooring_system_design.py @@ -0,0 +1,175 @@ +"""`MooringSystemDesign` and related functionality.""" + +__author__ = "Jake Nunemaker" +__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" +__maintainer__ = "Jake Nunemaker" +__email__ = "jake.nunemaker@nrel.gov" + + +from math import sqrt + +from ORBIT.phases.design import DesignPhase + + +class MooringSystemDesign(DesignPhase): + """Mooring System and Anchor Design.""" + + expected_config = { + "site": {"depth": "float"}, + "turbine": {"turbine_rating": "int | float"}, + "plant": {"num_turbines": "int"}, + "mooring_system_design": { + "num_lines": "int | float (optional, default: 4)", + "anchor_type": "str (optional, default: 'Suction Pile')", + "mooring_line_cost_rate": "int | float (optional)", + "drag_embedment_fixed_length": "int | float (optional, default: .5km)", + }, + } + + output_config = { + "mooring_system": { + "num_lines": "int", + "line_diam": "m, float", + "line_mass": "t", + "line_cost": "USD", + "line_length": "m", + "anchor_mass": "t", + "anchor_type": "str", + "anchor_cost": "USD", + } + } + + def __init__(self, config, **kwargs): + """ + Creates an instance of MooringSystemDesign. + + Parameters + ---------- + config : dict + """ + + config = self.initialize_library(config, **kwargs) + self.config = self.validate_config(config) + self.num_turbines = self.config["plant"]["num_turbines"] + + self._design = self.config.get("mooring_system_design", {}) + self.num_lines = self._design.get("num_lines", 4) + self.anchor_type = self._design.get("anchor_type", "Suction Pile") + + self._outputs = {} + + def run(self): + """ + Main run function. + """ + + self.determine_mooring_line() + self.calculate_breaking_load() + self.calculate_line_length_mass() + self.calculate_anchor_mass_cost() + + self._outputs["mooring_system"] = {**self.design_result} + + def determine_mooring_line(self): + """ + Returns the diameter of the mooring lines based on the turbine rating. + """ + + tr = self.config["turbine"]["turbine_rating"] + fit = -0.0004 * (tr ** 2) + 0.0132 * tr + 0.0536 + + if fit <= 0.09: + self.line_diam = 0.09 + self.line_mass_per_m = 0.161 + self.line_cost_rate = 399.0 + + elif fit <= 0.12: + self.line_diam = 0.12 + self.line_mass_per_m = 0.288 + self.line_cost_rate = 721.0 + + else: + self.line_diam = 0.15 + self.line_mass_per_m = 0.450 + self.line_cost_rate = 1088.0 + + def calculate_breaking_load(self): + """ + Returns the mooring line breaking load. + """ + + self.breaking_load = ( + 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 + ) + + def calculate_line_length_mass(self): + """ + Returns the mooring line length and mass. + """ + + if self.anchor_type == "Drag Embedment": + fixed = self._design.get("drag_embedment_fixed_length", 500) + + else: + fixed = 0 + + depth = self.config["site"]["depth"] + self.line_length = ( + 0.0002 * (depth ** 2) + 1.264 * depth + 47.776 + fixed + ) + + self.line_mass = self.line_length * self.line_mass_per_m + + def calculate_anchor_mass_cost(self): + """ + Returns the mass and cost of anchors. + + TODO: Anchor masses are rough estimates based on initial literature + review. Should be revised when this module is overhauled in the future. + """ + + if self.anchor_type == "Drag Embedment": + self.anchor_mass = 20 + self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 + + else: + self.anchor_mass = 50 + self.anchor_cost = sqrt(self.breaking_load / 9.81 / 1250) * 150000 + + @property + def line_cost(self): + """Returns cost of one line mooring line.""" + + return self.line_length * self.line_cost_rate + + @property + def total_cost(self): + """Returns the total cost of the mooring system.""" + + return ( + self.num_lines + * self.num_turbines + * (self.anchor_cost + self.line_length * self.line_cost_rate) + ) + + @property + def detailed_output(self): + """Returns detailed phase information.""" + + return { + "num_lines": self.num_lines, + "line_diam": self.line_diam, + "line_mass": self.line_mass, + "line_length": self.line_length, + "line_cost": self.line_cost, + "anchor_type": self.anchor_type, + "anchor_mass": self.anchor_mass, + "anchor_cost": self.anchor_cost, + "system_cost": self.total_cost, + } + + @property + def design_result(self): + """Returns the results of the design phase.""" + + return {"mooring_system": self.detailed_output} diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index 0ef7f6b3..03f2ac83 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -100,22 +100,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n" - ] - }, - { - "ename": "PhaseNotFound", - "evalue": "Unrecognized phase 'SemiTautMooringSystemDesign'.", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mPhaseNotFound\u001b[0m Traceback (most recent call last)", - "Cell \u001b[1;32mIn[4], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m project \u001b[38;5;241m=\u001b[39m ProjectManager(fixed_config, weather\u001b[38;5;241m=\u001b[39mweather)\n\u001b[1;32m----> 2\u001b[0m \u001b[43mproject\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:157\u001b[0m, in \u001b[0;36mProjectManager.run\u001b[1;34m(self, **kwargs)\u001b[0m\n\u001b[0;32m 154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(install_phases, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m 155\u001b[0m install_phases \u001b[38;5;241m=\u001b[39m [install_phases]\n\u001b[1;32m--> 157\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_all_design_phases(design_phases, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m 159\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(install_phases, (\u001b[38;5;28mlist\u001b[39m, \u001b[38;5;28mset\u001b[39m)):\n\u001b[0;32m 160\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_multiple_phases_in_serial(install_phases, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:610\u001b[0m, in \u001b[0;36mProjectManager.run_all_design_phases\u001b[1;34m(self, phase_list, **kwargs)\u001b[0m\n\u001b[0;32m 605\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 606\u001b[0m \u001b[38;5;124;03mRuns multiple design phases and adds '.design_result' to self.config.\u001b[39;00m\n\u001b[0;32m 607\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 609\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name \u001b[38;5;129;01min\u001b[39;00m phase_list:\n\u001b[1;32m--> 610\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrun_design_phase(name, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n", - "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:624\u001b[0m, in \u001b[0;36mProjectManager.run_design_phase\u001b[1;34m(self, name, **kwargs)\u001b[0m\n\u001b[0;32m 613\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 614\u001b[0m \u001b[38;5;124;03mRuns a design phase defined by 'name' and merges the '.design_result'\u001b[39;00m\n\u001b[0;32m 615\u001b[0m \u001b[38;5;124;03minto self.config.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 620\u001b[0m \u001b[38;5;124;03m Name of design phase that partially matches a key in `phase_dict`.\u001b[39;00m\n\u001b[0;32m 621\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 623\u001b[0m _catch \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcatch_exceptions\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m--> 624\u001b[0m _class \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_phase_class\u001b[49m\u001b[43m(\u001b[49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 625\u001b[0m _config \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcreate_config_for_phase(name)\n\u001b[0;32m 627\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m _catch:\n", - "File \u001b[1;32m~\\OneDrive - NREL\\ORBIT\\ORBIT\\manager.py:600\u001b[0m, in \u001b[0;36mProjectManager.get_phase_class\u001b[1;34m(self, phase)\u001b[0m\n\u001b[0;32m 598\u001b[0m phase_class \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfind_key_match(phase)\n\u001b[0;32m 599\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m phase_class \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 600\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m PhaseNotFound(phase)\n\u001b[0;32m 602\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m phase_class\n", - "\u001b[1;31mPhaseNotFound\u001b[0m: Unrecognized phase 'SemiTautMooringSystemDesign'." + "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n", + "total hybrid line mass is 579876.2530880001kg\n" ] } ], @@ -133,9 +119,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 418 M\n", + "System CapEx: 1218 M\n", + "Turbine CapEx: 780 M\n", + "Soft CapEx: 387 M\n", + "Total CapEx: 2955 M\n", + "\n", + "Installation Time: 27501 h\n" + ] + } + ], "source": [ "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", @@ -155,9 +155,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 56983076.60642063,\n", + " 'Export System': 103712476.9152,\n", + " 'Substructure': 630709636.6,\n", + " 'Mooring System': 327467880.0,\n", + " 'Offshore Substation': 99479100.0,\n", + " 'Array System Installation': 22844527.89607126,\n", + " 'Export System Installation': 135112258.0470523,\n", + " 'Substructure Installation': 78569120.05327243,\n", + " 'Mooring System Installation': 48485331.05022831,\n", + " 'Offshore Substation Installation': 5499328.911719939,\n", + " 'Turbine Installation': 127738070.77625567,\n", + " 'Turbine': 780000000,\n", + " 'Soft': 387000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "project.capex_breakdown" ] @@ -171,9 +195,337 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "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_multiplieragentactiondurationcostleveltimephaselocationsite_depthhub_heightphase_namemax_waveheightmax_windspeedtransit_speednum_vessels
00.5Array Cable Installation VesselMobilize72.0000001.800000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000001.800000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.075454e+08ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaNNaN
40.5Heavy Lift VesselMobilize72.0000007.500000e+05ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaNNaN
...................................................
4334NaNMulti-Purpose Support VesselConnect Mooring Lines, Pre-tension and pre-str...20.0000008.333333e+04ACTION8544.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4335NaNMulti-Purpose Support VesselCheck Mooring Lines6.0000002.500000e+04ACTION8550.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4336NaNTowing Group 1Positioning Support34.0000008.500000e+04ACTION8550.500000MooredSubInstallationsiteNaNNaNNaNNaNNaNNaN2.0
4337NaNMulti-Purpose Support VesselTransit10.0000004.166667e+04ACTION8560.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4338NaNTowing Group 1Transit16.6666676.250000e+04ACTION8567.166667MooredSubInstallationNaNNaNNaNNaNNaNNaNNaN3.0
\n", + "

4339 rows × 16 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent \\\n", + "0 0.5 Array Cable Installation Vessel \n", + "1 0.5 Export Cable Installation Vessel \n", + "2 NaN Onshore Construction \n", + "3 1.0 Mooring System Installation Vessel \n", + "4 0.5 Heavy Lift Vessel \n", + "... ... ... \n", + "4334 NaN Multi-Purpose Support Vessel \n", + "4335 NaN Multi-Purpose Support Vessel \n", + "4336 NaN Towing Group 1 \n", + "4337 NaN Multi-Purpose Support Vessel \n", + "4338 NaN Towing Group 1 \n", + "\n", + " action duration \\\n", + "0 Mobilize 72.000000 \n", + "1 Mobilize 72.000000 \n", + "2 Onshore Construction 0.000000 \n", + "3 Mobilize 168.000000 \n", + "4 Mobilize 72.000000 \n", + "... ... ... \n", + "4334 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", + "4335 Check Mooring Lines 6.000000 \n", + "4336 Positioning Support 34.000000 \n", + "4337 Transit 10.000000 \n", + "4338 Transit 16.666667 \n", + "\n", + " cost level time phase \\\n", + "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", + "1 1.800000e+05 ACTION 0.000000 ExportCableInstallation \n", + "2 1.075454e+08 ACTION 0.000000 ExportCableInstallation \n", + "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", + "4 7.500000e+05 ACTION 0.000000 OffshoreSubstationInstallation \n", + "... ... ... ... ... \n", + "4334 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", + "4335 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4336 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4337 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", + "4338 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", + "\n", + " location site_depth hub_height phase_name max_waveheight \\\n", + "0 NaN NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN NaN \n", + "2 Landfall NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "4334 NaN NaN NaN NaN NaN \n", + "4335 NaN NaN NaN NaN NaN \n", + "4336 site NaN NaN NaN NaN \n", + "4337 NaN NaN NaN NaN NaN \n", + "4338 NaN NaN NaN NaN NaN \n", + "\n", + " max_windspeed transit_speed num_vessels \n", + "0 NaN NaN NaN \n", + "1 NaN NaN NaN \n", + "2 NaN NaN NaN \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "... ... ... ... \n", + "4334 NaN NaN NaN \n", + "4335 NaN NaN NaN \n", + "4336 NaN NaN 2.0 \n", + "4337 NaN NaN NaN \n", + "4338 NaN NaN 3.0 \n", + "\n", + "[4339 rows x 16 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "pd.DataFrame(project.actions)" ] From 047213088d644ee1ebd275a0b801308ef00a6ef1 Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Tue, 24 Jan 2023 13:39:38 -0700 Subject: [PATCH 038/240] Changed water depth to match comparison project --- ...5. Example Floating Project-SemiTaut.ipynb | 110 +++++++++--------- .../example_floating_project_SemiTaut.yaml | 2 +- 2 files changed, 56 insertions(+), 56 deletions(-) diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index 03f2ac83..23899e96 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -44,7 +44,7 @@ "Num turbines: 50\n", "Turbine: 12MW_generic\n", "\n", - "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" + "Site: {'depth': 500, 'distance': 100, 'distance_to_landfall': 100}\n" ] } ], @@ -101,7 +101,7 @@ "output_type": "stream", "text": [ "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n", - "total hybrid line mass is 579876.2530880001kg\n" + "total hybrid line mass is 323700.2840200001kg\n" ] } ], @@ -126,13 +126,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Installation CapEx: 418 M\n", - "System CapEx: 1218 M\n", + "Installation CapEx: 410 M\n", + "System CapEx: 1066 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 2955 M\n", + "Total CapEx: 2794 M\n", "\n", - "Installation Time: 27501 h\n" + "Installation Time: 26286 h\n" ] } ], @@ -155,35 +155,35 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'Array System': 56983076.60642063,\n", - " 'Export System': 103712476.9152,\n", - " 'Substructure': 630709636.6,\n", - " 'Mooring System': 327467880.0,\n", - " 'Offshore Substation': 99479100.0,\n", - " 'Array System Installation': 22844527.89607126,\n", - " 'Export System Installation': 135112258.0470523,\n", - " 'Substructure Installation': 78569120.05327243,\n", - " 'Mooring System Installation': 48485331.05022831,\n", - " 'Offshore Substation Installation': 5499328.911719939,\n", - " 'Turbine Installation': 127738070.77625567,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" + "{'Array System': 73.86136722816696,\n", + " 'Export System': 172.32636751400003,\n", + " 'Substructure': 1051.1827276666668,\n", + " 'Mooring System': 313.1213333333333,\n", + " 'Offshore Substation': 165.7985,\n", + " 'Array System Installation': 35.42268447056795,\n", + " 'Export System Installation': 225.18351574438626,\n", + " 'Substructure Installation': 130.9485334221207,\n", + " 'Mooring System Installation': 69.2752092846271,\n", + " 'Offshore Substation Installation': 8.780764320142058,\n", + " 'Turbine Installation': 212.89678462709279,\n", + " 'Turbine': 1300.0,\n", + " 'Soft': 645.0,\n", + " 'Project': 252.08333333333334}" ] }, - "execution_count": 6, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "project.capex_breakdown" + "project.capex_breakdown_per_kw" ] }, { @@ -353,7 +353,7 @@ " ...\n", " \n", " \n", - " 4334\n", + " 4317\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Connect Mooring Lines, Pre-tension and pre-str...\n", @@ -372,7 +372,7 @@ " NaN\n", " \n", " \n", - " 4335\n", + " 4318\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Check Mooring Lines\n", @@ -391,7 +391,7 @@ " NaN\n", " \n", " \n", - " 4336\n", + " 4319\n", " NaN\n", " Towing Group 1\n", " Positioning Support\n", @@ -410,7 +410,7 @@ " 2.0\n", " \n", " \n", - " 4337\n", + " 4320\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Transit\n", @@ -429,7 +429,7 @@ " NaN\n", " \n", " \n", - " 4338\n", + " 4321\n", " NaN\n", " Towing Group 1\n", " Transit\n", @@ -449,7 +449,7 @@ " \n", " \n", "\n", - "

4339 rows × 16 columns

\n", + "

4322 rows × 16 columns

\n", "" ], "text/plain": [ @@ -460,11 +460,11 @@ "3 1.0 Mooring System Installation Vessel \n", "4 0.5 Heavy Lift Vessel \n", "... ... ... \n", - "4334 NaN Multi-Purpose Support Vessel \n", - "4335 NaN Multi-Purpose Support Vessel \n", - "4336 NaN Towing Group 1 \n", - "4337 NaN Multi-Purpose Support Vessel \n", - "4338 NaN Towing Group 1 \n", + "4317 NaN Multi-Purpose Support Vessel \n", + "4318 NaN Multi-Purpose Support Vessel \n", + "4319 NaN Towing Group 1 \n", + "4320 NaN Multi-Purpose Support Vessel \n", + "4321 NaN Towing Group 1 \n", "\n", " action duration \\\n", "0 Mobilize 72.000000 \n", @@ -473,11 +473,11 @@ "3 Mobilize 168.000000 \n", "4 Mobilize 72.000000 \n", "... ... ... \n", - "4334 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", - "4335 Check Mooring Lines 6.000000 \n", - "4336 Positioning Support 34.000000 \n", - "4337 Transit 10.000000 \n", - "4338 Transit 16.666667 \n", + "4317 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", + "4318 Check Mooring Lines 6.000000 \n", + "4319 Positioning Support 34.000000 \n", + "4320 Transit 10.000000 \n", + "4321 Transit 16.666667 \n", "\n", " cost level time phase \\\n", "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", @@ -486,11 +486,11 @@ "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", "4 7.500000e+05 ACTION 0.000000 OffshoreSubstationInstallation \n", "... ... ... ... ... \n", - "4334 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", - "4335 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4336 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4337 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", - "4338 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", + "4317 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", + "4318 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4319 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4320 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", + "4321 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", "\n", " location site_depth hub_height phase_name max_waveheight \\\n", "0 NaN NaN NaN NaN NaN \n", @@ -499,11 +499,11 @@ "3 NaN NaN NaN NaN NaN \n", "4 NaN NaN NaN NaN NaN \n", "... ... ... ... ... ... \n", - "4334 NaN NaN NaN NaN NaN \n", - "4335 NaN NaN NaN NaN NaN \n", - "4336 site NaN NaN NaN NaN \n", - "4337 NaN NaN NaN NaN NaN \n", - "4338 NaN NaN NaN NaN NaN \n", + "4317 NaN NaN NaN NaN NaN \n", + "4318 NaN NaN NaN NaN NaN \n", + "4319 site NaN NaN NaN NaN \n", + "4320 NaN NaN NaN NaN NaN \n", + "4321 NaN NaN NaN NaN NaN \n", "\n", " max_windspeed transit_speed num_vessels \n", "0 NaN NaN NaN \n", @@ -512,13 +512,13 @@ "3 NaN NaN NaN \n", "4 NaN NaN NaN \n", "... ... ... ... \n", - "4334 NaN NaN NaN \n", - "4335 NaN NaN NaN \n", - "4336 NaN NaN 2.0 \n", - "4337 NaN NaN NaN \n", - "4338 NaN NaN 3.0 \n", + "4317 NaN NaN NaN \n", + "4318 NaN NaN NaN \n", + "4319 NaN NaN 2.0 \n", + "4320 NaN NaN NaN \n", + "4321 NaN NaN 3.0 \n", "\n", - "[4339 rows x 16 columns]" + "[4322 rows x 16 columns]" ] }, "execution_count": 7, diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml index 05ef5a8d..5183f7f6 100644 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -1,6 +1,6 @@ # Site + Plant Parameters site: - depth: 900 + depth: 500 distance: 100 distance_to_landfall: 100 plant: From 7eb2d76288001d51391d57876576a5fb71a6919e Mon Sep 17 00:00:00 2001 From: Rolph Date: Sat, 4 Feb 2023 11:02:58 -0700 Subject: [PATCH 039/240] Created a Floating Offshore Substation design module that uses (for now) the same mooring system as the turbines --- examples/configs/example_floating_project_SemiTaut.yaml | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml index 5183f7f6..b2ffc08e 100644 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -27,8 +27,6 @@ wtiv: floating_heavy_lift_vessel # Module Specific substructure: takt_time: 168 -OffshoreSubstationInstallation: - feeder: floating_barge array_system: free_cable_length: 0.5 array_system_design: @@ -42,14 +40,15 @@ design_phases: - ArraySystemDesign - ExportSystemDesign - SemiTautMooringSystemDesign -- OffshoreSubstationDesign +# OffshoreFloatingSubstationDesign takes the mooring system unit cost of SemiTautMooringSystemDesign, so that needs to be run first +- OffshoreFloatingSubstationDesign - SemiSubmersibleDesign install_phases: ArrayCableInstallation: 0 ExportCableInstallation: 0 MooredSubInstallation: 0 MooringSystemInstallation: 0 - OffshoreSubstationInstallation: 0 - TurbineInstallation: 0 + FloatingSubstationInstallation: 0 + #TurbineInstallation: 0 # We assume the turbine is installed at quayside onto the substructure so the necessary steps are in 'MooredSubInstallation' # Project Inputs turbine: 12MW_generic From 2aa20b87ec05cbca7344664b65dc711a6e9a834e Mon Sep 17 00:00:00 2001 From: Rolph Date: Sat, 4 Feb 2023 11:56:58 -0700 Subject: [PATCH 040/240] last commit didnt have all changes for adding floating oss design module --- ORBIT/manager.py | 2 + .../design/SemiTaut_mooring_system_design.py | 2 +- ORBIT/phases/design/__init__.py | 1 + ORBIT/phases/design/mooring_system_design.py | 1 + ORBIT/phases/design/oss_design_floating.py | 320 ++++++++++++++++++ ORBIT/phases/install/oss_install/floating.py | 13 +- 6 files changed, 332 insertions(+), 7 deletions(-) create mode 100644 ORBIT/phases/design/oss_design_floating.py diff --git a/ORBIT/manager.py b/ORBIT/manager.py index d87e5d00..348d9cc8 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -35,6 +35,7 @@ SemiSubmersibleDesign, CustomArraySystemDesign, OffshoreSubstationDesign, + OffshoreFloatingSubstationDesign, ) from ORBIT.phases.install import ( JacketInstallation, @@ -69,6 +70,7 @@ class ProjectManager: ExportSystemDesign, ScourProtectionDesign, OffshoreSubstationDesign, + OffshoreFloatingSubstationDesign, MooringSystemDesign, SemiTautMooringSystemDesign, SemiSubmersibleDesign, diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py index bcd62465..b04b0887 100644 --- a/ORBIT/phases/design/SemiTaut_mooring_system_design.py +++ b/ORBIT/phases/design/SemiTaut_mooring_system_design.py @@ -101,7 +101,7 @@ def calculate_line_length_mass(self): chain_kg_per_m = 19900 * (self.chain_diameter**2) # 19,900 kg/m^2 (diameter)/m (length) rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) self.line_mass = (self.chain_length * chain_kg_per_m) + (self.rope_length * rope_kg_per_m) # kg - print('total hybrid line mass is ' + str(self.line_mass) + 'kg') + #print('total hybrid line mass is ' + str(self.line_mass) + 'kg') # convert kg to metric tonnes self.line_mass = self.line_mass/1e3 diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 7d74fa37..9bc61875 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -7,6 +7,7 @@ from .design_phase import DesignPhase # isort:skip +from .oss_design_floating import OffshoreFloatingSubstationDesign from .oss_design import OffshoreSubstationDesign from .spar_design import SparDesign from .monopile_design import MonopileDesign diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 383a4924..5b0eec8b 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -36,6 +36,7 @@ class MooringSystemDesign(DesignPhase): "anchor_mass": "t", "anchor_type": "str", "anchor_cost": "USD", + "system_cost": "USD", } } diff --git a/ORBIT/phases/design/oss_design_floating.py b/ORBIT/phases/design/oss_design_floating.py new file mode 100644 index 00000000..3484c87f --- /dev/null +++ b/ORBIT/phases/design/oss_design_floating.py @@ -0,0 +1,320 @@ +"""Provides the 'OffshoreSubstationDesign` class.""" + +__author__ = "Jake Nunemaker" +__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" +__maintainer__ = "Jake Nunemaker" +__email__ = "Jake.Nunemaker@nrel.gov" + + +import numpy as np + +from ORBIT.phases.design import DesignPhase + + +class OffshoreFloatingSubstationDesign(DesignPhase): + """Offshore Substation Design Class.""" + + expected_config = { + "site": {"depth": "m"}, + "plant": {"num_turbines": "int"}, + "turbine": {"turbine_rating": "MW"}, + "substation_design": { + "mpt_cost_rate": "USD/MW (optional)", + "topside_fab_cost_rate": "USD/t (optional)", + "topside_design_cost": "USD (optional)", + "shunt_cost_rate": "USD/MW (optional)", + "switchgear_cost": "USD (optional)", + "backup_gen_cost": "USD (optional)", + "workspace_cost": "USD (optional)", + "other_ancillary_cost": "USD (optional)", + "topside_assembly_factor": "float (optional)", + "oss_substructure_cost_rate": "USD/t (optional)", + "oss_pile_cost_rate": "USD/t (optional)", + "num_substations": "int (optional)", + }, + } + + output_config = { + "num_substations": "int", + "offshore_substation_topside": "dict", + #"offshore_substation_substructure", "dict", + } + + def __init__(self, config, **kwargs): + """ + Creates an instance of OffshoreSubstationDesign. + + Parameters + ---------- + config : dict + """ + + config = self.initialize_library(config, **kwargs) + self.config = self.validate_config(config) + self._outputs = {} + + def run(self): + """Main run function.""" + + self.calc_substructure_length() + self.calc_substructure_deck_space() + self.calc_topside_deck_space() + + self.calc_num_mpt_and_rating() + self.calc_mpt_cost() + self.calc_topside_mass_and_cost() + self.calc_shunt_reactor_cost() + self.calc_switchgear_cost() + self.calc_ancillary_system_cost() + self.calc_assembly_cost() + self.calc_substructure_mass_and_cost() + + self._outputs["offshore_substation_substructure"] = { + "type": "Floating", + "deck_space": self.substructure_deck_space, + "mass": self.substructure_mass, + "length": self.substructure_length, + "unit_cost": self.substructure_cost, + } + + self._outputs["offshore_substation_topside"] = { + "deck_space": self.topside_deck_space, + "mass": self.topside_mass, + "unit_cost": self.substation_cost, + } + + self._outputs["num_substations"] = self.num_substations + + @property + def substation_cost(self): + """Returns total procuremet cost of the topside.""" + + return ( + self.mpt_cost + + self.topside_cost + + self.shunt_reactor_cost + + self.switchgear_costs + + self.ancillary_system_costs + + self.land_assembly_cost + ) + + @property + def total_cost(self): + """Returns total procurement cost of the substation(s).""" + + if not self._outputs: + raise Exception("Has OffshoreSubstationDesign been ran yet?") + + return ( + self.substructure_cost + self.substation_cost + ) * self.num_substations + + def calc_substructure_length(self): + """ + Calculates substructure length as the site depth + 10m + """ + + self.substructure_length = self.config["site"]["depth"] + 10 + + def calc_substructure_deck_space(self): + """ + Calculates required deck space for the substation substructure. + + Coming soon! + """ + + self.substructure_deck_space = 1 + + def calc_topside_deck_space(self): + """ + Calculates required deck space for the substation topside. + + Coming soon! + """ + + self.topside_deck_space = 1 + + def calc_num_mpt_and_rating(self): + """ + Calculates the number of main power transformers (MPTs) and their rating. + + Parameters + ---------- + num_turbines : int + turbine_rating : float + """ + + _design = self.config.get("substation_design", {}) + + num_turbines = self.config["plant"]["num_turbines"] + turbine_rating = self.config["turbine"]["turbine_rating"] + capacity = num_turbines * turbine_rating + + self.num_substations = _design.get( + "num_substations", int(np.ceil(capacity / 500)) + ) + self.num_mpt = np.ceil( + num_turbines * turbine_rating / (250 * self.num_substations) + ) + self.mpt_rating = ( + round( + ( + (num_turbines * turbine_rating * 1.15) + / (self.num_mpt * self.num_substations) + ) + / 10.0 + ) + * 10.0 + ) + + def calc_mpt_cost(self): + """ + Calculates the total cost for all MPTs. + + Parameters + ---------- + mpt_cost_rate : float + """ + + _design = self.config.get("substation_design", {}) + mpt_cost_rate = _design.get("mpt_cost_rate", 12500) + + self.mpt_cost = self.mpt_rating * self.num_mpt * mpt_cost_rate + + def calc_topside_mass_and_cost(self): + """ + Calculates the mass and cost of the substation topsides. + + Parameters + ---------- + topside_fab_cost_rate : int | float + topside_design_cost: int | float + """ + + _design = self.config.get("substation_design", {}) + topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) + topside_design_cost = _design.get("topside_design_cost", 4.5e6) + + self.topside_mass = 3.85 * self.mpt_rating * self.num_mpt + 285 + self.topside_cost = ( + self.topside_mass * topside_fab_cost_rate + topside_design_cost + ) + + def calc_shunt_reactor_cost(self): + """ + Calculates the cost of the shunt reactor. + + Parameters + ---------- + shunt_cost_rate : int | float + """ + + _design = self.config.get("substation_design", {}) + shunt_cost_rate = _design.get("shunt_cost_rate", 35000) + + self.shunt_reactor_cost = ( + self.mpt_rating * self.num_mpt * shunt_cost_rate * 0.5 + ) + + def calc_switchgear_cost(self): + """ + Calculates the cost of the switchgear. + + Parameters + ---------- + switchgear_cost : int | float + """ + + _design = self.config.get("substation_design", {}) + switchgear_cost = _design.get("switchgear_cost", 14.5e5) + + self.switchgear_costs = self.num_mpt * switchgear_cost + + def calc_ancillary_system_cost(self): + """ + Calculates cost of ancillary systems. + + Parameters + ---------- + backup_gen_cost : int | float + workspace_cost : int | float + other_ancillary_cost : int | float + """ + + _design = self.config.get("substation_design", {}) + backup_gen_cost = _design.get("backup_gen_cost", 1e6) + workspace_cost = _design.get("workspace_cost", 2e6) + other_ancillary_cost = _design.get("other_ancillary_cost", 3e6) + + self.ancillary_system_costs = ( + backup_gen_cost + workspace_cost + other_ancillary_cost + ) + + def calc_assembly_cost(self): + """ + Calculates the cost of assembly on land. + + Parameters + ---------- + topside_assembly_factor : int | float + """ + + _design = self.config.get("substation_design", {}) + topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) + self.land_assembly_cost = ( + self.switchgear_costs + + self.shunt_reactor_cost + + self.ancillary_system_costs + ) * topside_assembly_factor + + def calc_substructure_mass_and_cost(self): + """ + Calculates the mass and associated cost of the substation substructure. + + Parameters + ---------- + oss_substructure_cost_rate : int | float + oss_pile_cost_rate : int | float + """ + + _design = self.config.get("substation_design", {}) + oss_substructure_cost_rate = _design.get( + "oss_substructure_cost_rate", 3000 + ) + oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + + substructure_mass = 0.4 * self.topside_mass + #substructure_pile_mass = 8 * substructure_mass ** 0.5574 + substructure_pile_mass = 0 # the monopiles are no longer needed because there is s mooring system + self.substructure_cost = ( + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate + ) + print('substructure cost:' + str(self.substructure_cost)) + self.substructure_mass = substructure_mass + substructure_pile_mass + + @property + def design_result(self): + """ + Returns the results of self.run(). + """ + + if not self._outputs: + raise Exception("Has OffshoreSubstationDesign been ran yet?") + + return self._outputs + + @property + def detailed_output(self): + """Returns detailed phase information.""" + + _outputs = { + "num_substations": self.num_substations, + "substation_mpt_rating": self.mpt_rating, + "substation_topside_mass": self.topside_mass, + "substation_topside_cost": self.topside_cost, + "substation_substructure_mass": self.substructure_mass, + "substation_substructure_cost": self.substructure_cost, + } + + return _outputs diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 6580e19a..d752cdd4 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -25,7 +25,7 @@ class FloatingSubstationInstallation(InstallPhase): and tow-out processes. """ - phase = "Offshore Substation Installation" + phase = "Offshore Floating Substation Installation" capex_category = "Offshore Substation" #: @@ -41,9 +41,10 @@ class FloatingSubstationInstallation(InstallPhase): "type": "Floating", "takt_time": "int | float (optional, default: 0)", "unit_cost": "USD", - "mooring_cost": "USD", - "towing_speed": "int | float (optional, default: 6 km/h)", - }, + #"mooring_cost": "USD", + "towing_speed": "int | float (optional, default: 6 km/h)" + }, + "mooring_system": {"system_cost": "USD"}, } def __init__(self, config, weather=None, **kwargs): @@ -89,8 +90,8 @@ def system_capex(self): substructure = self.config["offshore_substation_substructure"][ "unit_cost" ] - mooring = self.config["offshore_substation_substructure"][ - "mooring_cost" + mooring = self.config["mooring_system"][ + "system_cost" ] return self.num_substations * (topside + substructure + mooring) From e2fc7a5145ef7e2a2cb9059f00131d7b4f901458 Mon Sep 17 00:00:00 2001 From: Rolph Date: Sat, 4 Feb 2023 13:07:27 -0700 Subject: [PATCH 041/240] testing why floatingPY is called twice --- ORBIT/phases/design/oss_design_floating.py | 2 +- ORBIT/phases/install/oss_install/floating.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/design/oss_design_floating.py b/ORBIT/phases/design/oss_design_floating.py index 3484c87f..a1f384d3 100644 --- a/ORBIT/phases/design/oss_design_floating.py +++ b/ORBIT/phases/design/oss_design_floating.py @@ -290,7 +290,7 @@ def calc_substructure_mass_and_cost(self): substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate ) - print('substructure cost:' + str(self.substructure_cost)) + #print('substructure cost:' + str(self.substructure_cost)) self.substructure_mass = substructure_mass + substructure_pile_mass @property diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index d752cdd4..cdbf7558 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -93,7 +93,9 @@ def system_capex(self): mooring = self.config["mooring_system"][ "system_cost" ] - + print('topside: ' + str(topside)) + print('oss substructure' + str(substructure)) + print('mooring system' + str(mooring)) return self.num_substations * (topside + substructure + mooring) def initialize_substructure_production(self): From 3744934caa6c06f40cdd2c2b0eab9963c4f4641e Mon Sep 17 00:00:00 2001 From: Rolph Date: Sat, 4 Feb 2023 13:16:11 -0700 Subject: [PATCH 042/240] adding example run scripts that show 2x print statement --- ...5. Example Floating Project-SemiTaut.ipynb | 219 ++++++++++-------- examples/5. Example Floating Project.ipynb | 191 ++++++++------- .../example_floating_project_SemiTaut.yaml | 4 +- 3 files changed, 222 insertions(+), 192 deletions(-) diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index 23899e96..5d1756d8 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -44,7 +44,7 @@ "Num turbines: 50\n", "Turbine: 12MW_generic\n", "\n", - "Site: {'depth': 500, 'distance': 100, 'distance_to_landfall': 100}\n" + "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" ] } ], @@ -72,9 +72,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "Design phases: ['ArraySystemDesign', 'ExportSystemDesign', 'SemiTautMooringSystemDesign', 'OffshoreSubstationDesign', 'SemiSubmersibleDesign']\n", + "Design phases: ['ArraySystemDesign', 'ExportSystemDesign', 'SemiTautMooringSystemDesign', 'OffshoreFloatingSubstationDesign', 'SemiSubmersibleDesign']\n", "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'OffshoreSubstationInstallation', 'TurbineInstallation']\n" + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" ] } ], @@ -91,6 +91,13 @@ "### Run" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": 4, @@ -101,7 +108,12 @@ "output_type": "stream", "text": [ "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n", - "total hybrid line mass is 323700.2840200001kg\n" + "topside: 47826750.0\n", + "oss substructure1912800.0\n", + "mooring system327467880.0\n", + "topside: 47826750.0\n", + "oss substructure1912800.0\n", + "mooring system327467880.0\n" ] } ], @@ -126,13 +138,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Installation CapEx: 410 M\n", - "System CapEx: 1066 M\n", + "Installation CapEx: 300 M\n", + "System CapEx: 1873 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 2794 M\n", + "Total CapEx: 3491 M\n", "\n", - "Installation Time: 26286 h\n" + "Installation Time: 22581 h\n" ] } ], @@ -155,29 +167,60 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'Array System': 73.86136722816696,\n", - " 'Export System': 172.32636751400003,\n", + "{'Array System': 56983076.60642063,\n", + " 'Export System': 103712476.9152,\n", + " 'Substructure': 630709636.6,\n", + " 'Mooring System': 327467880.0,\n", + " 'Offshore Substation': 754414860.0,\n", + " 'Array System Installation': 22844527.89607126,\n", + " 'Export System Installation': 135112258.0470523,\n", + " 'Substructure Installation': 78569120.05327243,\n", + " 'Mooring System Installation': 48485331.05022831,\n", + " 'Offshore Substation Installation': 14801636.225266362,\n", + " 'Turbine': 780000000,\n", + " 'Soft': 387000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.capex_breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 94.97179434403438,\n", + " 'Export System': 172.854128192,\n", " 'Substructure': 1051.1827276666668,\n", - " 'Mooring System': 313.1213333333333,\n", - " 'Offshore Substation': 165.7985,\n", - " 'Array System Installation': 35.42268447056795,\n", - " 'Export System Installation': 225.18351574438626,\n", + " 'Mooring System': 545.7798,\n", + " 'Offshore Substation': 1257.3581,\n", + " 'Array System Installation': 38.07421316011877,\n", + " 'Export System Installation': 225.18709674508716,\n", " 'Substructure Installation': 130.9485334221207,\n", - " 'Mooring System Installation': 69.2752092846271,\n", - " 'Offshore Substation Installation': 8.780764320142058,\n", - " 'Turbine Installation': 212.89678462709279,\n", + " 'Mooring System Installation': 80.80888508371386,\n", + " 'Offshore Substation Installation': 24.66939370877727,\n", " 'Turbine': 1300.0,\n", " 'Soft': 645.0,\n", " 'Project': 252.08333333333334}" ] }, - "execution_count": 13, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -195,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -228,8 +271,6 @@ " time\n", " phase\n", " location\n", - " site_depth\n", - " hub_height\n", " phase_name\n", " max_waveheight\n", " max_windspeed\n", @@ -254,8 +295,6 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", " 1\n", @@ -273,8 +312,6 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", " 2\n", @@ -292,8 +329,6 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", " 3\n", @@ -311,21 +346,17 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", " 4\n", - " 0.5\n", - " Heavy Lift Vessel\n", - " Mobilize\n", - " 72.000000\n", - " 7.500000e+05\n", + " NaN\n", + " Substation Assembly Line 1\n", + " Substation Substructure Assembly\n", + " 0.000000\n", + " 0.000000e+00\n", " ACTION\n", " 0.000000\n", - " OffshoreSubstationInstallation\n", - " NaN\n", - " NaN\n", + " FloatingSubstationInstallation\n", " NaN\n", " NaN\n", " NaN\n", @@ -349,11 +380,9 @@ " ...\n", " ...\n", " ...\n", - " ...\n", - " ...\n", " \n", " \n", - " 4317\n", + " 2876\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Connect Mooring Lines, Pre-tension and pre-str...\n", @@ -368,11 +397,9 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", - " 4318\n", + " 2877\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Check Mooring Lines\n", @@ -387,11 +414,9 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", - " 4319\n", + " 2878\n", " NaN\n", " Towing Group 1\n", " Positioning Support\n", @@ -405,12 +430,10 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " 2.0\n", " \n", " \n", - " 4320\n", + " 2879\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Transit\n", @@ -425,11 +448,9 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " \n", " \n", - " 4321\n", + " 2880\n", " NaN\n", " Towing Group 1\n", " Transit\n", @@ -443,13 +464,11 @@ " NaN\n", " NaN\n", " NaN\n", - " NaN\n", - " NaN\n", " 3.0\n", " \n", " \n", "\n", - "

4322 rows × 16 columns

\n", + "

2881 rows × 14 columns

\n", "" ], "text/plain": [ @@ -458,70 +477,70 @@ "1 0.5 Export Cable Installation Vessel \n", "2 NaN Onshore Construction \n", "3 1.0 Mooring System Installation Vessel \n", - "4 0.5 Heavy Lift Vessel \n", + "4 NaN Substation Assembly Line 1 \n", "... ... ... \n", - "4317 NaN Multi-Purpose Support Vessel \n", - "4318 NaN Multi-Purpose Support Vessel \n", - "4319 NaN Towing Group 1 \n", - "4320 NaN Multi-Purpose Support Vessel \n", - "4321 NaN Towing Group 1 \n", + "2876 NaN Multi-Purpose Support Vessel \n", + "2877 NaN Multi-Purpose Support Vessel \n", + "2878 NaN Towing Group 1 \n", + "2879 NaN Multi-Purpose Support Vessel \n", + "2880 NaN Towing Group 1 \n", "\n", " action duration \\\n", "0 Mobilize 72.000000 \n", "1 Mobilize 72.000000 \n", "2 Onshore Construction 0.000000 \n", "3 Mobilize 168.000000 \n", - "4 Mobilize 72.000000 \n", + "4 Substation Substructure Assembly 0.000000 \n", "... ... ... \n", - "4317 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", - "4318 Check Mooring Lines 6.000000 \n", - "4319 Positioning Support 34.000000 \n", - "4320 Transit 10.000000 \n", - "4321 Transit 16.666667 \n", + "2876 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", + "2877 Check Mooring Lines 6.000000 \n", + "2878 Positioning Support 34.000000 \n", + "2879 Transit 10.000000 \n", + "2880 Transit 16.666667 \n", "\n", " cost level time phase \\\n", "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", "1 1.800000e+05 ACTION 0.000000 ExportCableInstallation \n", "2 1.075454e+08 ACTION 0.000000 ExportCableInstallation \n", "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", - "4 7.500000e+05 ACTION 0.000000 OffshoreSubstationInstallation \n", + "4 0.000000e+00 ACTION 0.000000 FloatingSubstationInstallation \n", "... ... ... ... ... \n", - "4317 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", - "4318 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4319 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4320 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", - "4321 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", + "2876 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", + "2877 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "2878 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "2879 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", + "2880 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", "\n", - " location site_depth hub_height phase_name max_waveheight \\\n", - "0 NaN NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN \n", - "2 Landfall NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN \n", - "... ... ... ... ... ... \n", - "4317 NaN NaN NaN NaN NaN \n", - "4318 NaN NaN NaN NaN NaN \n", - "4319 site NaN NaN NaN NaN \n", - "4320 NaN NaN NaN NaN NaN \n", - "4321 NaN NaN NaN NaN NaN \n", + " location phase_name max_waveheight max_windspeed transit_speed \\\n", + "0 NaN NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN NaN \n", + "2 Landfall NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "2876 NaN NaN NaN NaN NaN \n", + "2877 NaN NaN NaN NaN NaN \n", + "2878 site NaN NaN NaN NaN \n", + "2879 NaN NaN NaN NaN NaN \n", + "2880 NaN NaN NaN NaN NaN \n", "\n", - " max_windspeed transit_speed num_vessels \n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "... ... ... ... \n", - "4317 NaN NaN NaN \n", - "4318 NaN NaN NaN \n", - "4319 NaN NaN 2.0 \n", - "4320 NaN NaN NaN \n", - "4321 NaN NaN 3.0 \n", + " num_vessels \n", + "0 NaN \n", + "1 NaN \n", + "2 NaN \n", + "3 NaN \n", + "4 NaN \n", + "... ... \n", + "2876 NaN \n", + "2877 NaN \n", + "2878 2.0 \n", + "2879 NaN \n", + "2880 3.0 \n", "\n", - "[4322 rows x 16 columns]" + "[2881 rows x 14 columns]" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 8b01b575..0c216779 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -13,7 +13,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -92,14 +92,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" + "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n" ] } ], @@ -117,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -128,9 +128,9 @@ "System CapEx: 1222 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 2961 M\n", + "Total CapEx: 2960 M\n", "\n", - "Installation Time: 27750 h\n" + "Installation Time: 27734 h\n" ] } ], @@ -153,35 +153,35 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'Array System': 56983076.60642063,\n", - " 'Export System': 103712476.9152,\n", - " 'Substructure': 630709636.6,\n", - " 'Mooring System': 331379224.80820334,\n", - " 'Offshore Substation': 99479100.0,\n", - " 'Array System Installation': 22844527.896071255,\n", - " 'Export System Installation': 135112258.0470523,\n", - " 'Substructure Installation': 79182122.33637744,\n", - " 'Mooring System Installation': 50094520.5479452,\n", - " 'Offshore Substation Installation': 5499328.911719939,\n", - " 'Turbine Installation': 127738070.77625567,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" + "{'Array System': 94.97179434403438,\n", + " 'Export System': 172.854128192,\n", + " 'Substructure': 1051.1827276666668,\n", + " 'Mooring System': 552.2987080136722,\n", + " 'Offshore Substation': 165.7985,\n", + " 'Array System Installation': 38.07421316011877,\n", + " 'Export System Installation': 225.18709674508716,\n", + " 'Substructure Installation': 130.9485334221207,\n", + " 'Mooring System Installation': 83.49086757990867,\n", + " 'Offshore Substation Installation': 9.165548186199898,\n", + " 'Turbine Installation': 212.89678462709279,\n", + " 'Turbine': 1300.0,\n", + " 'Soft': 645.0,\n", + " 'Project': 252.08333333333334}" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "project.capex_breakdown" + "project.capex_breakdown_per_kw" ] }, { @@ -193,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -351,14 +351,14 @@ " ...\n", " \n", " \n", - " 4405\n", + " 4397\n", " NaN\n", " Multi-Purpose Support Vessel\n", - " Connect Mooring Lines\n", - " 22.000000\n", - " 9.166667e+04\n", + " Connect Mooring Lines, Pre-tension and pre-str...\n", + " 20.000000\n", + " 8.333333e+04\n", " ACTION\n", - " 8554.500000\n", + " 8544.500000\n", " MooredSubInstallation\n", " NaN\n", " NaN\n", @@ -370,14 +370,14 @@ " NaN\n", " \n", " \n", - " 4406\n", + " 4398\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Check Mooring Lines\n", - " 12.000000\n", - " 5.000000e+04\n", + " 6.000000\n", + " 2.500000e+04\n", " ACTION\n", - " 8566.500000\n", + " 8550.500000\n", " MooredSubInstallation\n", " NaN\n", " NaN\n", @@ -389,14 +389,14 @@ " NaN\n", " \n", " \n", - " 4407\n", + " 4399\n", " NaN\n", " Towing Group 1\n", " Positioning Support\n", - " 42.000000\n", - " 1.050000e+05\n", + " 34.000000\n", + " 8.500000e+04\n", " ACTION\n", - " 8566.500000\n", + " 8550.500000\n", " MooredSubInstallation\n", " site\n", " NaN\n", @@ -408,14 +408,14 @@ " 2.0\n", " \n", " \n", - " 4408\n", + " 4400\n", " NaN\n", " Multi-Purpose Support Vessel\n", " Transit\n", " 10.000000\n", " 4.166667e+04\n", " ACTION\n", - " 8576.500000\n", + " 8560.500000\n", " MooredSubInstallation\n", " NaN\n", " NaN\n", @@ -427,14 +427,14 @@ " NaN\n", " \n", " \n", - " 4409\n", + " 4401\n", " NaN\n", " Towing Group 1\n", " Transit\n", " 16.666667\n", " 6.250000e+04\n", " ACTION\n", - " 8583.166667\n", + " 8567.166667\n", " MooredSubInstallation\n", " NaN\n", " NaN\n", @@ -447,7 +447,7 @@ " \n", " \n", "\n", - "

4410 rows × 16 columns

\n", + "

4402 rows × 16 columns

\n", "" ], "text/plain": [ @@ -458,55 +458,68 @@ "3 1.0 Mooring System Installation Vessel \n", "4 0.5 Heavy Lift Vessel \n", "... ... ... \n", - "4405 NaN Multi-Purpose Support Vessel \n", - "4406 NaN Multi-Purpose Support Vessel \n", - "4407 NaN Towing Group 1 \n", - "4408 NaN Multi-Purpose Support Vessel \n", - "4409 NaN Towing Group 1 \n", + "4397 NaN Multi-Purpose Support Vessel \n", + "4398 NaN Multi-Purpose Support Vessel \n", + "4399 NaN Towing Group 1 \n", + "4400 NaN Multi-Purpose Support Vessel \n", + "4401 NaN Towing Group 1 \n", + "\n", + " action duration \\\n", + "0 Mobilize 72.000000 \n", + "1 Mobilize 72.000000 \n", + "2 Onshore Construction 0.000000 \n", + "3 Mobilize 168.000000 \n", + "4 Mobilize 72.000000 \n", + "... ... ... \n", + "4397 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", + "4398 Check Mooring Lines 6.000000 \n", + "4399 Positioning Support 34.000000 \n", + "4400 Transit 10.000000 \n", + "4401 Transit 16.666667 \n", "\n", - " action duration cost level time \\\n", - "0 Mobilize 72.000000 1.800000e+05 ACTION 0.000000 \n", - "1 Mobilize 72.000000 1.800000e+05 ACTION 0.000000 \n", - "2 Onshore Construction 0.000000 1.075454e+08 ACTION 0.000000 \n", - "3 Mobilize 168.000000 7.000000e+05 ACTION 0.000000 \n", - "4 Mobilize 72.000000 7.500000e+05 ACTION 0.000000 \n", - "... ... ... ... ... ... \n", - "4405 Connect Mooring Lines 22.000000 9.166667e+04 ACTION 8554.500000 \n", - "4406 Check Mooring Lines 12.000000 5.000000e+04 ACTION 8566.500000 \n", - "4407 Positioning Support 42.000000 1.050000e+05 ACTION 8566.500000 \n", - "4408 Transit 10.000000 4.166667e+04 ACTION 8576.500000 \n", - "4409 Transit 16.666667 6.250000e+04 ACTION 8583.166667 \n", + " cost level time phase \\\n", + "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", + "1 1.800000e+05 ACTION 0.000000 ExportCableInstallation \n", + "2 1.075454e+08 ACTION 0.000000 ExportCableInstallation \n", + "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", + "4 7.500000e+05 ACTION 0.000000 OffshoreSubstationInstallation \n", + "... ... ... ... ... \n", + "4397 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", + "4398 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4399 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", + "4400 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", + "4401 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", "\n", - " phase location site_depth hub_height \\\n", - "0 ArrayCableInstallation NaN NaN NaN \n", - "1 ExportCableInstallation NaN NaN NaN \n", - "2 ExportCableInstallation Landfall NaN NaN \n", - "3 MooringSystemInstallation NaN NaN NaN \n", - "4 OffshoreSubstationInstallation NaN NaN NaN \n", - "... ... ... ... ... \n", - "4405 MooredSubInstallation NaN NaN NaN \n", - "4406 MooredSubInstallation NaN NaN NaN \n", - "4407 MooredSubInstallation site NaN NaN \n", - "4408 MooredSubInstallation NaN NaN NaN \n", - "4409 MooredSubInstallation NaN NaN NaN \n", + " location site_depth hub_height phase_name max_waveheight \\\n", + "0 NaN NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN NaN \n", + "2 Landfall NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN NaN \n", + "... ... ... ... ... ... \n", + "4397 NaN NaN NaN NaN NaN \n", + "4398 NaN NaN NaN NaN NaN \n", + "4399 site NaN NaN NaN NaN \n", + "4400 NaN NaN NaN NaN NaN \n", + "4401 NaN NaN NaN NaN NaN \n", "\n", - " phase_name max_waveheight max_windspeed transit_speed num_vessels \n", - "0 NaN NaN NaN NaN NaN \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", - "... ... ... ... ... ... \n", - "4405 NaN NaN NaN NaN NaN \n", - "4406 NaN NaN NaN NaN NaN \n", - "4407 NaN NaN NaN NaN 2.0 \n", - "4408 NaN NaN NaN NaN NaN \n", - "4409 NaN NaN NaN NaN 3.0 \n", + " max_windspeed transit_speed num_vessels \n", + "0 NaN NaN NaN \n", + "1 NaN NaN NaN \n", + "2 NaN NaN NaN \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "... ... ... ... \n", + "4397 NaN NaN NaN \n", + "4398 NaN NaN NaN \n", + "4399 NaN NaN 2.0 \n", + "4400 NaN NaN NaN \n", + "4401 NaN NaN 3.0 \n", "\n", - "[4410 rows x 16 columns]" + "[4402 rows x 16 columns]" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -525,7 +538,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -539,7 +552,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.9.15" } }, "nbformat": 4, diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml index b2ffc08e..c43de907 100644 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -1,6 +1,6 @@ # Site + Plant Parameters site: - depth: 500 + depth: 900 distance: 100 distance_to_landfall: 100 plant: @@ -40,7 +40,6 @@ design_phases: - ArraySystemDesign - ExportSystemDesign - SemiTautMooringSystemDesign -# OffshoreFloatingSubstationDesign takes the mooring system unit cost of SemiTautMooringSystemDesign, so that needs to be run first - OffshoreFloatingSubstationDesign - SemiSubmersibleDesign install_phases: @@ -49,6 +48,5 @@ install_phases: MooredSubInstallation: 0 MooringSystemInstallation: 0 FloatingSubstationInstallation: 0 - #TurbineInstallation: 0 # We assume the turbine is installed at quayside onto the substructure so the necessary steps are in 'MooredSubInstallation' # Project Inputs turbine: 12MW_generic From ba3ab5db0e07c4913220197cfafc16fa99981b31 Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Mon, 6 Feb 2023 11:24:41 -0700 Subject: [PATCH 043/240] corrected that all moorings from farm were being added to each substation. now just one mooring system per oss. --- ORBIT/phases/install/oss_install/floating.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index cdbf7558..e554764d 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -44,7 +44,11 @@ class FloatingSubstationInstallation(InstallPhase): #"mooring_cost": "USD", "towing_speed": "int | float (optional, default: 6 km/h)" }, - "mooring_system": {"system_cost": "USD"}, + "mooring_system": { + #"system_cost": "USD", "}, # system cost is for all moorings in the whole farm, so you dont want this to be added to each substation + "num_lines", "int", + "line_cost", "USD", + "anchor_cost", "USD" } def __init__(self, config, weather=None, **kwargs): @@ -90,13 +94,15 @@ def system_capex(self): substructure = self.config["offshore_substation_substructure"][ "unit_cost" ] - mooring = self.config["mooring_system"][ - "system_cost" - ] + # mooring system + num_mooring_lines = self.config["mooring_system"]["num_lines"] + line_cost = self.config["mooring_system"]["line_cost"] + anchor_cost = self.config["mooring_system"]["anchor_cost"] + mooring_system_for_each_oss = num_mooring_lines*(line_cost + anchor_cost) print('topside: ' + str(topside)) print('oss substructure' + str(substructure)) print('mooring system' + str(mooring)) - return self.num_substations * (topside + substructure + mooring) + return self.num_substations * (topside + substructure + mooring_system_for_each_oss) def initialize_substructure_production(self): """ From 9ecee38c5d0afd94b3477f3039e4eb2ab8e8be1b Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Mon, 6 Feb 2023 11:31:39 -0700 Subject: [PATCH 044/240] fixed syntax errors --- ORBIT/phases/install/oss_install/floating.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index e554764d..cc6fa94d 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -48,8 +48,8 @@ class FloatingSubstationInstallation(InstallPhase): #"system_cost": "USD", "}, # system cost is for all moorings in the whole farm, so you dont want this to be added to each substation "num_lines", "int", "line_cost", "USD", - "anchor_cost", "USD" - } + "anchor_cost", "USD"} + } def __init__(self, config, weather=None, **kwargs): """ @@ -101,7 +101,7 @@ def system_capex(self): mooring_system_for_each_oss = num_mooring_lines*(line_cost + anchor_cost) print('topside: ' + str(topside)) print('oss substructure' + str(substructure)) - print('mooring system' + str(mooring)) + print('mooring system' + str(mooring_system_for_each_oss)) return self.num_substations * (topside + substructure + mooring_system_for_each_oss) def initialize_substructure_production(self): From 82095700cb56636126b9638df082dc55d4e1e06d Mon Sep 17 00:00:00 2001 From: Becca Rolph Date: Mon, 6 Feb 2023 11:38:23 -0700 Subject: [PATCH 045/240] updated example notebooks --- ...5. Example Floating Project-SemiTaut.ipynb | 19 +++++++++++++------ examples/5. Example Floating Project.ipynb | 4 ++-- 2 files changed, 15 insertions(+), 8 deletions(-) diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index 5d1756d8..aa999ce7 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, @@ -110,10 +117,10 @@ "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n", "topside: 47826750.0\n", "oss substructure1912800.0\n", - "mooring system327467880.0\n", + "mooring system6549357.6\n", "topside: 47826750.0\n", "oss substructure1912800.0\n", - "mooring system327467880.0\n" + "mooring system6549357.6\n" ] } ], @@ -139,10 +146,10 @@ "output_type": "stream", "text": [ "Installation CapEx: 300 M\n", - "System CapEx: 1873 M\n", + "System CapEx: 1231 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 3491 M\n", + "Total CapEx: 2850 M\n", "\n", "Installation Time: 22581 h\n" ] @@ -177,7 +184,7 @@ " 'Export System': 103712476.9152,\n", " 'Substructure': 630709636.6,\n", " 'Mooring System': 327467880.0,\n", - " 'Offshore Substation': 754414860.0,\n", + " 'Offshore Substation': 112577815.2,\n", " 'Array System Installation': 22844527.89607126,\n", " 'Export System Installation': 135112258.0470523,\n", " 'Substructure Installation': 78569120.05327243,\n", @@ -209,7 +216,7 @@ " 'Export System': 172.854128192,\n", " 'Substructure': 1051.1827276666668,\n", " 'Mooring System': 545.7798,\n", - " 'Offshore Substation': 1257.3581,\n", + " 'Offshore Substation': 187.629692,\n", " 'Array System Installation': 38.07421316011877,\n", " 'Export System Installation': 225.18709674508716,\n", " 'Substructure Installation': 130.9485334221207,\n", diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 0c216779..8c8c12d6 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -175,7 +175,7 @@ " 'Project': 252.08333333333334}" ] }, - "execution_count": 9, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } From ff6ebd97d4277a78d69c1524d11ce9751c44b5f1 Mon Sep 17 00:00:00 2001 From: Shields Date: Tue, 21 Feb 2023 15:50:27 -0700 Subject: [PATCH 046/240] Added flag for floating OSS in ElectricalDesign (zero out monopile cost) --- ORBIT/phases/design/electrical_export.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 42f5011d..23062c5c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -28,6 +28,7 @@ class ElectricalDesign(CableSystem): }, }, "substation_design": { + "floating_oss": "T/F (optional, default: False)", "mpt_cost_rate": "USD/MW (optional)", "topside_fab_cost_rate": "USD/t (optional)", "topside_design_cost": "USD (optional)", @@ -85,6 +86,7 @@ def __init__(self, config, **kwargs): self._distance_to_interconnection = 3 # SUBSTATION + self._floating_oss = config["substation_design"]["floating_oss"] self._outputs = {} def run(self): @@ -432,7 +434,11 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass**0.5574 + if self._floating_oss == False: + substructure_pile_mass = 8 * substructure_mass**0.5574 + else: + substructure_pile_mass = 0 # No piles for floating OSS + print('OSS sub mass', substructure_pile_mass) self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate From f930b22ff0199895285260913a1edfa3ddaf601b Mon Sep 17 00:00:00 2001 From: Shields Date: Tue, 21 Feb 2023 15:54:01 -0700 Subject: [PATCH 047/240] Remove print statement --- ORBIT/phases/design/electrical_export.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 23062c5c..1d127773 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -438,7 +438,7 @@ def calc_substructure_mass_and_cost(self): substructure_pile_mass = 8 * substructure_mass**0.5574 else: substructure_pile_mass = 0 # No piles for floating OSS - print('OSS sub mass', substructure_pile_mass) + self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate From 8ca374cea55317ff21b836be6d64755c2cf50364 Mon Sep 17 00:00:00 2001 From: asharma Date: Tue, 21 Feb 2023 23:14:43 -0700 Subject: [PATCH 048/240] allow floating_oss to be optional --- ORBIT/phases/design/electrical_export.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 1d127773..fd556cb6 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -86,7 +86,11 @@ def __init__(self, config, **kwargs): self._distance_to_interconnection = 3 # SUBSTATION - self._floating_oss = config["substation_design"]["floating_oss"] + try: + self._floating_oss = config["substation_design"]["floating_oss"] + except KeyError: + self._floating_oss = False + self._outputs = {} def run(self): From 2000caa4f9f485ed70b551905f05b06ed1b43cdc Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 22 Feb 2023 11:26:49 -0700 Subject: [PATCH 049/240] onshore docs --- ORBIT/phases/design/_cables.py | 11 ++++++----- ORBIT/phases/design/electrical_export.py | 3 +-- docs/source/phases/design/doc_ElectricalDesign.rst | 8 ++++++++ tests/phases/design/test_cable.py | 12 ++++++------ tests/phases/design/test_electrical_design.py | 7 ++++--- tests/phases/design/test_export_system_design.py | 4 ++-- 6 files changed, 27 insertions(+), 18 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 807e763f..bdc232ae 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -87,16 +87,17 @@ def __init__(self, cable_specs, **kwargs): # Calc additional cable specs if self.cable_type == "HVAC": - self.calc_char_impedance(**kwargs) - self.calc_power_factor() self.calc_compensation_factor() + + self.calc_char_impedance(**kwargs) + self.calc_power_factor() self.calc_cable_power() def calc_char_impedance(self): """ Calculate characteristic impedance of cable. """ - if self.cable_type == "HVDC-monopole" or "HVDC-bipole": + if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: self.char_impedance = 0 else: conductance = 1 / self.ac_resistance @@ -116,7 +117,7 @@ def calc_power_factor(self): Calculate power factor. """ - if self.cable_type == "HVDC-monopole" or "HVDC-bipole": + if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: self.power_factor = 0 else: phase_angle = math.atan( @@ -129,7 +130,7 @@ def calc_cable_power(self): Calculate maximum power transfer through 3-phase cable in :math:`MW`. """ - if self.cable_type == "HVDC-monopole" or "HVDC-bipole": + if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: self.cable_power = ( self.current_capacity * self.rated_voltage * 2 / 1000 ) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 42f5011d..51a8c7f6 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -305,7 +305,6 @@ def substation_cost(self): + self.switchgear_cost + self.converter_cost + self.dc_breaker_cost - + self.topside_cost + self.ancillary_system_cost + self.land_assembly_cost ) @@ -361,7 +360,7 @@ def calc_dc_breaker_cost(self): else: num_dc_breaker = self.num_cables self.dc_breaker_cost = num_dc_breaker * self._design.get( - "dc_breaker_cost", 40000000 + "dc_breaker_cost", 4000000 ) # 4e6 def calc_ancillary_system_cost(self): diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index d2fae8ff..7607b7d8 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -75,6 +75,14 @@ crossing is $500,000. This cost includes materials, installation, etc. Crossing cost is calculated as product of number of crossings and unit cost. +Onshore Cost +--------- +The onshore cost is considered to be the minimum cost of interconnection. This includes +the major required hardware for a cable connection onshore. For HVDC cables, it includes +the converter cost, DC breaker cost, and transformer cost. For HVAC, it includes the +transformer cost and switchgear cost. + + Design Result --------- The result of this design module (:py:attr:`design_result`) includes the diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index 448a09c2..e3e972e2 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -11,7 +11,6 @@ import numpy as np import pytest - from ORBIT.phases.design._cables import Cable, Plant cables = { @@ -124,15 +123,16 @@ def test_power_factor(): if any((a < 0) | (a > 1) for a in results): raise Exception("Invalid Power Factor.") + def test_cable_power(): cable = Cable(cables["passes"]) - assert cable.cable_power == pytest.approx(34.1341, abs=2e-1) - + assert cable.cable_power == pytest.approx(34.1341, abs=2e-1) + c = copy.deepcopy(cables["passes"]) - c["cable_type"] = "HVDC" - cable = Cable(c) + c["cable_type"] = "HVDC-monopole" + cable = Cable(c) print(c) - assert cable.cable_power == pytest.approx(39.6,abs=2e-1) + assert cable.cable_power == pytest.approx(39.6, abs=2e-1) @pytest.mark.parametrize( diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 9c7bef85..605ea434 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -123,7 +123,7 @@ def test_hvdc_substation(): assert o.shunt_reactor_cost == 0 assert o.dc_breaker_cost != 0 assert o.switchgear_cost == 0 - assert o.num_converters / o.num_cables == 2 + assert o.num_cables / o.num_converters == 2 config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} @@ -201,7 +201,7 @@ def test_cable_mass(): length = (0.02 + 3 + 30) * 1.01 mass = length * export.cable.linear_density - assert export.mass == pytest.approx(mass, abs=1e-10) + assert export.mass == pytest.approx(mass, abs=1e-6) def test_total_cable(): @@ -316,7 +316,8 @@ def test_cost_crossing(): cross = deepcopy(config) cross["export_system_design"]["cable_crossings"] = { - "crossing_unit_cost": 100000 + "crossing_number": 1, + "crossing_unit_cost": 100000, } cross_sim = ElectricalDesign(cross) diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 9db78fed..94d00819 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -8,7 +8,6 @@ from copy import deepcopy import pytest - from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ExportSystemDesign @@ -29,9 +28,10 @@ def test_export_system_creation(): def test_number_cables(): export = ExportSystemDesign(config) + print(export.config) export.run() - assert export.num_cables == 11 + assert export.num_cables == 9 def test_cable_length(): From 4090057433bb1507d89bc60bb2cbd1e21c22ca03 Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Wed, 22 Feb 2023 19:34:00 -0700 Subject: [PATCH 050/240] fix bug that causes error with >2 substations --- ORBIT/phases/design/array_system_design.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 1a25ab9f..ba95c99e 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -1017,7 +1017,7 @@ def _create_windfarm_layout(self): self.sections_bury_speeds[ string, order ] = data.bury_speed.values[order] - i += string + 1 + i = string + 1 # Ensure any point in array without a turbine is set to None no_turbines = self.location_data_x == 0 From 5765f25a97dd286da8a7dc04e5b08259ca96d330 Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Wed, 22 Feb 2023 19:34:40 -0700 Subject: [PATCH 051/240] fix issue with unnecessary commas in error message --- ORBIT/phases/design/array_system_design.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index ba95c99e..be00adbb 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -851,8 +851,8 @@ def _initialize_custom_data(self): missing = set(self.COLUMNS).difference(self.location_data.columns) if missing: raise ValueError( - "The following columns must be included in the location ", - f"data: {missing}", + "The following columns must be included in the location " + f"data: {missing}" ) self._format_windfarm_data() @@ -885,9 +885,9 @@ def _initialize_custom_data(self): # Ensure the number of turbines matches what's expected if self.location_data.shape[0] != self.system.num_turbines: raise ValueError( - "The provided number of turbines ", - f"({self.location_data.shape[0]}) does not match the plant ", - f"data ({self.system.num_turbines}).", + "The provided number of turbines " + f"({self.location_data.shape[0]}) does not match the plant " + f"data ({self.system.num_turbines})." ) n_coords = self.location_data.groupby( From b54a4a8cf4834704b295ff4ef5dab7a9ba713502 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Thu, 23 Feb 2023 09:32:13 -0700 Subject: [PATCH 052/240] Updated outdated tests. --- tests/phases/design/test_export_system_design.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 94d00819..7039bb5b 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -48,7 +48,7 @@ def test_cable_mass(): length = (0.02 + 3 + 30) * 1.01 mass = length * export.cable.linear_density - assert export.mass == mass + assert export.mass == pytest.approx(mass, abs=1e-10) def test_total_cable(): @@ -58,8 +58,8 @@ def test_total_cable(): length = 0.02 + 3 + 30 length += length * 0.01 mass = length * export.cable.linear_density - assert export.total_mass == pytest.approx(mass * 11, abs=1e-10) - assert export.total_length == pytest.approx(length * 11, abs=1e-10) + assert export.total_mass == pytest.approx(mass * 9, abs=1e-10) + assert export.total_length == pytest.approx(length * 9, abs=1e-10) def test_cables_property(): @@ -99,7 +99,7 @@ def test_design_result(): cables = export.design_result["export_system"]["cable"] assert cables["sections"] == [export.length] - assert cables["number"] == 11 + assert cables["number"] == 9 assert cables["linear_density"] == export.cable.linear_density From c99b94c5333da5ea7e4005cfa658d7ac7a1fb722 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 23 Feb 2023 16:33:38 +0000 Subject: [PATCH 053/240] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- LICENSE | 2 +- ORBIT/_version.py | 168 ++++++---- ORBIT/api/wisdem.py | 1 - ORBIT/config.py | 1 - ORBIT/core/cargo.py | 1 - ORBIT/core/components.py | 1 - ORBIT/core/defaults/__init__.py | 1 - ORBIT/core/environment.py | 2 - ORBIT/core/exceptions.py | 1 - ORBIT/core/library.py | 2 +- ORBIT/core/logic/vessel_logic.py | 6 - ORBIT/core/port.py | 1 - ORBIT/core/supply_chain.py | 1 - ORBIT/core/vessel.py | 2 - ORBIT/manager.py | 20 +- ORBIT/parametric.py | 5 +- ORBIT/phases/base.py | 2 - ORBIT/phases/design/__init__.py | 1 - ORBIT/phases/design/array_system_design.py | 4 - ORBIT/phases/design/export_system_design.py | 2 - ORBIT/phases/design/monopile_design.py | 7 +- ORBIT/phases/design/mooring_system_design.py | 6 +- ORBIT/phases/design/oss_design.py | 3 +- .../phases/design/scour_protection_design.py | 3 +- .../phases/design/semi_submersible_design.py | 8 +- ORBIT/phases/design/spar_design.py | 7 +- ORBIT/phases/install/cable_install/array.py | 5 - ORBIT/phases/install/cable_install/common.py | 1 - ORBIT/phases/install/install_phase.py | 1 - ORBIT/phases/install/jacket_install/common.py | 1 - .../phases/install/jacket_install/standard.py | 9 +- .../phases/install/monopile_install/common.py | 2 - .../install/monopile_install/standard.py | 9 +- .../phases/install/mooring_install/mooring.py | 3 - ORBIT/phases/install/oss_install/common.py | 2 - ORBIT/phases/install/oss_install/floating.py | 9 +- ORBIT/phases/install/oss_install/standard.py | 3 - .../quayside_assembly_tow/gravity_base.py | 3 - .../install/quayside_assembly_tow/moored.py | 3 - .../scour_protection_install/standard.py | 1 - .../phases/install/turbine_install/common.py | 1 - .../install/turbine_install/standard.py | 4 - ORBIT/supply_chain.py | 245 +++++++------- docs/Makefile | 2 +- docs/conf.py | 4 +- library/cables/XLPE_500mm_220kV.yaml | 2 +- library/cables/XLPE_630mm_220kV.yaml | 2 +- library/cables/XLPE_800mm_220kV.yaml | 2 +- library/turbines/15MW_generic.yaml | 2 +- misc/supply_chain_plots.py | 183 +++++++---- templates/design_module.py | 74 +++-- tests/api/test_wisdem_api.py | 3 - tests/conftest.py | 9 - tests/core/test_environment.py | 1 - tests/core/test_library.py | 2 - tests/core/test_port.py | 3 - .../phases/design/test_array_system_design.py | 2 - tests/phases/design/test_cable.py | 1 - tests/phases/design/test_electrical_design.py | 10 - .../design/test_export_system_design.py | 1 - tests/phases/design/test_monopile_design.py | 6 - .../design/test_mooring_system_design.py | 5 - tests/phases/design/test_oss_design.py | 4 - .../design/test_scour_protection_design.py | 1 - .../design/test_semisubmersible_design.py | 4 - tests/phases/design/test_spar_design.py | 4 - .../cable_install/test_array_install.py | 10 - .../install/cable_install/test_cable_tasks.py | 3 - .../cable_install/test_export_install.py | 10 - .../jacket_install/test_jacket_install.py | 10 - .../monopile_install/test_monopile_install.py | 9 - .../monopile_install/test_monopile_tasks.py | 3 - .../mooring_install/test_mooring_install.py | 5 - .../install/oss_install/test_oss_install.py | 10 - .../install/oss_install/test_oss_tasks.py | 3 - .../quayside_assembly_tow/test_common.py | 4 - .../test_gravity_based.py | 3 - .../quayside_assembly_tow/test_moored.py | 3 - .../test_scour_protection.py | 5 - tests/phases/install/test_install_phase.py | 3 - .../turbine_install/test_turbine_install.py | 12 - .../turbine_install/test_turbine_tasks.py | 3 - tests/phases/test_base.py | 5 - tests/test_config_management.py | 3 - .../test_design_install_phase_interactions.py | 5 +- tests/test_parametric.py | 9 +- tests/test_project_manager.py | 44 +-- versioneer.py | 298 +++++++++++------- 88 files changed, 625 insertions(+), 722 deletions(-) diff --git a/LICENSE b/LICENSE index dbb692d8..1c0c15ea 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ - Copyright (c) 2020 Alliance for Sustainable Energy, LLC + Copyright (c) 2020 Alliance for Sustainable Energy, LLC Apache License Version 2.0, January 2004 diff --git a/ORBIT/_version.py b/ORBIT/_version.py index fa1e63bc..f03f6681 100644 --- a/ORBIT/_version.py +++ b/ORBIT/_version.py @@ -1,4 +1,3 @@ - # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -10,11 +9,11 @@ """Git implementation of _version.py.""" -import errno import os import re -import subprocess import sys +import errno +import subprocess def get_keywords(): @@ -58,17 +57,20 @@ class NotThisMethod(Exception): def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" + def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f + return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands, args, cwd=None, verbose=False, hide_stderr=False, env=None +): """Call the given command(s).""" assert isinstance(commands, list) p = None @@ -76,10 +78,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break except EnvironmentError: e = sys.exc_info()[1] @@ -116,16 +121,22 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -181,7 +192,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -190,7 +201,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = set([r for r in refs if re.search(r"\d", r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -198,19 +209,26 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] + r = ref[len(tag_prefix) :] if verbose: print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} + return { + "version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": None, + "date": date, + } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} + return { + "version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": "no suitable tags", + "date": None, + } @register_vcs_handler("git", "pieces_from_vcs") @@ -225,8 +243,9 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + out, rc = run_command( + GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True + ) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -234,10 +253,19 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = run_command( + GITS, + [ + "describe", + "--tags", + "--dirty", + "--always", + "--long", + "--match", + "%s*" % tag_prefix, + ], + cwd=root, + ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -260,17 +288,18 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) + pieces["error"] = ( + "unable to parse git-describe output: '%s'" % describe_out + ) return pieces # tag @@ -279,10 +308,12 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) + pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -293,13 +324,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = run_command( + GITS, ["rev-list", "HEAD", "--count"], cwd=root + ) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ + 0 + ].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -330,8 +363,7 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -445,11 +477,13 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} + return { + "version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None, + } if not style or style == "default": style = "pep440" # the default @@ -469,9 +503,13 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} + return { + "version": rendered, + "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], + "error": None, + "date": pieces.get("date"), + } def get_versions(): @@ -485,8 +523,9 @@ def get_versions(): verbose = cfg.verbose try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) + return git_versions_from_keywords( + get_keywords(), cfg.tag_prefix, verbose + ) except NotThisMethod: pass @@ -495,13 +534,16 @@ def get_versions(): # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): + for i in cfg.versionfile_source.split("/"): root = os.path.dirname(root) except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None, + } try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) @@ -515,6 +557,10 @@ def get_versions(): except NotThisMethod: pass - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 8320e99c..63fd1460 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -7,7 +7,6 @@ import openmdao.api as om - from ORBIT import ProjectManager diff --git a/ORBIT/config.py b/ORBIT/config.py index 4a50732d..5a416b43 100644 --- a/ORBIT/config.py +++ b/ORBIT/config.py @@ -8,7 +8,6 @@ import yaml from yaml import Dumper - from ORBIT.core import loader diff --git a/ORBIT/core/cargo.py b/ORBIT/core/cargo.py index d02ab03f..0f618b4e 100644 --- a/ORBIT/core/cargo.py +++ b/ORBIT/core/cargo.py @@ -6,7 +6,6 @@ class Cargo(Object): - def __repr__(self): return self.type diff --git a/ORBIT/core/components.py b/ORBIT/core/components.py index e4e3792c..dec26889 100644 --- a/ORBIT/core/components.py +++ b/ORBIT/core/components.py @@ -6,7 +6,6 @@ __email__ = "jake.nunemaker@nrel.gov" import simpy - from ORBIT.core.defaults import process_times as pt from ORBIT.core.exceptions import ItemNotFound, InsufficientCable diff --git a/ORBIT/core/defaults/__init__.py b/ORBIT/core/defaults/__init__.py index 7df591ec..1cc75bae 100644 --- a/ORBIT/core/defaults/__init__.py +++ b/ORBIT/core/defaults/__init__.py @@ -8,7 +8,6 @@ import os import yaml - from ORBIT.core.library import loader DIR = os.path.split(__file__)[0] diff --git a/ORBIT/core/environment.py b/ORBIT/core/environment.py index 4654ec13..bade7d84 100644 --- a/ORBIT/core/environment.py +++ b/ORBIT/core/environment.py @@ -88,7 +88,6 @@ def standarize_state_inputs(self, _in): names = [] for name in list(_in.dtype.names): - if "windspeed" in name: try: val = name.split("_")[1].replace("m", "") @@ -139,7 +138,6 @@ def resolve_windspeed_constraints(self, constraints): return {**constraints, "windspeed": list(ws.values())[0]} for k, v in ws.items(): - if k == "windspeed": height = self.simplify_num(self.default_height) diff --git a/ORBIT/core/exceptions.py b/ORBIT/core/exceptions.py index 8d7d0ca4..ec9fa5d6 100644 --- a/ORBIT/core/exceptions.py +++ b/ORBIT/core/exceptions.py @@ -31,7 +31,6 @@ def __init__(self, vessel, component): ) def __str__(self): - return self.message diff --git a/ORBIT/core/library.py b/ORBIT/core/library.py index 6f771cc0..c8217b15 100644 --- a/ORBIT/core/library.py +++ b/ORBIT/core/library.py @@ -38,12 +38,12 @@ import yaml import pandas as pd from yaml import Dumper - from ORBIT.core.exceptions import LibraryItemNotFoundError ROOT = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../..")) default_library = os.path.join(ROOT, "library") + # Need a custom loader to read in scientific notation correctly class CustomSafeLoader(yaml.SafeLoader): def construct_python_tuple(self, node): diff --git a/ORBIT/core/logic/vessel_logic.py b/ORBIT/core/logic/vessel_logic.py index b27a3e78..daa4a707 100644 --- a/ORBIT/core/logic/vessel_logic.py +++ b/ORBIT/core/logic/vessel_logic.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core.defaults import process_times as pt from ORBIT.core.exceptions import ItemNotFound, MissingComponent @@ -149,7 +148,6 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): transit_time = vessel.transit_time(distance) while True: - if vessel.at_port: vessel.submit_debug_log(message=f"{vessel} is at port.") @@ -262,16 +260,13 @@ def get_list_of_items_from_port(vessel, port, items, **kwargs): proposed_mass = vessel.storage.current_cargo_mass + total_mass if vessel.storage.current_cargo_mass == 0: - if proposed_deck_space > vessel.storage.max_deck_space: - msg = ( f"Warning: '{vessel}' Deck Space Capacity Exceeded" ) vessel.submit_debug_log(message=msg) if proposed_mass > vessel.storage.max_cargo_mass: - msg = ( f"Warning: '{vessel}' Cargo Mass Capacity Exceeded" ) @@ -332,7 +327,6 @@ def shuttle_items_to_queue_wait( n = 0 while n < assigned: - vessel.submit_debug_log(message=f"{vessel} is at port.") # Get list of items diff --git a/ORBIT/core/port.py b/ORBIT/core/port.py index dbfc152a..c24ccfa6 100644 --- a/ORBIT/core/port.py +++ b/ORBIT/core/port.py @@ -7,7 +7,6 @@ import simpy - from ORBIT.core.exceptions import ItemNotFound diff --git a/ORBIT/core/supply_chain.py b/ORBIT/core/supply_chain.py index 0f2f3e1a..6f271c9b 100644 --- a/ORBIT/core/supply_chain.py +++ b/ORBIT/core/supply_chain.py @@ -41,7 +41,6 @@ def __init__( @process def start(self): - n = 0 while n < self.num: yield self.task( diff --git a/ORBIT/core/vessel.py b/ORBIT/core/vessel.py index 88c823a4..c952e905 100644 --- a/ORBIT/core/vessel.py +++ b/ORBIT/core/vessel.py @@ -15,7 +15,6 @@ WindowNotFound, AgentNotRegistered, ) - from ORBIT.core.components import ( Crane, JackingSys, @@ -86,7 +85,6 @@ def submit_action_log(self, action, duration, **kwargs): def task_wrapper( self, name, duration, constraints={}, suspendable=False, **kwargs ): - duration /= self.avail yield self.task(name, duration, constraints, suspendable, **kwargs) diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 5f85465d..bd229183 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -14,10 +14,9 @@ from itertools import product import numpy as np +import ORBIT import pandas as pd from benedict import benedict - -import ORBIT from ORBIT.phases import DesignPhase, InstallPhase from ORBIT.core.library import ( initialize_library, @@ -169,14 +168,12 @@ def run(self, **kwargs): self._print_warnings() def _print_warnings(self): - try: df = pd.DataFrame(self.logs) df = df.loc[~df["message"].isnull()] df = df.loc[df["message"].str.contains("Exceeded")] for msg in df["message"].unique(): - idx = df.loc[df["message"] == msg].index[0] phase = df.loc[idx, "phase"] print(f"{phase}:\n\t {msg}") @@ -207,7 +204,9 @@ def register_design_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._design_phases]: - raise ValueError(f"A phase with name '{phase.__name__}' already exists.") + raise ValueError( + f"A phase with name '{phase.__name__}' already exists." + ) if len(re.split("[_ ]", phase.__name__)) > 1: raise ValueError(f"Registered phase name must not include a '_'.") @@ -231,7 +230,9 @@ def register_install_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._install_phases]: - raise ValueError(f"A phase with name '{phase.__name__}' already exists.") + raise ValueError( + f"A phase with name '{phase.__name__}' already exists." + ) if len(re.split("[_ ]", phase.__name__)) > 1: raise ValueError(f"Registered phase name must not include a '_'.") @@ -455,7 +456,6 @@ def remove_keys(cls, left, right): right = {k: right[k] for k in set(new).intersection(set(right))} for k, val in right.items(): - if isinstance(new.get(k, None), dict) and isinstance(val, dict): new[k] = cls.remove_keys(new[k], val) @@ -502,7 +502,6 @@ def create_config_for_phase(self, phase): @property def phase_ends(self): - ret = {} for k, t in self.phase_times.items(): try: @@ -695,7 +694,6 @@ def run_multiple_phases_overlapping(self, phases, **kwargs): # Run defined for name, start in defined.items(): - _, logs = self.run_install_phase(name, start, **kwargs) if logs is None: @@ -729,7 +727,6 @@ def run_dependent_phases(self, _phases, zero, **kwargs): skipped = {} while True: - phases = {**phases, **skipped} if not phases: break @@ -828,7 +825,6 @@ def _parse_install_phase_values(self, phases): depends = {} for k, v in phases.items(): - if isinstance(v, (int, float)): defined[k] = ceil(v) @@ -1106,7 +1102,6 @@ def progress_summary(self): summary = {} for i in range(1, len(self.month_bins)): - unique, counts = np.unique( arr["progress"][dig == i], return_counts=True ) @@ -1142,7 +1137,6 @@ def phase_dates(self): dates = {} for phase, _start in self.config["install_phases"].items(): - start = dt.datetime.strptime(_start, self.date_format_short) end = start + dt.timedelta(hours=ceil(self.phase_times[phase])) diff --git a/ORBIT/parametric.py b/ORBIT/parametric.py index 6895400c..634b842c 100644 --- a/ORBIT/parametric.py +++ b/ORBIT/parametric.py @@ -15,9 +15,8 @@ import pandas as pd import statsmodels.api as sm from yaml import Loader -from benedict import benedict - from ORBIT import ProjectManager +from benedict import benedict class ParametricManager: @@ -202,7 +201,6 @@ def from_config(cls, data): funcs = {} for k, v in outputs.items(): - split = v.split("[") attr = split[0] @@ -298,7 +296,6 @@ def as_string(self): out = "" for i, (k, v) in enumerate(params.items()): - if i == 0: pre = "" diff --git a/ORBIT/phases/base.py b/ORBIT/phases/base.py index 2e9b539d..1b39d91a 100644 --- a/ORBIT/phases/base.py +++ b/ORBIT/phases/base.py @@ -10,7 +10,6 @@ from copy import deepcopy from benedict import benedict - from ORBIT.core.library import initialize_library, extract_library_data from ORBIT.core.exceptions import MissingInputs @@ -70,7 +69,6 @@ def _check_keys(cls, expected, config): missing = [] for k, v in expected.items(): - if isinstance(k, str) and "variable" in k: continue diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 120d1e83..8ef543e0 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -16,4 +16,3 @@ from .mooring_system_design import MooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign -from .electrical_export import ElectricalDesign diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 1a25ab9f..5298ebab 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -12,7 +12,6 @@ import numpy as np import pandas as pd import matplotlib.pyplot as plt - from ORBIT.core.library import export_library_specs, extract_library_specs from ORBIT.phases.design._cables import Plant, CableSystem @@ -567,7 +566,6 @@ def plot_array_system( for i, row in enumerate(self.sections_cables): for cable, width in zip(max_string, string_widths): - ix_to_plot = np.where(row == cable)[0] if ix_to_plot.size == 0: continue @@ -795,7 +793,6 @@ def create_project_csv(self, save_name): export_library_specs("cables", save_name, rows, file_ext="csv") def _format_windfarm_data(self): - # Separate the OSS data where substaion_id is equal to id substation_filter = ( self.location_data.substation_id == self.location_data.id @@ -1039,7 +1036,6 @@ def _create_windfarm_layout(self): self.sections_distance = self._compute_haversine_distance() def run(self): - self._initialize_cables() self.create_strings() self._initialize_custom_data() diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 6c6ae0a0..bf7af015 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -6,7 +6,6 @@ __email__ = "robert.hammond@nrel.gov" import numpy as np - from ORBIT.phases.design._cables import CableSystem @@ -213,7 +212,6 @@ def design_result(self): } for name, cable in self.cables.items(): - output["export_system"]["cable"] = { "linear_density": cable.linear_density, "sections": [self.length], diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index ab1e5349..082b3a9c 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -9,7 +9,6 @@ from math import pi, log from scipy.optimize import fsolve - from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase @@ -230,7 +229,7 @@ def design_transition_piece(self, D_p, t_p, **kwargs): "diameter": D_tp, "mass": m_tp, "length": L_tp, - "deck_space": D_tp ** 2, + "deck_space": D_tp**2, "unit_cost": m_tp * self.tp_steel_cost, } @@ -355,7 +354,7 @@ def pile_mass(Dp, tp, Lt, **kwargs): """ density = kwargs.get("monopile_density", 7860) # kg/m3 - volume = (pi / 4) * (Dp ** 2 - (Dp - tp) ** 2) * Lt + volume = (pi / 4) * (Dp**2 - (Dp - tp) ** 2) * Lt mass = density * volume / 907.185 return mass @@ -560,7 +559,7 @@ def calculate_thrust_coefficient(rated_windspeed): """ ct = min( - [3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed ** 2), 1] + [3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed**2), 1] ) return ct diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 383a4924..0dcf67d8 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -76,7 +76,7 @@ def determine_mooring_line(self): """ tr = self.config["turbine"]["turbine_rating"] - fit = -0.0004 * (tr ** 2) + 0.0132 * tr + 0.0536 + fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 if fit <= 0.09: self.line_diam = 0.09 @@ -99,7 +99,7 @@ def calculate_breaking_load(self): """ self.breaking_load = ( - 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 + 419449 * (self.line_diam**2) + 93415 * self.line_diam - 3577.9 ) def calculate_line_length_mass(self): @@ -115,7 +115,7 @@ def calculate_line_length_mass(self): depth = self.config["site"]["depth"] self.line_length = ( - 0.0002 * (depth ** 2) + 1.264 * depth + 47.776 + fixed + 0.0002 * (depth**2) + 1.264 * depth + 47.776 + fixed ) self.line_mass = self.line_length * self.line_mass_per_m diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index e762eab5..630275ff 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -7,7 +7,6 @@ import numpy as np - from ORBIT.phases.design import DesignPhase @@ -284,7 +283,7 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass ** 0.5574 + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate diff --git a/ORBIT/phases/design/scour_protection_design.py b/ORBIT/phases/design/scour_protection_design.py index efa66b4f..d36b91eb 100644 --- a/ORBIT/phases/design/scour_protection_design.py +++ b/ORBIT/phases/design/scour_protection_design.py @@ -8,7 +8,6 @@ from math import ceil import numpy as np - from ORBIT.phases.design import DesignPhase @@ -115,7 +114,7 @@ def compute_scour_protection_tonnes_to_install(self): r = self.diameter / 2 + self.scour_depth / np.tan(np.radians(self.phi)) volume = ( - np.pi * self.protection_depth * (r ** 2 - (self.diameter / 2) ** 2) + np.pi * self.protection_depth * (r**2 - (self.diameter / 2) ** 2) ) self.scour_protection_tonnes = ceil( diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index 58404a29..7bb34217 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -67,7 +67,7 @@ def stiffened_column_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.9581 * rating ** 2 + 40.89 * rating + 802.09 + mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 return mass @@ -89,7 +89,7 @@ def truss_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = 2.7894 * rating ** 2 + 15.591 * rating + 266.03 + mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 return mass @@ -111,7 +111,7 @@ def heave_plate_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.4397 * rating ** 2 + 21.545 * rating + 177.42 + mass = -0.4397 * rating**2 + 21.545 * rating + 177.42 return mass @@ -133,7 +133,7 @@ def secondary_steel_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.153 * rating ** 2 + 6.54 * rating + 128.34 + mass = -0.153 * rating**2 + 6.54 * rating + 128.34 return mass diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index 224c4a5e..c8b0862e 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -7,7 +7,6 @@ from numpy import exp, log - from ORBIT.phases.design import DesignPhase @@ -72,7 +71,7 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) return mass @@ -113,7 +112,7 @@ def ballast_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @@ -138,7 +137,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 - + 0.196 * (rating ** 0.5) * log(rating) + + 0.196 * (rating**0.5) * log(rating) + 0.00001 * depth * log(depth) ) diff --git a/ORBIT/phases/install/cable_install/array.py b/ORBIT/phases/install/cable_install/array.py index d4d8a181..21120126 100644 --- a/ORBIT/phases/install/cable_install/array.py +++ b/ORBIT/phases/install/cable_install/array.py @@ -10,7 +10,6 @@ import numpy as np from marmot import process - from ORBIT.core import Vessel from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase @@ -237,7 +236,6 @@ def install_array_cables( trench_vessel.at_site = True elif trench_vessel.at_site: - try: # Dig trench along each cable section distance trench_distance = trench_sections.pop(0) @@ -269,7 +267,6 @@ def install_array_cables( vessel.at_site = True elif vessel.at_site: - try: length, num_sections, *extra = sections.pop(0) if extra: @@ -291,12 +288,10 @@ def install_array_cables( break for _ in range(num_sections): - try: section = vessel.cable_storage.get_cable(length) except InsufficientCable: - yield vessel.transit(distance, **kwargs) yield load_cable_on_vessel(vessel, cable, **kwargs) yield vessel.transit(distance, **kwargs) diff --git a/ORBIT/phases/install/cable_install/common.py b/ORBIT/phases/install/cable_install/common.py index f2481138..fa0833f2 100644 --- a/ORBIT/phases/install/cable_install/common.py +++ b/ORBIT/phases/install/cable_install/common.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core.logic import position_onsite from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/install_phase.py b/ORBIT/phases/install/install_phase.py index 97b93c3b..c4d159d6 100644 --- a/ORBIT/phases/install/install_phase.py +++ b/ORBIT/phases/install/install_phase.py @@ -12,7 +12,6 @@ import numpy as np import simpy import pandas as pd - from ORBIT.core import Port, Vessel, Environment from ORBIT.phases import BasePhase from ORBIT.core.defaults import common_costs diff --git a/ORBIT/phases/install/jacket_install/common.py b/ORBIT/phases/install/jacket_install/common.py index 4312bfcf..5cd9feb2 100644 --- a/ORBIT/phases/install/jacket_install/common.py +++ b/ORBIT/phases/install/jacket_install/common.py @@ -5,7 +5,6 @@ from marmot import false, process - from ORBIT.core import Cargo from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/jacket_install/standard.py b/ORBIT/phases/install/jacket_install/standard.py index 2f8f0c55..10391d6e 100644 --- a/ORBIT/phases/install/jacket_install/standard.py +++ b/ORBIT/phases/install/jacket_install/standard.py @@ -7,7 +7,6 @@ import numpy as np import simpy from marmot import process - from ORBIT.core import SubstructureDelivery from ORBIT.core.logic import ( prep_for_site_operations, @@ -111,9 +110,7 @@ def system_capex(self): ] def initialize_substructure_delivery(self): - """ - - """ + """ """ jacket = Jacket(**self.config["jacket"]) @@ -132,7 +129,6 @@ def initialize_substructure_delivery(self): self.supply_chain = self.config.get("jacket_supply_chain", {}) if self.supply_chain.get("enabled", False): - items = [jacket, self.tp] if self.tp else [jacket] delivery_time = self.supply_chain.get( "substructure_delivery_time", 168 @@ -373,7 +369,6 @@ def solo_install_jackets( vessel.at_site = True if vessel.at_site: - if vessel.storage.items: # Prep for jacket install yield prep_for_site_operations( @@ -438,9 +433,7 @@ def install_jackets_from_queue( wtiv.at_site = True if wtiv.at_site: - if queue.vessel: - # Prep for jacket install yield prep_for_site_operations( wtiv, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/monopile_install/common.py b/ORBIT/phases/install/monopile_install/common.py index 04af017a..ee1fcb74 100644 --- a/ORBIT/phases/install/monopile_install/common.py +++ b/ORBIT/phases/install/monopile_install/common.py @@ -7,7 +7,6 @@ from marmot import false, process - from ORBIT.core import Cargo from ORBIT.core.logic import jackdown_if_required from ORBIT.core.defaults import process_times as pt @@ -340,7 +339,6 @@ def install_transition_piece(vessel, tp, **kwargs): yield bolt_transition_piece(vessel, **kwargs) elif connection == "grouted": - yield pump_transition_piece_grout(vessel, **kwargs) yield cure_transition_piece_grout(vessel) diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py index 5a204709..02c7c259 100644 --- a/ORBIT/phases/install/monopile_install/standard.py +++ b/ORBIT/phases/install/monopile_install/standard.py @@ -9,7 +9,6 @@ import numpy as np import simpy from marmot import process - from ORBIT.core import SubstructureDelivery from ORBIT.core.logic import ( prep_for_site_operations, @@ -106,9 +105,7 @@ def system_capex(self): ) * self.config["plant"]["num_turbines"] def initialize_substructure_delivery(self): - """ - - """ + """ """ monopile = Monopile(**self.config["monopile"]) tp = TransitionPiece(**self.config["transition_piece"]) @@ -119,7 +116,6 @@ def initialize_substructure_delivery(self): self.supply_chain = self.config.get("monopile_supply_chain", {}) if self.supply_chain.get("enabled", False): - delivery_time = self.supply_chain.get( "substructure_delivery_time", 168 ) @@ -346,7 +342,6 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): vessel.at_site = True if vessel.at_site: - if vessel.storage.items: # Prep for monopile install yield prep_for_site_operations( @@ -408,9 +403,7 @@ def install_monopiles_from_queue(wtiv, queue, monopiles, distance, **kwargs): wtiv.at_site = True if wtiv.at_site: - if queue.vessel: - # Prep for monopile install yield prep_for_site_operations( wtiv, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/mooring_install/mooring.py b/ORBIT/phases/install/mooring_install/mooring.py index 3b3573b9..c4175f28 100644 --- a/ORBIT/phases/install/mooring_install/mooring.py +++ b/ORBIT/phases/install/mooring_install/mooring.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core import Cargo, Vessel from ORBIT.core.logic import position_onsite, get_list_of_items_from_port from ORBIT.core.defaults import process_times as pt @@ -161,9 +160,7 @@ def install_mooring_systems(vessel, port, distance, depth, systems, **kwargs): vessel.at_site = True if vessel.at_site: - if vessel.storage.items: - system = yield vessel.get_item_from_storage( "MooringSystem", **kwargs ) diff --git a/ORBIT/phases/install/oss_install/common.py b/ORBIT/phases/install/oss_install/common.py index f90128ac..f1c5527b 100644 --- a/ORBIT/phases/install/oss_install/common.py +++ b/ORBIT/phases/install/oss_install/common.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core import Cargo from ORBIT.core.logic import stabilize, jackdown_if_required from ORBIT.core.defaults import process_times as pt @@ -139,7 +138,6 @@ def install_topside(vessel, topside, **kwargs): yield bolt_transition_piece(vessel, **kwargs) elif connection == "grouted": - yield pump_transition_piece_grout(vessel, **kwargs) yield cure_transition_piece_grout(vessel, **kwargs) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 6580e19a..a293363d 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -6,11 +6,10 @@ __email__ = "jake.nunemaker@nrel.gov" -from marmot import Agent, process, le -from marmot._exceptions import AgentNotRegistered - +from marmot import Agent, le, process from ORBIT.core import WetStorage from ORBIT.core.logic import position_onsite +from marmot._exceptions import AgentNotRegistered from ORBIT.phases.install import InstallPhase from ORBIT.phases.install.mooring_install.mooring import ( install_mooring_line, @@ -144,7 +143,6 @@ def initialize_installation_vessel(self): @property def detailed_output(self): - return {} @@ -175,7 +173,6 @@ def install_floating_substations( travel_time = distance / towing_speed for _ in range(number): - start = vessel.env.now yield feed.get() delay = vessel.env.now - start @@ -196,7 +193,7 @@ def install_floating_substations( constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) - for _ in range (3): + for _ in range(3): yield perform_mooring_site_survey(vessel) yield install_mooring_anchor(vessel, depth, "Suction Pile") yield install_mooring_line(vessel, depth) diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index 04038af9..15bcbd79 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -8,7 +8,6 @@ import simpy from marmot import process - from ORBIT.core import Vessel from ORBIT.core.logic import shuttle_items_to_queue, prep_for_site_operations from ORBIT.phases.install import InstallPhase @@ -230,9 +229,7 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): vessel.at_site = True if vessel.at_site: - if queue.vessel: - # Prep for monopile install yield prep_for_site_operations( vessel, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index 4cbd97f6..a02a3547 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -8,7 +8,6 @@ import simpy from marmot import le, process - from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -293,7 +292,6 @@ def transfer_gbf_substructures_from_storage( transit_time = distance / group.transit_speed while True: - start = group.env.now assembly = yield feed.get() delay = group.env.now - start @@ -357,7 +355,6 @@ def install_gravity_base_foundations( n = 0 while n < substructures: if queue.vessel: - start = vessel.env.now if n == 0: vessel.mobilize() diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index c38908b2..8376b274 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -8,7 +8,6 @@ import simpy from marmot import le, process - from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -292,7 +291,6 @@ def transfer_moored_substructures_from_storage( transit_time = distance / group.transit_speed while True: - start = group.env.now assembly = yield feed.get() delay = group.env.now - start @@ -366,7 +364,6 @@ def install_moored_substructures( n = 0 while n < substructures: if queue.vessel: - start = vessel.env.now if n == 0: vessel.mobilize() diff --git a/ORBIT/phases/install/scour_protection_install/standard.py b/ORBIT/phases/install/scour_protection_install/standard.py index 9dd3ee9a..db1c8ce6 100644 --- a/ORBIT/phases/install/scour_protection_install/standard.py +++ b/ORBIT/phases/install/scour_protection_install/standard.py @@ -10,7 +10,6 @@ import simpy from marmot import process - from ORBIT.core import Vessel from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install import InstallPhase diff --git a/ORBIT/phases/install/turbine_install/common.py b/ORBIT/phases/install/turbine_install/common.py index 057ff1bd..f65aa7a3 100644 --- a/ORBIT/phases/install/turbine_install/common.py +++ b/ORBIT/phases/install/turbine_install/common.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core import Cargo from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/turbine_install/standard.py b/ORBIT/phases/install/turbine_install/standard.py index d23515a1..58e273ab 100644 --- a/ORBIT/phases/install/turbine_install/standard.py +++ b/ORBIT/phases/install/turbine_install/standard.py @@ -12,7 +12,6 @@ import numpy as np import simpy from marmot import process - from ORBIT.core import Vessel from ORBIT.core.logic import ( jackdown_if_required, @@ -321,7 +320,6 @@ def solo_install_turbines( vessel.at_site = True if vessel.at_site: - if vessel.storage.items: yield prep_for_site_operations(vessel, **kwargs) @@ -407,9 +405,7 @@ def install_turbine_components_from_queue( wtiv.at_site = True if wtiv.at_site: - if queue.vessel: - # Prep for turbine install yield prep_for_site_operations(wtiv, **kwargs) diff --git a/ORBIT/supply_chain.py b/ORBIT/supply_chain.py index b17e2ae8..8290eae7 100644 --- a/ORBIT/supply_chain.py +++ b/ORBIT/supply_chain.py @@ -5,71 +5,47 @@ from copy import deepcopy -from benedict import benedict -from ORBIT import ProjectManager - +from ORBIT import ProjectManager +from benedict import benedict DEFAULT_MULTIPLIERS = { - "blades": { - "domestic": .026, - "imported": .30 - }, - "nacelle": { - "domestic": .025, - "imported": .10 - }, - "tower": { - "domestic": .04, - "imported": .20, - "tariffs": .25, - }, - "monopile": { - "domestic": .085, - "imported": .28, - "tariffs": .25, - }, - "transition_piece": { - "domestic": .169, - "imported": .17, - "tariffs": .25, - }, - "array_cable": { - "domestic": .19, - "imported": 0. - }, - "export_cable": { - "domestic": .231, - "imported": 0. - }, - "oss_topside": { - "domestic": 0., - "imported": 0. - }, - "oss_substructure": { - "domestic": 0., - "imported": 0. - }, - } - - -TURBINE_CAPEX_SPLIT = { - "blades": 0.135, - "nacelle": 0.274, - "tower": 0.162 + "blades": {"domestic": 0.026, "imported": 0.30}, + "nacelle": {"domestic": 0.025, "imported": 0.10}, + "tower": { + "domestic": 0.04, + "imported": 0.20, + "tariffs": 0.25, + }, + "monopile": { + "domestic": 0.085, + "imported": 0.28, + "tariffs": 0.25, + }, + "transition_piece": { + "domestic": 0.169, + "imported": 0.17, + "tariffs": 0.25, + }, + "array_cable": {"domestic": 0.19, "imported": 0.0}, + "export_cable": {"domestic": 0.231, "imported": 0.0}, + "oss_topside": {"domestic": 0.0, "imported": 0.0}, + "oss_substructure": {"domestic": 0.0, "imported": 0.0}, } +TURBINE_CAPEX_SPLIT = {"blades": 0.135, "nacelle": 0.274, "tower": 0.162} + + LABOR_SPLIT = { "tower": 0.5, "monopile": 0.5, "transition_piece": 0.5, - "oss_topside": 0.5 + "oss_topside": 0.5, } class SupplyChainManager: - def __init__(self, supply_chain_configuration, **kwargs): """ Creates an instance of `SupplyChainManager`. @@ -111,17 +87,17 @@ def pre_process(self, config): """""" # Save original plant design - plant = deepcopy(config['plant']) + plant = deepcopy(config["plant"]) # Run ProjectManager without install phases to generate design results - install_phases = config['install_phases'] - config['install_phases'] = [] + install_phases = config["install_phases"] + config["install_phases"] = [] project = ProjectManager(config) project.run() config = deepcopy(project.config) # Replace calculated plant design with original - config['plant'] = plant + config["plant"] = plant # Run pre ORBIT supply chain adjustments config = self.process_turbine_capex(config) @@ -130,8 +106,8 @@ def pre_process(self, config): config = self.process_offshore_substation_topside_capex(config) # Add install phases back in - config['install_phases'] = install_phases - config['design_phases'] = [] + config["install_phases"] = install_phases + config["design_phases"] = [] return config @@ -154,45 +130,51 @@ def process_turbine_capex(self, config): ORBIT configuration. """ - blade_scenario = self.sc_config['blades'] - nacelle_scenario = self.sc_config['nacelle'] - tower_scenario = self.sc_config['blades'] + blade_scenario = self.sc_config["blades"] + nacelle_scenario = self.sc_config["nacelle"] + tower_scenario = self.sc_config["blades"] blade_mult = self.multipliers["blades"].get(blade_scenario, None) if blade_mult == None: - print(f"Warning: scenario '{blade_scenario}' not found for category 'blades'.") - blade_mult = 0. + print( + f"Warning: scenario '{blade_scenario}' not found for category 'blades'." + ) + blade_mult = 0.0 nacelle_mult = self.multipliers["nacelle"].get(nacelle_scenario, None) if nacelle_mult == None: - print(f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'.") - nacelle_mult = 0. + print( + f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'." + ) + nacelle_mult = 0.0 - raw_cost = config.get('project_parameters.turbine_capex', 1300) - blade_adder = raw_cost * self.turbine_split['blades'] * blade_mult - nacelle_adder = raw_cost * self.turbine_split['nacelle'] * nacelle_mult + raw_cost = config.get("project_parameters.turbine_capex", 1300) + blade_adder = raw_cost * self.turbine_split["blades"] * blade_mult + nacelle_adder = raw_cost * self.turbine_split["nacelle"] * nacelle_mult if tower_scenario == "domestic, imported steel": tower_adder = self.multipliers["tower"]["domestic"] * raw_cost - tower_tariffs = raw_cost * self.turbine_split['tower'] *\ - (1 - self.labor_split['tower']) * self.multipliers["tower"]['tariffs'] + tower_tariffs = ( + raw_cost + * self.turbine_split["tower"] + * (1 - self.labor_split["tower"]) + * self.multipliers["tower"]["tariffs"] + ) else: - tower_tariffs = 0. + tower_tariffs = 0.0 tower_mult = self.multipliers["tower"].get(tower_scenario, None) if tower_mult == None: - print(f"Warning: scenario '{tower_scenario}' not found for category 'tower'.") - tower_mult = 0. + print( + f"Warning: scenario '{tower_scenario}' not found for category 'tower'." + ) + tower_mult = 0.0 - tower_adder = raw_cost * self.turbine_split['tower'] * tower_mult + tower_adder = raw_cost * self.turbine_split["tower"] * tower_mult - config['project_parameters.turbine_capex'] = sum([ - raw_cost, - blade_adder, - nacelle_adder, - tower_adder, - tower_tariffs - ]) + config["project_parameters.turbine_capex"] = sum( + [raw_cost, blade_adder, nacelle_adder, tower_adder, tower_tariffs] + ) return config @@ -206,28 +188,29 @@ def process_monopile_capex(self, config): ORBIT configuration. """ - raw_cost = config['monopile.unit_cost'] - scenario = self.sc_config['monopile'] + raw_cost = config["monopile.unit_cost"] + scenario = self.sc_config["monopile"] if scenario == "domestic, imported steel": - adder = self.multipliers['monopile']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['monopile']) *\ - self.multipliers["monopile"]['tariffs'] + adder = self.multipliers["monopile"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["monopile"]) + * self.multipliers["monopile"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["monopile"].get(scenario, None) if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'monopile'.") - mult = 0. + print( + f"Warning: scenario '{scenario}' not found for category 'monopile'." + ) + mult = 0.0 adder = raw_cost * mult - config['monopile.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["monopile.unit_cost"] = sum([raw_cost, adder, tariffs]) return config @@ -242,28 +225,29 @@ def process_transition_piece_capex(self, config): ORBIT configuration. """ - raw_cost = config['transition_piece.unit_cost'] - scenario = self.sc_config['transition_piece'] + raw_cost = config["transition_piece.unit_cost"] + scenario = self.sc_config["transition_piece"] if scenario == "domestic, imported steel": - adder = self.multipliers['transition_piece']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['transition_piece']) *\ - self.multipliers["transition_piece"]['tariffs'] + adder = self.multipliers["transition_piece"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["transition_piece"]) + * self.multipliers["transition_piece"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["transition_piece"].get(scenario, None) if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'transition_piece'.") - mult = 0. + print( + f"Warning: scenario '{scenario}' not found for category 'transition_piece'." + ) + mult = 0.0 adder = raw_cost * mult - config['transition_piece.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["transition_piece.unit_cost"] = sum([raw_cost, adder, tariffs]) return config @@ -278,28 +262,31 @@ def process_offshore_substation_topside_capex(self, config): ORBIT configuration. """ - raw_cost = config['offshore_substation_topside.unit_cost'] - scenario = self.sc_config['oss_topside'] + raw_cost = config["offshore_substation_topside.unit_cost"] + scenario = self.sc_config["oss_topside"] if scenario == "domestic, imported steel": - adder = self.multipliers['oss_topside']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['oss_topside']) *\ - self.multipliers["oss_topside"]['tariffs'] + adder = self.multipliers["oss_topside"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["oss_topside"]) + * self.multipliers["oss_topside"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["oss_topside"].get(scenario, None) if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'oss_topside'.") - mult = 0. + print( + f"Warning: scenario '{scenario}' not found for category 'oss_topside'." + ) + mult = 0.0 adder = raw_cost * mult - config['offshore_substation_topside.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["offshore_substation_topside.unit_cost"] = sum( + [raw_cost, adder, tariffs] + ) return config @@ -313,13 +300,15 @@ def process_array_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config['array_cable'] + scenario = self.sc_config["array_cable"] mult = self.multipliers["array_cable"].get(scenario, None) if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'array_cable'.") - mult = 0. + print( + f"Warning: scenario '{scenario}' not found for category 'array_cable'." + ) + mult = 0.0 - project.system_costs['ArrayCableInstallation'] *= (1 + mult) + project.system_costs["ArrayCableInstallation"] *= 1 + mult return project @@ -332,12 +321,14 @@ def process_export_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config['export_cable'] + scenario = self.sc_config["export_cable"] mult = self.multipliers["export_cable"].get(scenario, None) if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'export_cable'.") - mult = 0. + print( + f"Warning: scenario '{scenario}' not found for category 'export_cable'." + ) + mult = 0.0 - project.system_costs['ExportCableInstallation'] *= (1 + mult) + project.system_costs["ExportCableInstallation"] *= 1 + mult return project diff --git a/docs/Makefile b/docs/Makefile index 298ea9e2..51285967 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -16,4 +16,4 @@ help: # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/conf.py b/docs/conf.py index 38ceb207..555a6637 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -11,10 +11,10 @@ import os import sys -sys.path.insert(0, os.path.abspath("..")) - import ORBIT +sys.path.insert(0, os.path.abspath("..")) + # -- Project information ----------------------------------------------------- project = "ORBIT" diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index c602bbf4..0c0585e9 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.43 # mH/km linear_density: 90 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_500mm_220kV -rated_voltage: 220 \ No newline at end of file +rated_voltage: 220 diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index ff5e4820..8f2c0988 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.41 # mH/km linear_density: 96 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_630mm_220kV -rated_voltage: 220 \ No newline at end of file +rated_voltage: 220 diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index 18ed6b96..b0e48470 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.40 # mH/km linear_density: 105 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_800mm_220kV -rated_voltage: 220 \ No newline at end of file +rated_voltage: 220 diff --git a/library/turbines/15MW_generic.yaml b/library/turbines/15MW_generic.yaml index 50478a79..0a3683f9 100644 --- a/library/turbines/15MW_generic.yaml +++ b/library/turbines/15MW_generic.yaml @@ -17,4 +17,4 @@ tower: type: Tower length: 150 mass: 480 # t -turbine_rating: 15 # MW \ No newline at end of file +turbine_rating: 15 # MW diff --git a/misc/supply_chain_plots.py b/misc/supply_chain_plots.py index 75b6fd5c..00a13ba3 100644 --- a/misc/supply_chain_plots.py +++ b/misc/supply_chain_plots.py @@ -1,31 +1,40 @@ -import pandas as pd +import os import math + import numpy as np +import pandas as pd import matplotlib as mpl -import matplotlib.pyplot as plt import matplotlib.text as txt -import os +import matplotlib.pyplot as plt -def mysave(fig, froot, mode='png'): - assert mode in ['png', 'eps', 'pdf', 'all'] + +def mysave(fig, froot, mode="png"): + assert mode in ["png", "eps", "pdf", "all"] fileName, fileExtension = os.path.splitext(froot) padding = 0.1 dpiVal = 200 legs = [] for a in fig.get_axes(): addLeg = a.get_legend() - if not addLeg is None: legs.append(a.get_legend()) + if not addLeg is None: + legs.append(a.get_legend()) ext = [] - if mode == 'png' or mode == 'all': - ext.append('png') - if mode == 'eps': # or mode == 'all': - ext.append('eps') - if mode == 'pdf' or mode == 'all': - ext.append('pdf') + if mode == "png" or mode == "all": + ext.append("png") + if mode == "eps": # or mode == 'all': + ext.append("eps") + if mode == "pdf" or mode == "all": + ext.append("pdf") for sfx in ext: - fig.savefig(fileName + '.' + sfx, format=sfx, pad_inches=padding, bbox_inches='tight', - dpi=dpiVal, bbox_extra_artists=legs) + fig.savefig( + fileName + "." + sfx, + format=sfx, + pad_inches=padding, + bbox_inches="tight", + dpi=dpiVal, + bbox_extra_artists=legs, + ) titleSize = 24 # 40 #38 @@ -38,32 +47,48 @@ def mysave(fig, froot, mode='png'): linewidth = 3 -def myformat(ax, linewidth=linewidth, xticklabel=tickLabelSize, yticklabel=tickLabelSize, mode='save'): - assert type(mode) == type('') - assert mode.lower() in ['save', 'show'], 'Unknown mode' - - def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel): - if mode.lower() == 'show': +def myformat( + ax, + linewidth=linewidth, + xticklabel=tickLabelSize, + yticklabel=tickLabelSize, + mode="save", +): + assert type(mode) == type("") + assert mode.lower() in ["save", "show"], "Unknown mode" + + def myformat( + myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel + ): + if mode.lower() == "show": for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize + 3 * deltaShow) for i in myax.get_lines(): - if i.get_marker() == 'D': continue # Don't modify baseline diamond + if i.get_marker() == "D": + continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() if not leg is None: - for t in leg.get_texts(): t.set_fontsize(legendSize + deltaShow + 6) + for t in leg.get_texts(): + t.set_fontsize(legendSize + deltaShow + 6) th = leg.get_title() if not th is None: th.set_fontsize(legendSize + deltaShow + 6) - myax.set_title(myax.get_title(), size=titleSize + deltaShow, weight='bold') - myax.set_xlabel(myax.get_xlabel(), size=axLabelSize + deltaShow, weight='bold') - myax.set_ylabel(myax.get_ylabel(), size=axLabelSize + deltaShow, weight='bold') + myax.set_title( + myax.get_title(), size=titleSize + deltaShow, weight="bold" + ) + myax.set_xlabel( + myax.get_xlabel(), size=axLabelSize + deltaShow, weight="bold" + ) + myax.set_ylabel( + myax.get_ylabel(), size=axLabelSize + deltaShow, weight="bold" + ) myax.tick_params(labelsize=tickLabelSize + deltaShow) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -75,27 +100,29 @@ def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=ytickl for i in myax.get_yticklines(): i.set_linewidth(3) - elif mode.lower() == 'save': + elif mode.lower() == "save": for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize) for i in myax.get_lines(): - if i.get_marker() == 'D': continue # Don't modify baseline diamond + if i.get_marker() == "D": + continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() if not leg is None: - for t in leg.get_texts(): t.set_fontsize(legendSize) + for t in leg.get_texts(): + t.set_fontsize(legendSize) th = leg.get_title() if not th is None: th.set_fontsize(legendSize) - myax.set_title(myax.get_title(), size=titleSize, weight='bold') - myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight='bold') - myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight='bold') + myax.set_title(myax.get_title(), size=titleSize, weight="bold") + myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight="bold") + myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight="bold") myax.tick_params(labelsize=tickLabelSize) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -108,40 +135,62 @@ def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=ytickl i.set_linewidth(3) if type(ax) == type([]): - for i in ax: myformat(i) + for i in ax: + myformat(i) else: myformat(ax) + def initFigAxis(figx=12, figy=9): fig = plt.figure(figsize=(figx, figy)) ax = fig.add_subplot(111) return fig, ax + def waterfall_plot(x, y, bottom, color, bar_text, fname=None): - """ Waterfall plot comparing European andUS manufactining costs""" + """Waterfall plot comparing European andUS manufactining costs""" fig, ax = initFigAxis() - h = ax.bar(x, y,bottom=bottom, color=color, edgecolor='k') + h = ax.bar(x, y, bottom=bottom, color=color, edgecolor="k") ax.get_yaxis().set_major_formatter( - mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ','))) - ax.set_ylabel('Capital Expenditures, $/kW') - ax.set_title('Comparison of different cost premiums between \nimported and domestically manufactured components') - - h[3].set_linestyle('--') + mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ",")) + ) + ax.set_ylabel("Capital Expenditures, $/kW") + ax.set_title( + "Comparison of different cost premiums between \nimported and domestically manufactured components" + ) + + h[3].set_linestyle("--") h[3].set_linewidth(1.75) - h[3].set_edgecolor('k') - - ax.text(x[1], 2000, bar_text['transit'], horizontalalignment='center',) - ax.text(x[2], 2000, bar_text['factory'], horizontalalignment='center',) - ax.text(x[3], 2000, bar_text['margin'], horizontalalignment='center',) + h[3].set_edgecolor("k") + + ax.text( + x[1], + 2000, + bar_text["transit"], + horizontalalignment="center", + ) + ax.text( + x[2], + 2000, + bar_text["factory"], + horizontalalignment="center", + ) + ax.text( + x[3], + 2000, + bar_text["margin"], + horizontalalignment="center", + ) if fname is not None: myformat(ax) mysave(fig, fname) plt.close() + def area_time_plot(x, y, color, fname=None): """Area plot showing changin component cost over time""" @@ -150,40 +199,52 @@ def area_time_plot(x, y, color, fname=None): y0 = np.zeros(len(x)) y_init = 0 - y_init = np.sum([v[0] for k,v in y.items()]) + y_init = np.sum([v[0] for k, v in y.items()]) - for k,v in y.items(): - y1 = [yi+vi for yi, vi in zip(y0,v)] + for k, v in y.items(): + y1 = [yi + vi for yi, vi in zip(y0, v)] ax.fill_between(x, y0 / y_init, y1 / y_init, color=color[k], label=k) - ax.plot(x, y1 / y_init, 'w') + ax.plot(x, y1 / y_init, "w") y0 = y1 # Define margin - ax.fill_between(x, y1 / y_init, np.ones(len(x)), color=color['Cost margin'], label='Margin') + ax.fill_between( + x, + y1 / y_init, + np.ones(len(x)), + color=color["Cost margin"], + label="Margin", + ) - final_margin = round( 100* (1 - y1[-1] / y_init), 1) + final_margin = round(100 * (1 - y1[-1] / y_init), 1) - y_margin = ((1 + y1[-1] / y_init) /2) + y_margin = (1 + y1[-1] / y_init) / 2 - margin_text = ' ' + str(final_margin) + '% CapEx margin relative to \n European imports can cover \n local differences in wages, \n taxes, financing, etc' + margin_text = ( + " " + + str(final_margin) + + "% CapEx margin relative to \n European imports can cover \n local differences in wages, \n taxes, financing, etc" + ) right_bound = 2030.5 right_spline_corr = 0.2 - ax.plot([2030, right_bound], [y_margin, y_margin], 'k') - ax.text(right_bound, y_margin, margin_text, verticalalignment='center') - ax.spines["right"].set_position(("data", right_bound-right_spline_corr)) - ax.spines["top"].set_bounds(2022.65, right_bound-right_spline_corr) - ax.spines["bottom"].set_bounds(2022.65, right_bound-right_spline_corr) + ax.plot([2030, right_bound], [y_margin, y_margin], "k") + ax.text(right_bound, y_margin, margin_text, verticalalignment="center") + ax.spines["right"].set_position(("data", right_bound - right_spline_corr)) + ax.spines["top"].set_bounds(2022.65, right_bound - right_spline_corr) + ax.spines["bottom"].set_bounds(2022.65, right_bound - right_spline_corr) - ax.text(2023, -0.215, '(Fully \nimported)', horizontalalignment='center') - ax.text(2030, -0.215, '(Fully \ndomestic)', horizontalalignment='center') + ax.text(2023, -0.215, "(Fully \nimported)", horizontalalignment="center") + ax.text(2030, -0.215, "(Fully \ndomestic)", horizontalalignment="center") - ax.set_yticklabels([-20, 0, 20, 40, 60, 80 ,100]) + ax.set_yticklabels([-20, 0, 20, 40, 60, 80, 100]) ax.legend(loc=(1, 0.05)) - ax.set_ylabel('CapEx breakdown relative to \ncomponents imported from Europe, %') + ax.set_ylabel( + "CapEx breakdown relative to \ncomponents imported from Europe, %" + ) if fname is not None: myformat(ax) diff --git a/templates/design_module.py b/templates/design_module.py index 2b1bdafe..eed5b2c9 100644 --- a/templates/design_module.py +++ b/templates/design_module.py @@ -12,12 +12,10 @@ class TemplateDesign(DesignPhase): expected_config = { "required_input": "unit", - "optional_input": "unit, (optional, default: 'default')" + "optional_input": "unit, (optional, default: 'default')", } - output_config = { - "example_output": "unit" - } + output_config = {"example_output": "unit"} def __init__(self, config, **kwargs): """Creates an instance of `TemplateDesign`.""" @@ -45,9 +43,7 @@ def example_computation(self): def detailed_output(self): """Returns detailed output dictionary.""" - return { - "example_detailed_output": self.result - } + return {"example_detailed_output": self.result} @property def total_cost(self): @@ -60,9 +56,7 @@ def total_cost(self): def design_result(self): """Must match `self.output_config` structure.""" - return { - "example_output": self.result - } + return {"example_output": self.result} # === Annotated Example === @@ -75,18 +69,21 @@ class SparDesign(DesignPhase): # that ProjectManager doesn't raise a warning if doesn't find the input in # a project level config. expected_config = { - "site": {"depth": "m"}, # For common inputs that will be shared across many modules, - "plant": {"num_turbines": "int"}, # it's best to look up how the variable is named in existing modules - "turbine": {"turbine_rating": "MW"}, # so the user doesn't have to input the same thing twice. For example, avoid adding - # 'number_turbines' if 'num_turbines' is already used throughout ORBIT - - - + "site": { + "depth": "m" + }, # For common inputs that will be shared across many modules, + "plant": { + "num_turbines": "int" + }, # it's best to look up how the variable is named in existing modules + "turbine": { + "turbine_rating": "MW" + }, # so the user doesn't have to input the same thing twice. For example, avoid adding + # 'number_turbines' if 'num_turbines' is already used throughout ORBIT # Inputs can be grouped into dictionaries like the following: "spar_design": { - "stiffened_column_CR": "$/t (optional, default: 3120)", # I tend to group module specific cost rates - "tapered_column_CR": "$/t (optional, default: 4220)", # into dictionaries named after the component being considered - "ballast_material_CR": "$/t (optional, default: 100)", # eg. spar_design, gbf_design, etc. + "stiffened_column_CR": "$/t (optional, default: 3120)", # I tend to group module specific cost rates + "tapered_column_CR": "$/t (optional, default: 4220)", # into dictionaries named after the component being considered + "ballast_material_CR": "$/t (optional, default: 100)", # eg. spar_design, gbf_design, etc. "secondary_steel_CR": "$/t (optional, default: 7250)", "towing_speed": "km/h (optional, default: 6)", }, @@ -97,8 +94,8 @@ class SparDesign(DesignPhase): # results are used as inputs to installation modules. As such, these output # names should match the input names of the respective installation module output_config = { - "substructure": { # Typically a design phase ouptuts a component design - "mass": "t", # grouped into a dictionary, eg. "substructure" dict to the left. + "substructure": { # Typically a design phase ouptuts a component design + "mass": "t", # grouped into a dictionary, eg. "substructure" dict to the left. "ballasted_mass": "t", "unit_cost": "USD", "towing_speed": "km/h", @@ -114,13 +111,18 @@ def __init__(self, config, **kwargs): config : dict """ - config = self.initialize_library(config, **kwargs) # These first two lines are required in all modules. They initialize the library - self.config = self.validate_config(config) # if it hasn't already been and validate the config against '.expected_config' from above - - - self._design = self.config.get("spar_design", {}) # Not required, but I often save module specific outputs to "_design" for later use - # If the "spar_design" sub dictionary isn't found, an empty one is returned to - # work with later methods. + config = self.initialize_library( + config, **kwargs + ) # These first two lines are required in all modules. They initialize the library + self.config = self.validate_config( + config + ) # if it hasn't already been and validate the config against '.expected_config' from above + + self._design = self.config.get( + "spar_design", {} + ) # Not required, but I often save module specific outputs to "_design" for later use + # If the "spar_design" sub dictionary isn't found, an empty one is returned to + # work with later methods. self._outputs = {} def run(self): @@ -152,7 +154,7 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) return mass @@ -174,8 +176,10 @@ def stiffened_column_cost(self): Calculates the cost of the stiffened column for a single spar. From original OffshoreBOS model. """ - cr = self._design.get("stiffened_column_CR", 3120) # This is how I typically handle outputs. This will look for the key in - # self._design, and return default value if it isn't found. + cr = self._design.get( + "stiffened_column_CR", 3120 + ) # This is how I typically handle outputs. This will look for the key in + # self._design, and return default value if it isn't found. return self.stiffened_column_mass * cr @property @@ -194,7 +198,7 @@ def ballast_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @@ -219,7 +223,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 - + 0.196 * (rating ** 0.5) * log(rating) + + 0.196 * (rating**0.5) * log(rating) + 0.00001 * depth * log(depth) ) @@ -267,7 +271,7 @@ def substructure_cost(self): # The following properties are required methods for a DesignPhase # .detailed_output returns any relevant detailed outputs from the module - # in a dictionary. + # in a dictionary. @property def detailed_output(self): """Returns detailed phase information.""" diff --git a/tests/api/test_wisdem_api.py b/tests/api/test_wisdem_api.py index e15c8156..4cc5fa25 100644 --- a/tests/api/test_wisdem_api.py +++ b/tests/api/test_wisdem_api.py @@ -11,7 +11,6 @@ def test_wisdem_monopile_api_default(): - prob = om.Problem(reports=False) prob.model = Orbit(floating=False, jacket=False, jacket_legs=0) prob.setup() @@ -23,7 +22,6 @@ def test_wisdem_monopile_api_default(): def test_wisdem_jacket_api_default(): - prob = om.Problem(reports=False) prob.model = Orbit(floating=False, jacket=True, jacket_legs=3) prob.setup() @@ -35,7 +33,6 @@ def test_wisdem_jacket_api_default(): def test_wisdem_floating_api_default(): - prob = om.Problem(reports=False) prob.model = Orbit(floating=True, jacket=False, jacket_legs=0) prob.setup() diff --git a/tests/conftest.py b/tests/conftest.py index a480e04e..5579f62c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -5,7 +5,6 @@ import pytest from marmot import Environment - from ORBIT.core import Vessel from tests.data import test_weather from ORBIT.core.library import initialize_library, extract_library_specs @@ -24,27 +23,23 @@ def pytest_configure(): @pytest.fixture() def env(): - return Environment("Test Environment", state=test_weather) @pytest.fixture() def wtiv(): - specs = extract_library_specs("wtiv", "test_wtiv") return Vessel("Test WTIV", specs) @pytest.fixture() def feeder(): - specs = extract_library_specs("feeder", "test_feeder") return Vessel("Test Feeder", specs) @pytest.fixture() def cable_vessel(): - specs = extract_library_specs( "array_cable_install_vessel", "test_cable_lay_vessel" ) @@ -53,7 +48,6 @@ def cable_vessel(): @pytest.fixture() def heavy_lift(): - specs = extract_library_specs( "oss_install_vessel", "test_heavy_lift_vessel" ) @@ -62,19 +56,16 @@ def heavy_lift(): @pytest.fixture() def spi_vessel(): - specs = extract_library_specs("spi_vessel", "test_scour_protection_vessel") return Vessel("Test SPI Vessel", specs) @pytest.fixture() def simple_cable(): - return SimpleCable(linear_density=50.0) @pytest.fixture(scope="function") def tmp_yaml_del(): - yield os.remove("tmp.yaml") diff --git a/tests/core/test_environment.py b/tests/core/test_environment.py index 0ce94758..b5f5208b 100644 --- a/tests/core/test_environment.py +++ b/tests/core/test_environment.py @@ -8,7 +8,6 @@ import pandas as pd import pytest from marmot import le - from ORBIT.core import Environment from tests.data import test_weather as _weather diff --git a/tests/core/test_library.py b/tests/core/test_library.py index 7320a9f6..9cac3f50 100644 --- a/tests/core/test_library.py +++ b/tests/core/test_library.py @@ -9,7 +9,6 @@ from copy import deepcopy import pytest - from ORBIT import ProjectManager from ORBIT.core import library from ORBIT.core.exceptions import LibraryItemNotFoundError @@ -58,7 +57,6 @@ def test_extract_library_specs_fail(): def test_phase_specific_file_extraction(): - project = ProjectManager(config) turbine_config = project.create_config_for_phase("TurbineInstallation") monopile_config = project.create_config_for_phase("MonopileInstallation") diff --git a/tests/core/test_port.py b/tests/core/test_port.py index 915af401..6415118d 100644 --- a/tests/core/test_port.py +++ b/tests/core/test_port.py @@ -8,7 +8,6 @@ import pytest from marmot import Environment - from ORBIT.core import Port, Cargo from ORBIT.core.exceptions import ItemNotFound @@ -19,7 +18,6 @@ def __init__(self): def test_port_creation(): - env = Environment() port = Port(env) item = SampleItem() @@ -32,7 +30,6 @@ def test_port_creation(): def test_get_item(): - env = Environment() port = Port(env) item = SampleItem() diff --git a/tests/phases/design/test_array_system_design.py b/tests/phases/design/test_array_system_design.py index cd1ad5cd..39c42a82 100644 --- a/tests/phases/design/test_array_system_design.py +++ b/tests/phases/design/test_array_system_design.py @@ -10,7 +10,6 @@ import numpy as np import pytest - from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ArraySystemDesign, CustomArraySystemDesign from ORBIT.core.exceptions import LibraryItemNotFoundError @@ -209,7 +208,6 @@ def test_correct_turbines(): def test_floating_calculations(): - base = deepcopy(config_full_ring) base["site"]["depth"] = 50 number = base["plant"]["num_turbines"] diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index e3e972e2..c141f7cc 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -111,7 +111,6 @@ def test_power_factor(): np.arange(0, 1, 0.15), # inductance range(100, 1001, 150), # capacitance ): - c["conductor_size"] = i[0] c["ac_resistance"] = i[1] c["inductance"] = i[2] diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 605ea434..ed8c6d82 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -32,7 +32,6 @@ ), ) def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): - config = { "site": {"distance_to_landfall": distance_to_landfall, "depth": depth}, "plant": {"capacity": plant_cap}, @@ -59,7 +58,6 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_ac_oss_kwargs(): - test_kwargs = { "mpt_cost_rate": 13500, "topside_fab_cost_rate": 17000, @@ -80,7 +78,6 @@ def test_ac_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v @@ -101,7 +98,6 @@ def test_dc_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" config["substation_design"] = {} @@ -138,7 +134,6 @@ def test_hvdc_substation(): def test_export_kwargs(): - test_kwargs = { "num_redundant": 2, "touchdown_distance": 50, @@ -150,7 +145,6 @@ def test_export_kwargs(): base_cost = o.total_cost for k, v in test_kwargs.items(): - config = deepcopy(base) config["export_system_design"] = {"cables": "XLPE_630mm_220kV"} config["export_system_design"][k] = v @@ -257,7 +251,6 @@ def test_design_result(): def test_floating_length_calculations(): - base = deepcopy(config) base["site"]["depth"] = 250 base["export_system_design"]["touchdown_distance"] = 0 @@ -277,7 +270,6 @@ def test_floating_length_calculations(): def test_HVDC_cable(): - base = deepcopy(config) base["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} @@ -296,7 +288,6 @@ def test_HVDC_cable(): def test_num_crossing(): - base_sim = ElectricalDesign(config) base_sim.run() @@ -310,7 +301,6 @@ def test_num_crossing(): def test_cost_crossing(): - base_sim = ElectricalDesign(config) base_sim.run() diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 7039bb5b..32e91dd9 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -104,7 +104,6 @@ def test_design_result(): def test_floating_length_calculations(): - base = deepcopy(config) base["site"]["depth"] = 250 base["export_system_design"]["touchdown_distance"] = 0 diff --git a/tests/phases/design/test_monopile_design.py b/tests/phases/design/test_monopile_design.py index 0762b46b..2f69ed18 100644 --- a/tests/phases/design/test_monopile_design.py +++ b/tests/phases/design/test_monopile_design.py @@ -10,7 +10,6 @@ from itertools import product import pytest - from ORBIT.phases.design import MonopileDesign base = { @@ -37,7 +36,6 @@ product(range(10, 51, 10), range(8, 13, 1), turbines), ) def test_paramater_sweep(depth, mean_ws, turbine): - config = { "site": {"depth": depth, "mean_windspeed": mean_ws}, "plant": {"num_turbines": 20}, @@ -61,7 +59,6 @@ def test_paramater_sweep(depth, mean_ws, turbine): def test_monopile_kwargs(): - test_kwargs = { "yield_stress": 400000000, "load_factor": 1.25, @@ -80,7 +77,6 @@ def test_monopile_kwargs(): base_results = m._outputs["monopile"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["monopile_design"] = {} config["monopile_design"][k] = v @@ -93,7 +89,6 @@ def test_monopile_kwargs(): def test_transition_piece_kwargs(): - test_kwargs = { # Transition piece specific "monopile_tp_connection_thickness": 0.005, @@ -107,7 +102,6 @@ def test_transition_piece_kwargs(): base_results = m._outputs["transition_piece"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["monopile_design"] = {} config["monopile_design"][k] = v diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index 88a7a747..c59ef535 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -9,7 +9,6 @@ from copy import deepcopy import pytest - from ORBIT.phases.design import MooringSystemDesign base = { @@ -21,7 +20,6 @@ @pytest.mark.parametrize("depth", range(10, 1000, 100)) def test_depth_sweep(depth): - config = deepcopy(base) config["site"]["depth"] = depth @@ -34,7 +32,6 @@ def test_depth_sweep(depth): @pytest.mark.parametrize("rating", range(3, 15, 1)) def test_rating_sweeip(rating): - config = deepcopy(base) config["turbine"]["turbine_rating"] = rating @@ -46,7 +43,6 @@ def test_rating_sweeip(rating): def test_drag_embedment_fixed_length(): - m = MooringSystemDesign(base) m.run() @@ -75,7 +71,6 @@ def test_drag_embedment_fixed_length(): def test_custom_num_lines(): - config = deepcopy(base) config["mooring_system_design"] = {"num_lines": 5} diff --git a/tests/phases/design/test_oss_design.py b/tests/phases/design/test_oss_design.py index b2dd6316..f17b3bd7 100644 --- a/tests/phases/design/test_oss_design.py +++ b/tests/phases/design/test_oss_design.py @@ -8,7 +8,6 @@ from itertools import product import pytest - from ORBIT.phases.design import OffshoreSubstationDesign base = { @@ -24,7 +23,6 @@ product(range(10, 51, 10), range(3, 13, 1), range(20, 80, 10)), ) def test_parameter_sweep(depth, num_turbines, turbine_rating): - config = { "site": {"depth": depth}, "plant": {"num_turbines": num_turbines}, @@ -51,7 +49,6 @@ def test_parameter_sweep(depth, num_turbines, turbine_rating): def test_oss_kwargs(): - test_kwargs = { "mpt_cost_rate": 13500, "topside_fab_cost_rate": 15500, @@ -72,7 +69,6 @@ def test_oss_kwargs(): base_cost = o.total_cost for k, v in test_kwargs.items(): - config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v diff --git a/tests/phases/design/test_scour_protection_design.py b/tests/phases/design/test_scour_protection_design.py index 301e5894..d4168fd1 100644 --- a/tests/phases/design/test_scour_protection_design.py +++ b/tests/phases/design/test_scour_protection_design.py @@ -10,7 +10,6 @@ import numpy as np import pytest - from ORBIT.phases.design import ScourProtectionDesign config_min_defined = { diff --git a/tests/phases/design/test_semisubmersible_design.py b/tests/phases/design/test_semisubmersible_design.py index 7c710fb9..30a134f3 100644 --- a/tests/phases/design/test_semisubmersible_design.py +++ b/tests/phases/design/test_semisubmersible_design.py @@ -8,7 +8,6 @@ from itertools import product import pytest - from ORBIT.phases.design import SemiSubmersibleDesign base = { @@ -23,7 +22,6 @@ "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) ) def test_parameter_sweep(depth, turbine_rating): - config = { "site": {"depth": depth}, "plant": {"num_turbines": 50}, @@ -41,7 +39,6 @@ def test_parameter_sweep(depth, turbine_rating): def test_design_kwargs(): - test_kwargs = { "stiffened_column_CR": 3000, "truss_CR": 6000, @@ -54,7 +51,6 @@ def test_design_kwargs(): base_cost = s.total_cost for k, v in test_kwargs.items(): - config = deepcopy(base) config["semisubmersible_design"] = {} config["semisubmersible_design"][k] = v diff --git a/tests/phases/design/test_spar_design.py b/tests/phases/design/test_spar_design.py index 393cf7c1..dbc937c1 100644 --- a/tests/phases/design/test_spar_design.py +++ b/tests/phases/design/test_spar_design.py @@ -8,7 +8,6 @@ from itertools import product import pytest - from ORBIT.phases.design import SparDesign base = { @@ -23,7 +22,6 @@ "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) ) def test_parameter_sweep(depth, turbine_rating): - config = { "site": {"depth": depth}, "plant": {"num_turbines": 50}, @@ -41,7 +39,6 @@ def test_parameter_sweep(depth, turbine_rating): def test_design_kwargs(): - test_kwargs = { "stiffened_column_CR": 3000, "tapered_column_CR": 4000, @@ -54,7 +51,6 @@ def test_design_kwargs(): base_cost = s.total_cost for k, v in test_kwargs.items(): - config = deepcopy(base) config["spar_design"] = {} config["spar_design"][k] = v diff --git a/tests/phases/install/cable_install/test_array_install.py b/tests/phases/install/cable_install/test_array_install.py index 5a01c14b..f9b1c9a9 100644 --- a/tests/phases/install/cable_install/test_array_install.py +++ b/tests/phases/install/cable_install/test_array_install.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,7 +27,6 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): - sim = ArrayCableInstallation(config) assert sim.env @@ -37,7 +35,6 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): - sim = ArrayCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -53,7 +50,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): - sim = ArrayCableInstallation(config, weather=weather) sim.run() @@ -72,7 +68,6 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): - sim = ArrayCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time @@ -89,7 +84,6 @@ def test_simultaneous_speed_kwargs(): def test_separate_speed_kwargs(): - sim = ArrayCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -114,7 +108,6 @@ def test_separate_speed_kwargs(): def test_kwargs_for_array_install(): - sim = ArrayCableInstallation(base_config) sim.run() baseline = sim.total_phase_time @@ -131,7 +124,6 @@ def test_kwargs_for_array_install(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: @@ -163,7 +155,6 @@ def test_kwargs_for_array_install(): def test_kwargs_for_array_install_in_ProjectManager(): - base = deepcopy(base_config) base["install_phases"] = ["ArrayCableInstallation"] @@ -183,7 +174,6 @@ def test_kwargs_for_array_install_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: diff --git a/tests/phases/install/cable_install/test_cable_tasks.py b/tests/phases/install/cable_install/test_cable_tasks.py index 3ab42d15..f3d03350 100644 --- a/tests/phases/install/cable_install/test_cable_tasks.py +++ b/tests/phases/install/cable_install/test_cable_tasks.py @@ -9,7 +9,6 @@ import pytest - from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.cable_install.common import ( tow_plow, @@ -28,7 +27,6 @@ def test_load_cable_on_vessel(env, cable_vessel, feeder, simple_cable): - env.register(cable_vessel) cable_vessel.initialize(mobilize=False) @@ -59,7 +57,6 @@ def test_load_cable_on_vessel(env, cable_vessel, feeder, simple_cable): ], ) def test_task(env, cable_vessel, task, log, args): - env.register(cable_vessel) cable_vessel.initialize(mobilize=False) diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 80889fb1..f4237200 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,7 +27,6 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): - sim = ExportCableInstallation(config) assert sim.env assert sim.cable @@ -42,7 +40,6 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): - sim = ExportCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -58,7 +55,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): - sim = ExportCableInstallation(config, weather=weather) sim.run() @@ -77,7 +73,6 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): - sim = ExportCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time @@ -94,7 +89,6 @@ def test_simultaneous_speed_kwargs(): def test_separate_speed_kwargs(): - sim = ExportCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -119,7 +113,6 @@ def test_separate_speed_kwargs(): def test_kwargs_for_export_install(): - new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -151,7 +144,6 @@ def test_kwargs_for_export_install(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: @@ -183,7 +175,6 @@ def test_kwargs_for_export_install(): def test_kwargs_for_export_install_in_ProjectManager(): - new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -215,7 +206,6 @@ def test_kwargs_for_export_install_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: diff --git a/tests/phases/install/jacket_install/test_jacket_install.py b/tests/phases/install/jacket_install/test_jacket_install.py index 6811e631..c601a5c6 100644 --- a/tests/phases/install/jacket_install/test_jacket_install.py +++ b/tests/phases/install/jacket_install/test_jacket_install.py @@ -10,7 +10,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -29,7 +28,6 @@ ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_simulation_setup(config): - sim = JacketInstallation(config) assert sim.config == config assert sim.env @@ -50,7 +48,6 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): - sim = JacketInstallation(config) assert sim.wtiv assert sim.wtiv.jacksys @@ -74,7 +71,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): - sim = JacketInstallation(config, weather=weather) sim.run() @@ -97,7 +93,6 @@ def test_for_complete_logging(weather, config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_num_legs(config): - base = JacketInstallation(config) base.run() @@ -116,7 +111,6 @@ def test_num_legs(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_foundation_type(config): - base = JacketInstallation(config) base.run() @@ -134,7 +128,6 @@ def test_foundation_type(config): def test_kwargs_piles(): - sim = JacketInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -154,7 +147,6 @@ def test_kwargs_piles(): failed = [] for kw in keywords: - default = pt[kw] kwargs = {kw: default + 2} @@ -176,7 +168,6 @@ def test_kwargs_piles(): def test_kwargs_suction(): - config_wtiv_suction = deepcopy(config_wtiv) config_wtiv_suction["jacket"]["foundation_type"] = "suction" @@ -197,7 +188,6 @@ def test_kwargs_suction(): failed = [] for kw in keywords: - default = pt[kw] kwargs = {kw: default + 2} diff --git a/tests/phases/install/monopile_install/test_monopile_install.py b/tests/phases/install/monopile_install/test_monopile_install.py index 57538063..1759bc3e 100644 --- a/tests/phases/install/monopile_install/test_monopile_install.py +++ b/tests/phases/install/monopile_install/test_monopile_install.py @@ -10,7 +10,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -29,7 +28,6 @@ ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_simulation_setup(config): - sim = MonopileInstallation(config) assert sim.config == config assert sim.env @@ -50,7 +48,6 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): - sim = MonopileInstallation(config) assert sim.wtiv assert sim.wtiv.jacksys @@ -74,7 +71,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): - sim = MonopileInstallation(config, weather=weather) sim.run() @@ -92,7 +88,6 @@ def test_for_complete_logging(weather, config): def test_kwargs(): - sim = MonopileInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -113,7 +108,6 @@ def test_kwargs(): failed = [] for kw in keywords: - default = pt[kw] if kw == "mono_drive_rate": @@ -145,7 +139,6 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): - base = deepcopy(config_wtiv) base["install_phases"] = ["MonopileInstallation"] project = ProjectManager(base) @@ -168,7 +161,6 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if kw == "mono_drive_rate": @@ -203,7 +195,6 @@ def test_kwargs_in_ProjectManager(): def test_grout_kwargs(): - sim = MonopileInstallation(config_wtiv) sim.run() diff --git a/tests/phases/install/monopile_install/test_monopile_tasks.py b/tests/phases/install/monopile_install/test_monopile_tasks.py index bff023f5..2fa11d9e 100644 --- a/tests/phases/install/monopile_install/test_monopile_tasks.py +++ b/tests/phases/install/monopile_install/test_monopile_tasks.py @@ -9,7 +9,6 @@ import pytest - from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.monopile_install.common import ( drive_monopile, @@ -35,7 +34,6 @@ ], ) def test_task(env, wtiv, task, log, args): - env.register(wtiv) wtiv.initialize(mobilize=False) @@ -55,7 +53,6 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): - env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/install/mooring_install/test_mooring_install.py b/tests/phases/install/mooring_install/test_mooring_install.py index 116f7558..3583bbda 100644 --- a/tests/phases/install/mooring_install/test_mooring_install.py +++ b/tests/phases/install/mooring_install/test_mooring_install.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -61,7 +60,6 @@ def test_full_run_logging(weather): ], ) def test_kwargs(anchor, key): - new = deepcopy(config) new["mooring_system"]["anchor_type"] = anchor @@ -74,7 +72,6 @@ def test_kwargs(anchor, key): failed = [] for kw in keywords: - default = pt[kw] kwargs = {kw: default + 2} @@ -103,7 +100,6 @@ def test_kwargs(anchor, key): ], ) def test_kwargs_in_ProjectManager(anchor, key): - base = deepcopy(config) base["mooring_system"]["anchor_type"] = anchor base["install_phases"] = ["MooringSystemInstallation"] @@ -117,7 +113,6 @@ def test_kwargs_in_ProjectManager(anchor, key): failed = [] for kw in keywords: - default = pt[kw] processes = {kw: default + 2} new_config = deepcopy(base) diff --git a/tests/phases/install/oss_install/test_oss_install.py b/tests/phases/install/oss_install/test_oss_install.py index be32be3d..30ed4475 100644 --- a/tests/phases/install/oss_install/test_oss_install.py +++ b/tests/phases/install/oss_install/test_oss_install.py @@ -10,7 +10,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -33,7 +32,6 @@ ids=["single_feeder", "multi_feeder"], ) def test_simulation_setup(config): - sim = OffshoreSubstationInstallation(config) assert sim.config == config assert sim.env @@ -45,7 +43,6 @@ def test_simulation_setup(config): def test_floating_simulation_setup(): - sim = FloatingSubstationInstallation(config_floating) assert sim.config == config_floating assert sim.env @@ -58,7 +55,6 @@ def test_floating_simulation_setup(): ids=["single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): - sim = OffshoreSubstationInstallation(config) assert sim.oss_vessel assert sim.oss_vessel.crane @@ -82,7 +78,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): - # No weather sim = OffshoreSubstationInstallation(config, weather=weather) sim.run() @@ -104,7 +99,6 @@ def test_for_complete_logging(weather, config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging_floating(weather): - sim = FloatingSubstationInstallation(config_floating, weather=weather) sim.run() @@ -118,7 +112,6 @@ def test_for_complete_logging_floating(weather): def test_kwargs(): - sim = OffshoreSubstationInstallation(config_single) sim.run() baseline = sim.total_phase_time @@ -139,7 +132,6 @@ def test_kwargs(): failed = [] for kw in keywords: - default = pt[kw] if kw == "mono_drive_rate": @@ -171,7 +163,6 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): - base = deepcopy(config_single) base["install_phases"] = ["OffshoreSubstationInstallation"] @@ -195,7 +186,6 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if kw == "mono_drive_rate": diff --git a/tests/phases/install/oss_install/test_oss_tasks.py b/tests/phases/install/oss_install/test_oss_tasks.py index 67a28c40..758df489 100644 --- a/tests/phases/install/oss_install/test_oss_tasks.py +++ b/tests/phases/install/oss_install/test_oss_tasks.py @@ -9,7 +9,6 @@ import pytest - from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.oss_install.common import ( lift_topside, @@ -25,7 +24,6 @@ ], ) def test_task(env, wtiv, task, log, args): - env.register(wtiv) wtiv.initialize(mobilize=False) @@ -44,7 +42,6 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): - env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/install/quayside_assembly_tow/test_common.py b/tests/phases/install/quayside_assembly_tow/test_common.py index 00fa2b4e..b9a08bac 100644 --- a/tests/phases/install/quayside_assembly_tow/test_common.py +++ b/tests/phases/install/quayside_assembly_tow/test_common.py @@ -8,7 +8,6 @@ import pandas as pd import pytest - from ORBIT.core import WetStorage from ORBIT.phases.install.quayside_assembly_tow.common import ( TurbineAssemblyLine, @@ -28,7 +27,6 @@ ], ) def test_SubstructureAssemblyLine(env, num, assigned, expected): - _assigned = len(assigned) storage = WetStorage(env, capacity=float("inf")) @@ -54,7 +52,6 @@ def test_SubstructureAssemblyLine(env, num, assigned, expected): ], ) def test_TurbineAssemblyLine(env, num, assigned): - _assigned = len(assigned) feed = WetStorage(env, capacity=float("inf")) target = WetStorage(env, capacity=float("inf")) @@ -92,7 +89,6 @@ def test_TurbineAssemblyLine(env, num, assigned): ], ) def test_Sub_to_Turbine_assembly_interaction(env, sub_lines, turb_lines): - num_turbines = 50 assigned = [1] * num_turbines diff --git a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py index dafad84b..25d7db92 100644 --- a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py +++ b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py @@ -8,7 +8,6 @@ import pandas as pd import pytest - from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import GravityBasedInstallation @@ -18,7 +17,6 @@ def test_simulation_setup(): - sim = GravityBasedInstallation(config) assert sim.config == config assert sim.env @@ -41,7 +39,6 @@ def test_simulation_setup(): ) @pytest.mark.parametrize("config", (config, no_supply)) def test_for_complete_logging(weather, config): - sim = GravityBasedInstallation(config, weather=weather) sim.run() diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index e1fc0af7..72619642 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -8,7 +8,6 @@ import pandas as pd import pytest - from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import MooredSubInstallation @@ -18,7 +17,6 @@ def test_simulation_setup(): - sim = MooredSubInstallation(config) assert sim.config == config assert sim.env @@ -41,7 +39,6 @@ def test_simulation_setup(): ) @pytest.mark.parametrize("config", (config, no_supply)) def test_for_complete_logging(weather, config): - sim = MooredSubInstallation(config, weather=weather) sim.run() diff --git a/tests/phases/install/scour_protection_install/test_scour_protection.py b/tests/phases/install/scour_protection_install/test_scour_protection.py index 85e372c7..ae1c9313 100644 --- a/tests/phases/install/scour_protection_install/test_scour_protection.py +++ b/tests/phases/install/scour_protection_install/test_scour_protection.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -51,7 +50,6 @@ def test_full_run_logging(weather): def test_kwargs(): - sim = ScourProtectionInstallation(config) sim.run() baseline = sim.total_phase_time @@ -61,7 +59,6 @@ def test_kwargs(): failed = [] for kw in keywords: - default = pt[kw] kwargs = {kw: default + 2} @@ -83,7 +80,6 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): - base = deepcopy(config) base["install_phases"] = ["ScourProtectionInstallation"] @@ -96,7 +92,6 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] processes = {kw: default + 2} diff --git a/tests/phases/install/test_install_phase.py b/tests/phases/install/test_install_phase.py index 6b600eb2..cba9802c 100644 --- a/tests/phases/install/test_install_phase.py +++ b/tests/phases/install/test_install_phase.py @@ -9,7 +9,6 @@ import pandas as pd import pytest from marmot import Environment - from ORBIT.phases.install import InstallPhase @@ -45,7 +44,6 @@ def setup_simulation(self): def test_abstract_methods(): - with pytest.raises(TypeError): install = BadInstallPhase(base_config) @@ -53,7 +51,6 @@ def test_abstract_methods(): def test_run(): - sim = SampleInstallPhase(base_config) sim.run(until=10) diff --git a/tests/phases/install/turbine_install/test_turbine_install.py b/tests/phases/install/turbine_install/test_turbine_install.py index aac2de9f..0592999a 100644 --- a/tests/phases/install/turbine_install/test_turbine_install.py +++ b/tests/phases/install/turbine_install/test_turbine_install.py @@ -10,7 +10,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -33,7 +32,6 @@ ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_simulation_setup(config): - sim = TurbineInstallation(config) assert sim.config == config assert sim.env @@ -56,7 +54,6 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_vessel_creation(config): - sim = TurbineInstallation(config) assert sim.wtiv assert sim.wtiv.crane @@ -80,7 +77,6 @@ def test_vessel_creation(config): "config, expected", [(config_wtiv, 72), (config_long_mobilize, 14 * 24)] ) def test_vessel_mobilize(config, expected): - sim = TurbineInstallation(config) assert sim.wtiv @@ -97,7 +93,6 @@ def test_vessel_mobilize(config, expected): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): - sim = TurbineInstallation(config, weather=weather) sim.run() @@ -120,7 +115,6 @@ def test_for_complete_logging(weather, config): ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_for_complete_installation(config): - sim = TurbineInstallation(config) sim.run() @@ -131,7 +125,6 @@ def test_for_complete_installation(config): def test_kwargs(): - sim = TurbineInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -153,7 +146,6 @@ def test_kwargs(): failed = [] for kw in keywords: - default = pt[kw] kwargs = {kw: default + 2} @@ -175,7 +167,6 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): - base = deepcopy(config_wtiv) base["install_phases"] = ["TurbineInstallation"] @@ -200,7 +191,6 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] processes = {kw: default + 2} @@ -225,7 +215,6 @@ def test_kwargs_in_ProjectManager(): def test_multiple_tower_sections(): - sim = TurbineInstallation(config_wtiv) sim.run() baseline = len( @@ -245,7 +234,6 @@ def test_multiple_tower_sections(): df = pd.DataFrame(sim.env.actions) for vessel in df["agent"].unique(): - vl = df[df["agent"] == vessel].copy() vl = vl.assign(shift=(vl["time"] - vl["time"].shift(1))) diff --git a/tests/phases/install/turbine_install/test_turbine_tasks.py b/tests/phases/install/turbine_install/test_turbine_tasks.py index 055da73d..2042f639 100644 --- a/tests/phases/install/turbine_install/test_turbine_tasks.py +++ b/tests/phases/install/turbine_install/test_turbine_tasks.py @@ -9,7 +9,6 @@ import pytest - from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.turbine_install.common import ( lift_nacelle, @@ -33,7 +32,6 @@ ], ) def test_task(env, wtiv, task, log, args): - env.register(wtiv) wtiv.initialize(mobilize=False) @@ -56,7 +54,6 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): - env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/test_base.py b/tests/phases/test_base.py index 209983ac..01e37b7b 100644 --- a/tests/phases/test_base.py +++ b/tests/phases/test_base.py @@ -18,14 +18,12 @@ def test_good_config(): - config = deepcopy(expected_config) missing = BasePhase._check_keys(expected_config, config) assert len(missing) == 0 def test_missing_key(): - config = deepcopy(expected_config) _ = config.pop("param1") missing = BasePhase._check_keys(expected_config, config) @@ -33,7 +31,6 @@ def test_missing_key(): def test_optional(): - config = deepcopy(expected_config) _ = config["param2"].pop("param4") missing = BasePhase._check_keys(expected_config, config) @@ -41,7 +38,6 @@ def test_optional(): def test_variable_key(): - config = deepcopy(expected_config) _ = config.pop("param5 (variable)") @@ -50,7 +46,6 @@ def test_variable_key(): def test_optional_dict(): - config = deepcopy(expected_config) _ = config.pop("param6") diff --git a/tests/test_config_management.py b/tests/test_config_management.py index f635f271..ffd84920 100644 --- a/tests/test_config_management.py +++ b/tests/test_config_management.py @@ -7,7 +7,6 @@ import os import pytest - from ORBIT import ProjectManager, load_config, save_config from ORBIT.core.library import extract_library_specs @@ -15,7 +14,6 @@ def test_save_and_load_equality(tmp_yaml_del): - save_config(complete_project, "tmp.yaml", overwrite=True) new = load_config("tmp.yaml") @@ -23,7 +21,6 @@ def test_save_and_load_equality(tmp_yaml_del): def test_orbit_version_ProjectManager(): - config = ProjectManager.compile_input_dict( ["MonopileDesign", "MonopileInstallation"] ) diff --git a/tests/test_design_install_phase_interactions.py b/tests/test_design_install_phase_interactions.py index 059202fb..656db0d8 100644 --- a/tests/test_design_install_phase_interactions.py +++ b/tests/test_design_install_phase_interactions.py @@ -6,9 +6,8 @@ from copy import deepcopy -from numpy.testing import assert_almost_equal - from ORBIT import ProjectManager +from numpy.testing import assert_almost_equal from ORBIT.core.library import extract_library_specs fixed = extract_library_specs("config", "complete_project") @@ -16,7 +15,6 @@ def test_fixed_phase_cost_passing(): - project = ProjectManager(fixed) project.run() @@ -47,7 +45,6 @@ def test_fixed_phase_cost_passing(): def test_floating_phase_cost_passing(): - project = ProjectManager(floating) project.run() diff --git a/tests/test_parametric.py b/tests/test_parametric.py index 4d73da75..5d33cfca 100644 --- a/tests/test_parametric.py +++ b/tests/test_parametric.py @@ -7,9 +7,8 @@ import pandas as pd import pytest -from benedict import benedict - from ORBIT import ProjectManager, ParametricManager +from benedict import benedict from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import TurbineInstallation @@ -24,7 +23,6 @@ def test_for_equal_results(): - config = benedict(deepcopy(complete_project)) config["site.distance"] = 20 project = ProjectManager(config) @@ -37,7 +35,6 @@ def test_for_equal_results(): def test_weather(): - without = ParametricManager(complete_project, params, funcs) without.run() @@ -50,7 +47,6 @@ def test_weather(): def test_individual_phase(): - config = benedict(deepcopy(complete_project)) config["site.distance"] = 20 phase = TurbineInstallation(config) @@ -67,7 +63,6 @@ def test_individual_phase(): def test_bad_result_attribute(): - funcs = {"result": lambda phase: phase.nonexistent_result} parametric = ParametricManager( @@ -79,7 +74,6 @@ def test_bad_result_attribute(): def test_bad_result_structure(): - funcs = {"result": "bos_capex"} parametric = ParametricManager( @@ -91,7 +85,6 @@ def test_bad_result_structure(): def test_product_option(): - params = {"site.distance": [20, 40, 60], "site.depth": [20, 40, 60]} parametric = ParametricManager( diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 7e62a225..9cbf9ad3 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -8,10 +8,9 @@ import pandas as pd import pytest - from ORBIT import ProjectManager -from ORBIT.phases import InstallPhase, DesignPhase from tests.data import test_weather +from ORBIT.phases import DesignPhase, InstallPhase from ORBIT.manager import ProjectProgress from ORBIT.core.library import extract_library_specs from ORBIT.core.exceptions import ( @@ -26,10 +25,10 @@ config = extract_library_specs("config", "project_manager") complete_project = extract_library_specs("config", "complete_project") + ### Top Level @pytest.mark.parametrize("weather", (None, weather_df)) def test_complete_run(weather): - project = ProjectManager(config, weather=weather) project.run() @@ -47,11 +46,9 @@ def test_for_required_phase_structure(): """ for p in ProjectManager._install_phases: - assert isinstance(p.expected_config, dict) for p in ProjectManager._design_phases: - assert isinstance(p.expected_config, dict) assert isinstance(p.output_config, dict) @@ -130,7 +127,6 @@ class SpecificTurbineInstallation(InstallPhase): ] for test in tests: - i, expected = test response = TestProjectManager.find_key_match(i) @@ -143,13 +139,11 @@ class SpecificTurbineInstallation(InstallPhase): ] for f in fails: - assert TestProjectManager.find_key_match(f) is None ### Overlapping Install Phases def test_install_phase_start_parsing(): - config_mixed_starts = deepcopy(config) config_mixed_starts["install_phases"] = { "MonopileInstallation": 0, @@ -169,7 +163,6 @@ def test_install_phase_start_parsing(): def test_chained_dependencies(): - config_chained = deepcopy(config) config_chained["spi_vessel"] = "test_scour_protection_vessel" config_chained["scour_protection"] = { @@ -233,7 +226,6 @@ def test_index_starts(m_start, t_start): ], ) def test_start_dates_with_weather(m_start, t_start, expected): - config_with_defined_starts = deepcopy(config) config_with_defined_starts["install_phases"] = { "MonopileInstallation": m_start, @@ -283,7 +275,6 @@ def test_duplicate_phase_definitions(): def test_custom_install_phases(): - # Not a subclass class CustomInstallPhase: pass @@ -305,7 +296,6 @@ class MonopileInstallation(InstallPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileInstallation) - # Bad name format class MonopileInstallation_Custom(InstallPhase): pass @@ -318,11 +308,13 @@ class CustomInstallPhase(InstallPhase): pass ProjectManager.register_install_phase(CustomInstallPhase) - assert ProjectManager.find_key_match("CustomInstallPhase") == CustomInstallPhase + assert ( + ProjectManager.find_key_match("CustomInstallPhase") + == CustomInstallPhase + ) def test_custom_design_phases(): - # Not a subclass class CustomDesignPhase: pass @@ -344,7 +336,6 @@ class MonopileDesign(DesignPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileDesign) - # Bad name format class MonopileDesign_Custom(DesignPhase): pass @@ -357,11 +348,13 @@ class CustomDesignPhase(DesignPhase): pass ProjectManager.register_design_phase(CustomDesignPhase) - assert ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase + assert ( + ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase + ) + ### Design Phase Interactions def test_design_phases(): - config_with_design = deepcopy(config) # Add MonopileDesign @@ -386,7 +379,6 @@ def test_design_phases(): ### Outputs def test_resolve_project_capacity(): - # Missing turbine rating config1 = {"plant": {"capacity": 600, "num_turbines": 40}} @@ -467,7 +459,6 @@ def test_resolve_project_capacity(): ### Exceptions def test_incomplete_config(): - incomplete_config = deepcopy(config) _ = incomplete_config["site"].pop("depth") @@ -477,7 +468,6 @@ def test_incomplete_config(): def test_wrong_phases(): - wrong_phases = deepcopy(config) wrong_phases["install_phases"].append("IncorrectPhaseName") @@ -487,7 +477,6 @@ def test_wrong_phases(): def test_bad_dates(): - bad_dates = deepcopy(config) bad_dates["install_phases"] = { "MonopileInstallation": "03/01/2015", @@ -500,7 +489,6 @@ def test_bad_dates(): def test_no_defined_start(): - missing_start = deepcopy(config) missing_start["install_phases"] = { "MonopileInstallation": ("TurbineInstallation", 0.1), @@ -513,7 +501,6 @@ def test_no_defined_start(): def test_circular_dependencies(): - circular_deps = deepcopy(config) circular_deps["spi_vessel"] = "test_scour_protection_vessel" circular_deps["scour_protection"] = { @@ -532,7 +519,6 @@ def test_circular_dependencies(): def test_dependent_phase_ordering(): - wrong_order = deepcopy(config) wrong_order["spi_vessel"] = "test_scour_protection_vessel" wrong_order["scour_protection"] = { @@ -552,7 +538,6 @@ def test_dependent_phase_ordering(): def test_ProjectProgress(): - data = [ ("Export System", 10), ("Offshore Substation", 20), @@ -592,7 +577,6 @@ def test_ProjectProgress(): def test_ProjectProgress_with_incomplete_project(): - project = ProjectManager(config) project.run() @@ -607,7 +591,6 @@ def test_ProjectProgress_with_incomplete_project(): def test_ProjectProgress_with_complete_project(): - project = ProjectManager(complete_project) project.run() @@ -633,7 +616,6 @@ def test_ProjectProgress_with_complete_project(): def test_monthly_expenses(): - project = ProjectManager(complete_project) project.run() _ = project.monthly_expenses @@ -649,7 +631,6 @@ def test_monthly_expenses(): def test_monthly_revenue(): - project = ProjectManager(complete_project) project.run() _ = project.monthly_revenue @@ -666,7 +647,6 @@ def test_monthly_revenue(): def test_cash_flow(): - project = ProjectManager(complete_project) project.run() _ = project.cash_flow @@ -684,7 +664,6 @@ def test_cash_flow(): def test_npv(): - project = ProjectManager(complete_project) project.run() baseline = project.npv @@ -721,7 +700,6 @@ def test_npv(): def test_soft_costs(): - project = ProjectManager(complete_project) baseline = project.soft_capex @@ -757,7 +735,6 @@ def test_soft_costs(): def test_project_costs(): - project = ProjectManager(complete_project) baseline = project.project_capex @@ -783,7 +760,6 @@ def test_project_costs(): def test_capex_categories(): - project = ProjectManager(complete_project) project.run() baseline = project.capex_breakdown diff --git a/versioneer.py b/versioneer.py index 64fea1c8..96361d2f 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,4 +1,3 @@ - # Version: 0.18 """The Versioneer - like a rocketeer, but for versions. @@ -277,16 +276,18 @@ """ from __future__ import print_function + +import os +import re +import sys +import json +import errno +import subprocess + try: import configparser except ImportError: import ConfigParser as configparser -import errno -import json -import os -import re -import subprocess -import sys class VersioneerConfig: @@ -308,11 +309,13 @@ def get_root(): setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") + err = ( + "Versioneer was unable to run the project root directory. " + "Versioneer requires setup.py to be executed from " + "its immediate directory (like 'python setup.py COMMAND'), " + "or in a way that lets it use sys.argv[0] to find the root " + "(like 'python path/to/setup.py COMMAND')." + ) raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools @@ -325,8 +328,10 @@ def get_root(): me_dir = os.path.normcase(os.path.splitext(me)[0]) vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) if me_dir != vsr_dir: - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py)) + print( + "Warning: build in %s is using versioneer.py from %s" + % (os.path.dirname(me), versioneer_py) + ) except NameError: pass return root @@ -348,6 +353,7 @@ def get(parser, name): if parser.has_option("versioneer", name): return parser.get("versioneer", name) return None + cfg = VersioneerConfig() cfg.VCS = VCS cfg.style = get(parser, "style") or "" @@ -372,17 +378,20 @@ class NotThisMethod(Exception): def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" + def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f + return decorate -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands, args, cwd=None, verbose=False, hide_stderr=False, env=None +): """Call the given command(s).""" assert isinstance(commands, list) p = None @@ -390,10 +399,13 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) + p = subprocess.Popen( + [c] + args, + cwd=cwd, + env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr else None), + ) break except EnvironmentError: e = sys.exc_info()[1] @@ -418,7 +430,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, return stdout, p.returncode -LONG_VERSION_PY['git'] = ''' +LONG_VERSION_PY[ + "git" +] = ''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -993,7 +1007,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -1002,7 +1016,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) + tags = set([r for r in refs if re.search(r"\d", r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -1010,19 +1024,26 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] + r = ref[len(tag_prefix) :] if verbose: print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} + return { + "version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": None, + "date": date, + } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} + return { + "version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, + "error": "no suitable tags", + "date": None, + } @register_vcs_handler("git", "pieces_from_vcs") @@ -1037,8 +1058,9 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + out, rc = run_command( + GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True + ) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -1046,10 +1068,19 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = run_command( + GITS, + [ + "describe", + "--tags", + "--dirty", + "--always", + "--long", + "--match", + "%s*" % tag_prefix, + ], + cwd=root, + ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -1072,17 +1103,18 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] + git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) + mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) + pieces["error"] = ( + "unable to parse git-describe output: '%s'" % describe_out + ) return pieces # tag @@ -1091,10 +1123,12 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) + pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( + full_tag, + tag_prefix, + ) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] + pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -1105,13 +1139,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) + count_out, rc = run_command( + GITS, ["rev-list", "HEAD", "--count"], cwd=root + ) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ + 0 + ].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -1167,16 +1203,22 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} + return { + "version": dirname[len(parentdir_prefix) :], + "full-revisionid": None, + "dirty": False, + "error": None, + "date": None, + } else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) + print( + "Tried directories %s but none started with prefix %s" + % (str(rootdirs), parentdir_prefix) + ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -1205,11 +1247,17 @@ def versions_from_file(filename): contents = f.read() except EnvironmentError: raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) + mo = re.search( + r"version_json = '''\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) if not mo: - mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) + mo = re.search( + r"version_json = '''\r\n(.*)''' # END VERSION_JSON", + contents, + re.M | re.S, + ) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) @@ -1218,8 +1266,9 @@ def versions_from_file(filename): def write_to_version_file(filename, versions): """Write the given version number to the given _version.py file.""" os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) + contents = json.dumps( + versions, sort_keys=True, indent=1, separators=(",", ": ") + ) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) @@ -1251,8 +1300,7 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -1366,11 +1414,13 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} + return { + "version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None, + } if not style or style == "default": style = "pep440" # the default @@ -1390,9 +1440,13 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} + return { + "version": rendered, + "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], + "error": None, + "date": pieces.get("date"), + } class VersioneerBadRootError(Exception): @@ -1415,8 +1469,9 @@ def get_versions(verbose=False): handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" + assert ( + cfg.versionfile_source is not None + ), "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) @@ -1470,9 +1525,13 @@ def get_versions(verbose=False): if verbose: print("unable to compute version") - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} + return { + "version": "0+unknown", + "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", + "date": None, + } def get_version(): @@ -1521,6 +1580,7 @@ def run(self): print(" date: %s" % vers.get("date")) if vers["error"]: print(" error: %s" % vers["error"]) + cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools @@ -1553,14 +1613,17 @@ def run(self): # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) + target_versionfile = os.path.join( + self.build_lib, cfg.versionfile_build + ) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) + cmds["build_py"] = cmd_build_py if "cx_Freeze" in sys.modules: # cx_freeze enabled? from cx_Freeze.dist import build_exe as _build_exe + # nczeczulin reports that py2exe won't like the pep440-style string # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. # setup(console=[{ @@ -1581,17 +1644,21 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + cmds["build_exe"] = cmd_build_exe del cmds["build_py"] - if 'py2exe' in sys.modules: # py2exe enabled? + if "py2exe" in sys.modules: # py2exe enabled? try: from py2exe.distutils_buildexe import py2exe as _py2exe # py3 except ImportError: @@ -1610,13 +1677,17 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + cmds["py2exe"] = cmd_py2exe # we override different "sdist" commands for both environments @@ -1643,8 +1714,10 @@ def make_release_tree(self, base_dir, files): # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) + write_to_version_file( + target_versionfile, self._versioneer_generated_versions + ) + cmds["sdist"] = cmd_sdist return cmds @@ -1699,11 +1772,15 @@ def do_setup(): root = get_root() try: cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: + except ( + EnvironmentError, + configparser.NoSectionError, + configparser.NoOptionError, + ) as e: if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) + print( + "Adding sample versioneer config to setup.cfg", file=sys.stderr + ) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) @@ -1712,15 +1789,18 @@ def do_setup(): print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") + f.write( + LONG + % { + "DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + } + ) + + ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") if os.path.exists(ipy): try: with open(ipy, "r") as f: @@ -1762,8 +1842,10 @@ def do_setup(): else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) + print( + " appending versionfile_source ('%s') to MANIFEST.in" + % cfg.versionfile_source + ) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: From 30795dacda5939cd23cf5820adecc232e793c381 Mon Sep 17 00:00:00 2001 From: Shields Date: Thu, 23 Feb 2023 15:10:32 -0700 Subject: [PATCH 054/240] Suppress print statement in oss_install/floating.py --- ORBIT/phases/install/oss_install/floating.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index cc6fa94d..88f40dae 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -99,9 +99,9 @@ def system_capex(self): line_cost = self.config["mooring_system"]["line_cost"] anchor_cost = self.config["mooring_system"]["anchor_cost"] mooring_system_for_each_oss = num_mooring_lines*(line_cost + anchor_cost) - print('topside: ' + str(topside)) - print('oss substructure' + str(substructure)) - print('mooring system' + str(mooring_system_for_each_oss)) + # print('topside: ' + str(topside)) + # print('oss substructure' + str(substructure)) + # print('mooring system' + str(mooring_system_for_each_oss)) return self.num_substations * (topside + substructure + mooring_system_for_each_oss) def initialize_substructure_production(self): @@ -153,7 +153,7 @@ def initialize_installation_vessel(self): @property def detailed_output(self): - + return {} From 22a280efdc7f4e5cc09075edd998ef354ce028c8 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker <42254629+JakeNunemaker@users.noreply.github.com> Date: Tue, 14 Mar 2023 11:47:10 -0600 Subject: [PATCH 055/240] Feature/phase dates rework (#135) * Added check for mixed phase start types. * Added ProjectManager.start date and conditional logic to calculate phase dates if weather is not defined or phase starts are defined as ints. * Revised logic for calculating defined start time. * Added fixed timedelta functionality to dependent phases. * Added tests for fixed amount dependent phases. * Added test for phase_dates. * Removed ceil from several methods in ProjectManager. --- ORBIT/manager.py | 99 ++++++++++++++++++++++------- tests/test_project_manager.py | 113 ++++++++++++++++++++++++++++++++-- 2 files changed, 186 insertions(+), 26 deletions(-) diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 6aeb5ba1..a6b1ede8 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -126,6 +126,17 @@ def __init__(self, config, library_path=None, weather=None): self.phase_times = {} self._output_logs = [] + @property + def start_date(self): + """Return start date for the analysis. If weather is configured, the + first date in the weather profile is used. If weather is not configured, + an arbitary start date is assumed and used to index phase times.""" + + if self.weather is not None: + return self.weather.index[0].to_pydatetime() + + return dt.datetime(2010, 1, 1, 0, 0) + def run(self, **kwargs): """ Main project run method. @@ -675,7 +686,7 @@ def run_multiple_phases_in_serial(self, phase_list, **kwargs): pass self._output_logs.extend(logs) - start = ceil(start + time) + start = start + time def run_multiple_phases_overlapping(self, phases, **kwargs): """ @@ -778,7 +789,37 @@ def get_dependency_start_time(self, target, perc): start = self.phase_starts[target] elapsed = self.phase_times[target] - return start + elapsed * perc + if isinstance(perc, (int, float)): + + if (perc < 0.) or (perc > 1.): + raise ValueError(f"Dependent phase perc must be between 0. and 1.") + + return start + elapsed * perc + + if isinstance(perc, str): + + try: + delta = dt.timedelta( + **{ + v.split("=")[0].strip(): float(v.split("=")[1]) + for v in perc.split(";") + } + ) + + return start + delta.days * 24 + delta.seconds / 3600 + + except (TypeError, IndexError): + raise ValueError( + f"Dependent phase amount must be defined with this format: " + "'weeks=1;hours=12'. Accepted entries: 'weeks', 'days', 'hours'." + ) + + else: + raise ValueError( + f"Unrecognized dependent phase amount: '{perc}'. " + f"Must be float between 0. and 1.0 or str with format " + "'weeks=1;days=0;hours=12'" + ) @staticmethod def transform_weather_input(weather): @@ -827,24 +868,8 @@ def _parse_install_phase_values(self, phases): for k, v in phases.items(): - if isinstance(v, (int, float)): - defined[k] = ceil(v) - - elif isinstance(v, str): - _dt = dt.datetime.strptime(v, self.date_format_short) - - try: - i = self.weather.index.get_loc(_dt) - defined[k] = i - - except AttributeError: - raise ValueError( - f"No weather profile configured " - f"for '{k}': '{v}' input type." - ) - - except KeyError: - raise WeatherProfileError(_dt, self.weather) + if isinstance(v, (int, float, str)): + defined[k] = v elif isinstance(v, tuple) and len(v) == 2: depends[k] = v @@ -854,7 +879,32 @@ def _parse_install_phase_values(self, phases): if not defined: raise ValueError("No phases have a defined start index/date.") + + if len(set(type(i) for i in defined.values())) > 1: + raise ValueError( + "Defined start date types can't be mixed. " + "All must be an int (index location) or str (format: '%m/%d/%Y'). " + "This does not apply to the dependent phases defined as tuples." + ) + + for k, v in defined.items(): + + if isinstance(v, int): + continue + _dt = dt.datetime.strptime(v, self.date_format_short) + + if self.weather is not None: + try: + defined[k] = self.weather.index.get_loc(_dt) + + except KeyError: + raise WeatherProfileError(_dt, self.weather) + + else: + delta = (_dt - self.start_date) + defined[k] = delta.days * 24 + delta.seconds / 3600 + return defined, depends def get_weather_profile(self, start): @@ -1141,8 +1191,13 @@ def phase_dates(self): for phase, _start in self.config["install_phases"].items(): - start = dt.datetime.strptime(_start, self.date_format_short) - end = start + dt.timedelta(hours=ceil(self.phase_times[phase])) + try: + start = dt.datetime.strptime(_start, self.date_format_short) + + except TypeError: + start = self.start_date + dt.timedelta(hours=self.phase_starts[phase]) + + end = start + dt.timedelta(hours=self.phase_times[phase]) dates[phase] = { "start": start.strftime(self.date_format_long), diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 7e62a225..113c2ac8 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -7,6 +7,7 @@ from copy import deepcopy import pandas as pd +import datetime as dt import pytest from ORBIT import ProjectManager @@ -148,11 +149,11 @@ class SpecificTurbineInstallation(InstallPhase): ### Overlapping Install Phases -def test_install_phase_start_parsing(): +def test_install_phase_start_parsing__dates(): config_mixed_starts = deepcopy(config) config_mixed_starts["install_phases"] = { - "MonopileInstallation": 0, + "MonopileInstallation": "10/22/2010", "TurbineInstallation": "10/22/2009", "ArrayCableInstallation": ("MonopileInstallation", 0.5), } @@ -164,10 +165,95 @@ def test_install_phase_start_parsing(): assert len(defined) == 2 assert len(depends) == 1 - assert defined["MonopileInstallation"] == 0 + assert defined["MonopileInstallation"] == 8761 assert defined["TurbineInstallation"] == 1 +def test_install_phase_start_parsing__ints(): + + config_mixed_starts = deepcopy(config) + config_mixed_starts["install_phases"] = { + "MonopileInstallation": 0, + "TurbineInstallation": 100, + "ArrayCableInstallation": ("MonopileInstallation", 0.5), + } + + project = ProjectManager(config_mixed_starts, weather=weather_df) + defined, depends = project._parse_install_phase_values( + config_mixed_starts["install_phases"] + ) + assert len(defined) == 2 + assert len(depends) == 1 + + assert defined["MonopileInstallation"] == 0 + assert defined["TurbineInstallation"] == 100 + +@pytest.mark.parametrize("weather", (None, weather_df)) +@pytest.mark.parametrize("defined", (0, "10/22/2009")) +@pytest.mark.parametrize( + "amount_str, diff", + [ + ("hours=10", 10), + ("days=1", 24), + ("days=1;hours=10", 34), + ("weeks=1", 168), + ("weeks=1;days=1;hours=10", 202), + ] +) +def test_dependent_install_phases_fixed_amounts(weather, defined, amount_str, diff): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": defined, + "TurbineInstallation": ("MonopileInstallation", amount_str), + } + + project = ProjectManager(new, weather=weather) + project.run() + + diff_calc = project.phase_starts["TurbineInstallation"] - project.phase_starts["MonopileInstallation"] + + assert diff_calc == diff + + +@pytest.mark.parametrize("input_val", (-1, 1.2, "years=10", "days:10")) +def test_dependent_install_phases_bad_inputs(input_val): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": 0, + "TurbineInstallation": ("MonopileInstallation", input_val), + } + + project = ProjectManager(new) + + with pytest.raises(ValueError): + project.run() + + +@pytest.mark.parametrize("weather", (None, weather_df)) +@pytest.mark.parametrize("defined", (0, "10/22/2009")) +@pytest.mark.parametrize("input_val", (0.5, "hours=10", "days=1;hours=10")) +def test_dependent_install_phases_phase_dates(weather, defined, input_val): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": defined, + "TurbineInstallation": ("MonopileInstallation", input_val), + } + + project = ProjectManager(new, weather=weather) + project.run() + + phase_dates = project.phase_dates + for p in ["MonopileInstallation", "TurbineInstallation"]: + assert p in phase_dates + + for key in ["start", "end"]: + _ = dt.datetime.strptime(phase_dates[p][key], project.date_format_long) + assert True + + def test_chained_dependencies(): config_chained = deepcopy(config) @@ -227,7 +313,6 @@ def test_index_starts(m_start, t_start): [ (0, 0, 0), (0, 1000, 1000), - (0, "05/01/2010", 4585), ("03/01/2010", "03/01/2010", 0), ("03/01/2010", "05/01/2010", 1464), ], @@ -251,6 +336,26 @@ def test_start_dates_with_weather(m_start, t_start, expected): assert _diff == expected +@pytest.mark.parametrize( + "m_start, t_start", + [ + (0, "03/01/2010"), + ("03/01/2010", 0), + ], +) +def test_mixed_start_date_types(m_start, t_start): + + config_with_defined_starts = deepcopy(config) + config_with_defined_starts["install_phases"] = { + "MonopileInstallation": m_start, + "TurbineInstallation": t_start, + "ArrayCableInstallation": ("MonopileInstallation", 0.5), + } + + with pytest.raises(ValueError): + project = ProjectManager(config_with_defined_starts, weather_df) + project.run() + def test_duplicate_phase_definitions(): config_with_duplicates = deepcopy(config) config_with_duplicates["MonopileInstallation_1"] = { From 48f84b00297bf6b25ee12effc3d08077de2c0b4b Mon Sep 17 00:00:00 2001 From: asharma Date: Fri, 3 Mar 2023 16:15:05 -0700 Subject: [PATCH 056/240] Make delay messages more informative --- ORBIT/phases/install/jacket_install/standard.py | 2 +- ORBIT/phases/install/monopile_install/standard.py | 2 +- ORBIT/phases/install/oss_install/standard.py | 2 +- ORBIT/phases/install/quayside_assembly_tow/gravity_base.py | 2 +- ORBIT/phases/install/quayside_assembly_tow/moored.py | 2 +- ORBIT/phases/install/turbine_install/standard.py | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ORBIT/phases/install/jacket_install/standard.py b/ORBIT/phases/install/jacket_install/standard.py index 2f8f0c55..95fb7402 100644 --- a/ORBIT/phases/install/jacket_install/standard.py +++ b/ORBIT/phases/install/jacket_install/standard.py @@ -480,7 +480,7 @@ def install_jackets_from_queue( start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay", delay_time, location="Site") + wtiv.submit_action_log("Delay: Not enough vessels for jackets", delay_time, location="Site") # Transit to port wtiv.at_site = False diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py index 5a204709..da16ad13 100644 --- a/ORBIT/phases/install/monopile_install/standard.py +++ b/ORBIT/phases/install/monopile_install/standard.py @@ -441,7 +441,7 @@ def install_monopiles_from_queue(wtiv, queue, monopiles, distance, **kwargs): start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay", delay_time, location="Site") + wtiv.submit_action_log("Delay: Not enough vessels for monopiles", delay_time, location="Site") # Transit to port wtiv.at_site = False diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index 04038af9..c69f160d 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -257,7 +257,7 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): start = vessel.env.now yield queue.activate delay_time = vessel.env.now - start - vessel.submit_action_log("Delay", delay_time, location="Site") + vessel.submit_action_log("Delay: Not enough vessels for oss", delay_time, location="Site") # Transit to port vessel.at_site = False diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index 4cbd97f6..6772a5cb 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -407,6 +407,6 @@ def install_gravity_base_foundations( delay_time = vessel.env.now - start if n != 0: - vessel.submit_action_log("Delay", delay_time, location="Site") + vessel.submit_action_log("Delay: Not enough vessels for gravity foundations", delay_time, location="Site") yield vessel.transit(distance) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index c79fbe66..a7cf9447 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -412,6 +412,6 @@ def install_moored_substructures( delay_time = vessel.env.now - start if n != 0: - vessel.submit_action_log("Delay", delay_time, location="Site") + vessel.submit_action_log("Delay: Not enough vessels for Moored substructures", delay_time, location="Site") yield vessel.transit(distance) diff --git a/ORBIT/phases/install/turbine_install/standard.py b/ORBIT/phases/install/turbine_install/standard.py index d23515a1..c05e3088 100644 --- a/ORBIT/phases/install/turbine_install/standard.py +++ b/ORBIT/phases/install/turbine_install/standard.py @@ -458,7 +458,7 @@ def install_turbine_components_from_queue( start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay", delay_time, location="Site") + wtiv.submit_action_log("Delay: Not enough vessels for turbines", delay_time, location="Site") # Transit to port wtiv.at_site = False From 866c8d222b9ec94c2a7e505db82a271d32650485 Mon Sep 17 00:00:00 2001 From: Shields Date: Wed, 15 Mar 2023 11:58:47 -0600 Subject: [PATCH 057/240] Add electrical commissioning process (and update nacelle lift time) in TurbineAssemblyLine --- .../install/quayside_assembly_tow/common.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 252965b7..354a7367 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -213,6 +213,8 @@ def assemble_turbine(self): yield self.mechanical_completion() + yield self.electrical_completion() + start = self.env.now yield self.target.put(1) delay = self.env.now - start @@ -267,7 +269,7 @@ def lift_and_attach_nacelle(self): """ yield self.task( - "Lift and Attach Nacelle", 7, constraints={"windspeed": le(15)} + "Lift and Attach Nacelle", 12, constraints={"windspeed": le(15)} ) @process @@ -292,6 +294,17 @@ def mechanical_completion(self): "Mechanical Completion", 24, constraints={"windspeed": le(18)} ) + @process + def electrical_completion(self): + """ + Task representing time associated with performing electrical completion + work at quayside, including precommissioning. Assumes the tower is delivered to port in multiple sections, requiring cable pull-in after tower assembly. + """ + + yield self.task( + "Electrical Completion", 72, constraints={"windspeed": le(18)} + ) + class TowingGroup(Agent): """Class to represent an arbitrary group of towing vessels.""" From 53559c32e1d56e74608dc7fe3a1e0780de0bb6a3 Mon Sep 17 00:00:00 2001 From: Shields Date: Wed, 15 Mar 2023 13:19:57 -0600 Subject: [PATCH 058/240] Update tower section process time in TurbineAssemblyLine --- ORBIT/phases/install/quayside_assembly_tow/common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 354a7367..6fcd9e4f 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -257,7 +257,7 @@ def lift_and_attach_tower_section(self): yield self.task( "Lift and Attach Tower Section", - 12, + 4, constraints={"windspeed": le(15)}, ) From 5b400aba9d2b5a5f7a4d6affe025a763f54c4b41 Mon Sep 17 00:00:00 2001 From: Shields Date: Wed, 15 Mar 2023 13:55:11 -0600 Subject: [PATCH 059/240] Added constraint for O&M activities at port to TurbineAssemblyLine.move_substructure --- ORBIT/phases/install/quayside_assembly_tow/common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 6fcd9e4f..a37fea5a 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -237,7 +237,7 @@ def move_substructure(self): TODO: Move to dynamic process involving tow groups. """ - yield self.task("Move Substructure", 8) + yield self.task("Move Substructure", 8, {'port_in_use': false()}) @process def prepare_for_assembly(self): From 5cc306d64bdf452ed4c147f3bd3991d14e6d4035 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker <42254629+JakeNunemaker@users.noreply.github.com> Date: Tue, 14 Mar 2023 11:47:10 -0600 Subject: [PATCH 060/240] Feature/phase dates rework (#135) * Added check for mixed phase start types. * Added ProjectManager.start date and conditional logic to calculate phase dates if weather is not defined or phase starts are defined as ints. * Revised logic for calculating defined start time. * Added fixed timedelta functionality to dependent phases. * Added tests for fixed amount dependent phases. * Added test for phase_dates. * Removed ceil from several methods in ProjectManager. --- ORBIT/manager.py | 99 ++++++++++++++++++++++------- tests/test_project_manager.py | 113 ++++++++++++++++++++++++++++++++-- 2 files changed, 186 insertions(+), 26 deletions(-) diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 3252b650..303ecbaf 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -132,6 +132,17 @@ def __init__(self, config, library_path=None, weather=None): self.phase_times = {} self._output_logs = [] + @property + def start_date(self): + """Return start date for the analysis. If weather is configured, the + first date in the weather profile is used. If weather is not configured, + an arbitary start date is assumed and used to index phase times.""" + + if self.weather is not None: + return self.weather.index[0].to_pydatetime() + + return dt.datetime(2010, 1, 1, 0, 0) + def run(self, **kwargs): """ Main project run method. @@ -681,7 +692,7 @@ def run_multiple_phases_in_serial(self, phase_list, **kwargs): pass self._output_logs.extend(logs) - start = ceil(start + time) + start = start + time def run_multiple_phases_overlapping(self, phases, **kwargs): """ @@ -784,7 +795,37 @@ def get_dependency_start_time(self, target, perc): start = self.phase_starts[target] elapsed = self.phase_times[target] - return start + elapsed * perc + if isinstance(perc, (int, float)): + + if (perc < 0.) or (perc > 1.): + raise ValueError(f"Dependent phase perc must be between 0. and 1.") + + return start + elapsed * perc + + if isinstance(perc, str): + + try: + delta = dt.timedelta( + **{ + v.split("=")[0].strip(): float(v.split("=")[1]) + for v in perc.split(";") + } + ) + + return start + delta.days * 24 + delta.seconds / 3600 + + except (TypeError, IndexError): + raise ValueError( + f"Dependent phase amount must be defined with this format: " + "'weeks=1;hours=12'. Accepted entries: 'weeks', 'days', 'hours'." + ) + + else: + raise ValueError( + f"Unrecognized dependent phase amount: '{perc}'. " + f"Must be float between 0. and 1.0 or str with format " + "'weeks=1;days=0;hours=12'" + ) @staticmethod def transform_weather_input(weather): @@ -833,24 +874,8 @@ def _parse_install_phase_values(self, phases): for k, v in phases.items(): - if isinstance(v, (int, float)): - defined[k] = ceil(v) - - elif isinstance(v, str): - _dt = dt.datetime.strptime(v, self.date_format_short) - - try: - i = self.weather.index.get_loc(_dt) - defined[k] = i - - except AttributeError: - raise ValueError( - f"No weather profile configured " - f"for '{k}': '{v}' input type." - ) - - except KeyError: - raise WeatherProfileError(_dt, self.weather) + if isinstance(v, (int, float, str)): + defined[k] = v elif isinstance(v, tuple) and len(v) == 2: depends[k] = v @@ -860,7 +885,32 @@ def _parse_install_phase_values(self, phases): if not defined: raise ValueError("No phases have a defined start index/date.") + + if len(set(type(i) for i in defined.values())) > 1: + raise ValueError( + "Defined start date types can't be mixed. " + "All must be an int (index location) or str (format: '%m/%d/%Y'). " + "This does not apply to the dependent phases defined as tuples." + ) + + for k, v in defined.items(): + + if isinstance(v, int): + continue + _dt = dt.datetime.strptime(v, self.date_format_short) + + if self.weather is not None: + try: + defined[k] = self.weather.index.get_loc(_dt) + + except KeyError: + raise WeatherProfileError(_dt, self.weather) + + else: + delta = (_dt - self.start_date) + defined[k] = delta.days * 24 + delta.seconds / 3600 + return defined, depends def get_weather_profile(self, start): @@ -1147,8 +1197,13 @@ def phase_dates(self): for phase, _start in self.config["install_phases"].items(): - start = dt.datetime.strptime(_start, self.date_format_short) - end = start + dt.timedelta(hours=ceil(self.phase_times[phase])) + try: + start = dt.datetime.strptime(_start, self.date_format_short) + + except TypeError: + start = self.start_date + dt.timedelta(hours=self.phase_starts[phase]) + + end = start + dt.timedelta(hours=self.phase_times[phase]) dates[phase] = { "start": start.strftime(self.date_format_long), diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 7e62a225..113c2ac8 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -7,6 +7,7 @@ from copy import deepcopy import pandas as pd +import datetime as dt import pytest from ORBIT import ProjectManager @@ -148,11 +149,11 @@ class SpecificTurbineInstallation(InstallPhase): ### Overlapping Install Phases -def test_install_phase_start_parsing(): +def test_install_phase_start_parsing__dates(): config_mixed_starts = deepcopy(config) config_mixed_starts["install_phases"] = { - "MonopileInstallation": 0, + "MonopileInstallation": "10/22/2010", "TurbineInstallation": "10/22/2009", "ArrayCableInstallation": ("MonopileInstallation", 0.5), } @@ -164,10 +165,95 @@ def test_install_phase_start_parsing(): assert len(defined) == 2 assert len(depends) == 1 - assert defined["MonopileInstallation"] == 0 + assert defined["MonopileInstallation"] == 8761 assert defined["TurbineInstallation"] == 1 +def test_install_phase_start_parsing__ints(): + + config_mixed_starts = deepcopy(config) + config_mixed_starts["install_phases"] = { + "MonopileInstallation": 0, + "TurbineInstallation": 100, + "ArrayCableInstallation": ("MonopileInstallation", 0.5), + } + + project = ProjectManager(config_mixed_starts, weather=weather_df) + defined, depends = project._parse_install_phase_values( + config_mixed_starts["install_phases"] + ) + assert len(defined) == 2 + assert len(depends) == 1 + + assert defined["MonopileInstallation"] == 0 + assert defined["TurbineInstallation"] == 100 + +@pytest.mark.parametrize("weather", (None, weather_df)) +@pytest.mark.parametrize("defined", (0, "10/22/2009")) +@pytest.mark.parametrize( + "amount_str, diff", + [ + ("hours=10", 10), + ("days=1", 24), + ("days=1;hours=10", 34), + ("weeks=1", 168), + ("weeks=1;days=1;hours=10", 202), + ] +) +def test_dependent_install_phases_fixed_amounts(weather, defined, amount_str, diff): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": defined, + "TurbineInstallation": ("MonopileInstallation", amount_str), + } + + project = ProjectManager(new, weather=weather) + project.run() + + diff_calc = project.phase_starts["TurbineInstallation"] - project.phase_starts["MonopileInstallation"] + + assert diff_calc == diff + + +@pytest.mark.parametrize("input_val", (-1, 1.2, "years=10", "days:10")) +def test_dependent_install_phases_bad_inputs(input_val): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": 0, + "TurbineInstallation": ("MonopileInstallation", input_val), + } + + project = ProjectManager(new) + + with pytest.raises(ValueError): + project.run() + + +@pytest.mark.parametrize("weather", (None, weather_df)) +@pytest.mark.parametrize("defined", (0, "10/22/2009")) +@pytest.mark.parametrize("input_val", (0.5, "hours=10", "days=1;hours=10")) +def test_dependent_install_phases_phase_dates(weather, defined, input_val): + + new = deepcopy(config) + new["install_phases"] = { + "MonopileInstallation": defined, + "TurbineInstallation": ("MonopileInstallation", input_val), + } + + project = ProjectManager(new, weather=weather) + project.run() + + phase_dates = project.phase_dates + for p in ["MonopileInstallation", "TurbineInstallation"]: + assert p in phase_dates + + for key in ["start", "end"]: + _ = dt.datetime.strptime(phase_dates[p][key], project.date_format_long) + assert True + + def test_chained_dependencies(): config_chained = deepcopy(config) @@ -227,7 +313,6 @@ def test_index_starts(m_start, t_start): [ (0, 0, 0), (0, 1000, 1000), - (0, "05/01/2010", 4585), ("03/01/2010", "03/01/2010", 0), ("03/01/2010", "05/01/2010", 1464), ], @@ -251,6 +336,26 @@ def test_start_dates_with_weather(m_start, t_start, expected): assert _diff == expected +@pytest.mark.parametrize( + "m_start, t_start", + [ + (0, "03/01/2010"), + ("03/01/2010", 0), + ], +) +def test_mixed_start_date_types(m_start, t_start): + + config_with_defined_starts = deepcopy(config) + config_with_defined_starts["install_phases"] = { + "MonopileInstallation": m_start, + "TurbineInstallation": t_start, + "ArrayCableInstallation": ("MonopileInstallation", 0.5), + } + + with pytest.raises(ValueError): + project = ProjectManager(config_with_defined_starts, weather_df) + project.run() + def test_duplicate_phase_definitions(): config_with_duplicates = deepcopy(config) config_with_duplicates["MonopileInstallation_1"] = { From e58c88612819850be23bfba000fb6e15ce369583 Mon Sep 17 00:00:00 2001 From: asharma Date: Wed, 15 Mar 2023 14:23:12 -0600 Subject: [PATCH 061/240] change default value to boolean --- ORBIT/phases/install/quayside_assembly_tow/common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index a37fea5a..a2e83c49 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -237,7 +237,7 @@ def move_substructure(self): TODO: Move to dynamic process involving tow groups. """ - yield self.task("Move Substructure", 8, {'port_in_use': false()}) + yield self.task("Move Substructure", 8, {'port_in_use': False}) @process def prepare_for_assembly(self): From 04009f25a02d0e11ea5920a7f6baec7da510ca03 Mon Sep 17 00:00:00 2001 From: asharma Date: Wed, 15 Mar 2023 21:30:09 -0600 Subject: [PATCH 062/240] implementation for transfering and installing --- ORBIT/core/library.py | 3 +- .../install/quayside_assembly_tow/common.py | 43 ++- .../quayside_assembly_tow/gravity_base.py | 26 +- .../install/quayside_assembly_tow/moored.py | 284 ++++++++---------- .../doc_MooredSubInstallation.rst | 1 + library/vessels/example_ahts_vessel.yaml | 6 + .../project/config/moored_install.yaml | 4 +- .../config/moored_install_multi_assembly.yaml | 21 ++ ...ored_install_multi_assembly_multi_tow.yaml | 21 ++ .../config/moored_install_multi_tow.yaml | 21 ++ .../config/moored_install_no_supply.yaml | 4 +- .../library/vessels/test_ahts_vessel.yaml | 6 + .../quayside_assembly_tow/test_moored.py | 27 +- 13 files changed, 283 insertions(+), 184 deletions(-) create mode 100644 library/vessels/example_ahts_vessel.yaml create mode 100644 tests/data/library/project/config/moored_install_multi_assembly.yaml create mode 100644 tests/data/library/project/config/moored_install_multi_assembly_multi_tow.yaml create mode 100644 tests/data/library/project/config/moored_install_multi_tow.yaml create mode 100644 tests/data/library/vessels/test_ahts_vessel.yaml diff --git a/ORBIT/core/library.py b/ORBIT/core/library.py index 6f771cc0..e33b4523 100644 --- a/ORBIT/core/library.py +++ b/ORBIT/core/library.py @@ -38,12 +38,12 @@ import yaml import pandas as pd from yaml import Dumper - from ORBIT.core.exceptions import LibraryItemNotFoundError ROOT = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../..")) default_library = os.path.join(ROOT, "library") + # Need a custom loader to read in scientific notation correctly class CustomSafeLoader(yaml.SafeLoader): def construct_python_tuple(self, node): @@ -277,6 +277,7 @@ def export_library_specs(key, filename, data, file_ext="yaml"): "wtiv": "vessels", "towing_vessel": "vessels", "support_vessel": "vessels", + "ahts_vessel": "vessels", # cables "cables": "cables", "array_system": "cables", diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index a2e83c49..5ca39c6a 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -237,7 +237,7 @@ def move_substructure(self): TODO: Move to dynamic process involving tow groups. """ - yield self.task("Move Substructure", 8, {'port_in_use': False}) + yield self.task("Move Substructure", 8, {"port_in_use": False}) @process def prepare_for_assembly(self): @@ -309,7 +309,7 @@ def electrical_completion(self): class TowingGroup(Agent): """Class to represent an arbitrary group of towing vessels.""" - def __init__(self, vessel_specs, num=1): + def __init__(self, vessel_specs, ahts_vessel_specs=None, num=1): """ Creates an instance of TowingGroup. @@ -318,13 +318,27 @@ def __init__(self, vessel_specs, num=1): vessel_specs : dict Specs for the individual vessels used in the towing group. Currently restricted to one vessel specification per group. + num : int + Towing group number + ahts_vessel_specs : dict + Specs for the anchor hndling tug vessel. """ super().__init__(f"Towing Group {num}") self._specs = vessel_specs - self.day_rate = self._specs["vessel_specs"]["day_rate"] + self.day_rate_towing = self._specs["vessel_specs"]["day_rate"] + self.day_rate_anchor = 0.0 self.transit_speed = self._specs["transport_specs"]["transit_speed"] + if ahts_vessel_specs is not None: + self.day_rate_anchor = ahts_vessel_specs["vessel_specs"][ + "day_rate" + ] + self.transit_speed = min( + vessel_specs["transport_specs"]["transit_speed"], + ahts_vessel_specs["transport_specs"]["transit_speed"], + ) + def initialize(self): """Initializes the towing group.""" @@ -332,7 +346,13 @@ def initialize(self): @process def group_task( - self, name, duration, num_vessels, constraints={}, **kwargs + self, + name, + duration, + num_vessels, + num_ahts_vessels=0, + constraints={}, + **kwargs, ): """ Submits a group task with any number of towing vessels. @@ -346,9 +366,12 @@ def group_task( Rounded up to the nearest int. num_vessels : int Number of individual towing vessels needed for the operation. + num_ahts_vessels : int + Number of anchor handling tug vessels used for the operation. """ kwargs = {**kwargs, "num_vessels": num_vessels} + kwargs = {**kwargs, "num_ahts_vessels": num_ahts_vessels} yield self.task(name, duration, constraints=constraints, **kwargs) def operation_cost(self, hours, **kwargs): @@ -365,8 +388,16 @@ def operation_cost(self, hours, **kwargs): """ mult = kwargs.get("cost_multiplier", 1.0) - vessels = kwargs.get("num_vessels", 1) - return (self.day_rate / 24) * vessels * hours * mult + num_towing_vessels = kwargs.get("num_vessels", 1) + num_ahts_vessels = kwargs.get("num_ahts_vessels", 0) + return ( + ( + (self.day_rate_towing / 24) * num_towing_vessels + + (self.day_rate_anchor / 24) * num_ahts_vessels + ) + * hours + * mult + ) def submit_action_log(self, action, duration, **kwargs): """ diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index 6772a5cb..665f6d7c 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -8,7 +8,6 @@ import simpy from marmot import le, process - from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -184,7 +183,7 @@ def initialize_towing_groups(self, **kwargs): towing_speed = self.config["substructure"].get("towing_speed", 6) for i in range(num_groups): - g = TowingGroup(vessel, num=i + 1) + g = TowingGroup(vessel, None, num=i + 1) self.env.register(g) g.initialize() self.installation_groups.append(g) @@ -293,18 +292,21 @@ def transfer_gbf_substructures_from_storage( transit_time = distance / group.transit_speed while True: - start = group.env.now assembly = yield feed.get() delay = group.env.now - start if delay > 0: group.submit_action_log( - "Delay: No Completed Assemblies Available", delay + "Delay: No Completed Assemblies Available", + delay, + num_vessels=towing_vessels, ) yield group.group_task( - "Tow Substructure", towing_time, num_vessels=towing_vessels + "Tow Substructure", + towing_time, + num_vessels=towing_vessels, ) # At Site @@ -314,7 +316,12 @@ def transfer_gbf_substructures_from_storage( queue_time = group.env.now - queue_start if queue_time > 0: - group.submit_action_log("Queue", queue_time, location="Site") + group.submit_action_log( + "Queue", + queue_time, + location="Site", + num_vessels=towing_vessels, + ) queue.vessel = group active_start = group.env.now @@ -357,7 +364,6 @@ def install_gravity_base_foundations( n = 0 while n < substructures: if queue.vessel: - start = vessel.env.now if n == 0: vessel.mobilize() @@ -407,6 +413,10 @@ def install_gravity_base_foundations( delay_time = vessel.env.now - start if n != 0: - vessel.submit_action_log("Delay: Not enough vessels for gravity foundations", delay_time, location="Site") + vessel.submit_action_log( + "Delay: Not enough vessels for gravity foundations", + delay_time, + location="Site", + ) yield vessel.transit(distance) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index a7cf9447..561df3a9 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -26,11 +26,11 @@ class MooredSubInstallation(InstallPhase): #: expected_config = { - "support_vessel": "str", + "ahts_vessel": "str", "towing_vessel": "str", "towing_vessel_groups": { "towing_vessels": "int", - "station_keeping_vessels": "int", + "ahts_vessels": "int (optional, default: 1)", "num_groups": "int (optional)", }, "substructure": { @@ -86,7 +86,6 @@ def setup_simulation(self, **kwargs): self.initialize_turbine_assembly() self.initialize_queue() self.initialize_towing_groups() - self.initialize_support_vessel() @property def system_capex(self): @@ -177,24 +176,30 @@ def initialize_towing_groups(self, **kwargs): self.installation_groups = [] - vessel = self.config["towing_vessel"] + towing_vessel = self.config["towing_vessel"] num_groups = self.config["towing_vessel_groups"].get("num_groups", 1) - towing = self.config["towing_vessel_groups"]["towing_vessels"] + num_towing = self.config["towing_vessel_groups"]["towing_vessels"] towing_speed = self.config["substructure"].get("towing_speed", 6) + ahts_vessel = self.config["ahts_vessel"] + num_ahts = self.config["towing_vessel_groups"]["ahts_vessels"] + + remaining_substructures = [1] * self.num_turbines + for i in range(num_groups): - g = TowingGroup(vessel, num=i + 1) + g = TowingGroup(towing_vessel, ahts_vessel, i + 1) self.env.register(g) g.initialize() self.installation_groups.append(g) - transfer_moored_substructures_from_storage( + transfer_install_moored_substructures_from_storage( g, self.assembly_storage, self.distance, - self.active_group, - towing, + num_towing, + num_ahts, towing_speed, + remaining_substructures, **kwargs, ) @@ -208,32 +213,6 @@ def initialize_queue(self): self.active_group.vessel = None self.active_group.activate = self.env.event() - def initialize_support_vessel(self, **kwargs): - """ - Initializes Multi-Purpose Support Vessel to perform installation - processes at site. - """ - - specs = self.config["support_vessel"] - vessel = self.initialize_vessel("Multi-Purpose Support Vessel", specs) - - self.env.register(vessel) - vessel.initialize(mobilize=False) - self.support_vessel = vessel - - station_keeping_vessels = self.config["towing_vessel_groups"][ - "station_keeping_vessels" - ] - - install_moored_substructures( - self.support_vessel, - self.active_group, - self.distance, - self.num_turbines, - station_keeping_vessels, - **kwargs, - ) - @property def detailed_output(self): """""" @@ -252,9 +231,6 @@ def detailed_output(self): k: self.operational_delay(str(k)) for k in self.installation_groups }, - self.support_vessel: self.operational_delay( - str(self.support_vessel) - ), } } @@ -268,11 +244,50 @@ def operational_delay(self, name): @process -def transfer_moored_substructures_from_storage( - group, feed, distance, queue, towing_vessels, towing_speed, **kwargs +def transfer_install_moored_substructures_from_storage( + group, + feed, + distance, + towing_vessels, + ahts_vessels, + towing_speed, + remaining_substructures, + **kwargs, ): """ - Process logic for the towing vessel group. + Trigger the substructure installtions. Shuts down after + self.remaining_substructures is empty. + """ + + while True: + try: + _ = remaining_substructures.pop(0) + yield towing_group_actions( + group, + feed, + distance, + towing_vessels, + ahts_vessels, + towing_speed, + **kwargs, + ) + + except IndexError: + break + + +@process +def towing_group_actions( + group, + feed, + distance, + towing_vessels, + ahts_vessels, + towing_speed, + **kwargs, +): + """ + Process logic for the towing vessel group. Assumes there is an anchor tug boat with each group Parameters ---------- @@ -286,132 +301,79 @@ def transfer_moored_substructures_from_storage( Number of vessels to use for towing to site. towing_speed : int | float Configured towing speed (km/h) + num_substructures : int + Number of substructures to be installed corresponding to number of turbines """ towing_time = distance / towing_speed transit_time = distance / group.transit_speed - while True: - - start = group.env.now - assembly = yield feed.get() - delay = group.env.now - start - - if delay > 0: - group.submit_action_log( - "Delay: No Completed Assemblies Available", delay - ) - - yield group.group_task( - "Ballast to Towing Draft", - 6, - num_vessels=towing_vessels, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) + start = group.env.now + assembly = yield feed.get() + delay = group.env.now - start - yield group.group_task( - "Tow Substructure", - towing_time, + if delay > 0: + group.submit_action_log( + "Delay: No Completed Assemblies Available", + delay, num_vessels=towing_vessels, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) - - # At Site - with queue.request() as req: - queue_start = group.env.now - yield req - - queue_time = group.env.now - queue_start - if queue_time > 0: - group.submit_action_log("Queue", queue_time, location="Site") - - queue.vessel = group - active_start = group.env.now - queue.activate.succeed() - - # Released by WTIV when objects are depleted - group.release = group.env.event() - yield group.release - active_time = group.env.now - active_start - - queue.vessel = None - queue.activate = group.env.event() - - yield group.group_task( - "Transit", transit_time, num_vessels=towing_vessels + num_ahts_vessels=ahts_vessels, ) - -@process -def install_moored_substructures( - vessel, queue, distance, substructures, station_keeping_vessels, **kwargs -): - """ - Logic that a Multi-Purpose Support Vessel uses at site to complete the - installation of moored substructures. - - Parameters - ---------- - vessel : Vessel - queue : - distance : int | float - Distance between port and site (km). - substructures : int - Number of substructures to install before transiting back to port. - station_keeping_vessels : int - Number of vessels to use for substructure station keeping during final - installation at site. - """ - - n = 0 - while n < substructures: - if queue.vessel: - - start = vessel.env.now - if n == 0: - vessel.mobilize() - yield vessel.transit(distance) - - yield vessel.task_wrapper( - "Position Substructure", - 2, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) - yield vessel.task_wrapper( - "Ballast to Operational Draft", - 6, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) - yield vessel.task_wrapper( - "Connect Mooring Lines, Pre-tension and pre-stretch", - 20, - suspendable=True, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) - yield vessel.task_wrapper( - "Check Mooring Lines", - 6, - suspendable=True, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, - ) - - group_time = vessel.env.now - start - queue.vessel.submit_action_log( - "Positioning Support", - group_time, - location="site", - num_vessels=station_keeping_vessels, - ) - yield queue.vessel.release.succeed() - vessel.submit_debug_log(progress="Substructure") - n += 1 - - else: - start = vessel.env.now - yield queue.activate - delay_time = vessel.env.now - start - - if n != 0: - vessel.submit_action_log("Delay: Not enough vessels for Moored substructures", delay_time, location="Site") - - yield vessel.transit(distance) + yield group.group_task( + "Ballast to Towing Draft", + 6, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + yield group.group_task( + "Tow Substructure", + towing_time, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + # At Site + yield group.group_task( + "Position Substructure", + 2, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + yield group.group_task( + "Ballast to Operational Draft", + 6, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + yield group.group_task( + "Connect Mooring Lines, Pre-tension and pre-stretch", + 20, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + suspendable=True, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + yield group.group_task( + "Check Mooring Lines", + 6, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + suspendable=True, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + yield group.group_task( + "Transit", + transit_time, + num_vessels=towing_vessels, + num_ahts_vessels=ahts_vessels, + ) diff --git a/docs/source/phases/install/quayside_towout/doc_MooredSubInstallation.rst b/docs/source/phases/install/quayside_towout/doc_MooredSubInstallation.rst index ad137a51..3838bca7 100644 --- a/docs/source/phases/install/quayside_towout/doc_MooredSubInstallation.rst +++ b/docs/source/phases/install/quayside_towout/doc_MooredSubInstallation.rst @@ -28,6 +28,7 @@ the key parameters available. ... "support_vessel": "example_support_vessel", # Will perform onsite installation procedures. + "ahts_vessel": "example_ahts_vessel", # Anchor handling tug supply vessel associated with each tow group. "towing_vessel": "example_towing_vessel", # Towing groups will contain multiple of this vessel. "towing_groups": { "towing_vessel": 1, # Vessels used to tow the substructure to site. diff --git a/library/vessels/example_ahts_vessel.yaml b/library/vessels/example_ahts_vessel.yaml new file mode 100644 index 00000000..28023f85 --- /dev/null +++ b/library/vessels/example_ahts_vessel.yaml @@ -0,0 +1,6 @@ +transport_specs: + max_waveheight: 2.5 # m + max_windspeed: 20 # m/s + transit_speed: 6 # km/h +vessel_specs: + day_rate: 100000 # USD/day diff --git a/tests/data/library/project/config/moored_install.yaml b/tests/data/library/project/config/moored_install.yaml index 47cd8bb0..631f0e44 100644 --- a/tests/data/library/project/config/moored_install.yaml +++ b/tests/data/library/project/config/moored_install.yaml @@ -12,10 +12,10 @@ substructure: takt_time: 168 towing_speed: 6 unit_cost: 12e6 -support_vessel: test_support_vessel +ahts_vessel: test_ahts_vessel towing_vessel: test_towing_vessel towing_vessel_groups: num_groups: 1 - station_keeping_vessels: 3 + ahts_vessels: 1 towing_vessels: 1 turbine: 12MW_generic diff --git a/tests/data/library/project/config/moored_install_multi_assembly.yaml b/tests/data/library/project/config/moored_install_multi_assembly.yaml new file mode 100644 index 00000000..2f196638 --- /dev/null +++ b/tests/data/library/project/config/moored_install_multi_assembly.yaml @@ -0,0 +1,21 @@ +plant: + num_turbines: 50 +port: + assembly_storage: 1 + sub_assembly_lines: 3 + sub_storage: 1 + turbine_assembly_cranes: 1 +site: + depth: 500 + distance: 50 +substructure: + takt_time: 168 + towing_speed: 6 + unit_cost: 12e6 +ahts_vessel: test_ahts_vessel +towing_vessel: test_towing_vessel +towing_vessel_groups: + num_groups: 1 + ahts_vessels: 1 + towing_vessels: 1 +turbine: 12MW_generic diff --git a/tests/data/library/project/config/moored_install_multi_assembly_multi_tow.yaml b/tests/data/library/project/config/moored_install_multi_assembly_multi_tow.yaml new file mode 100644 index 00000000..2f196638 --- /dev/null +++ b/tests/data/library/project/config/moored_install_multi_assembly_multi_tow.yaml @@ -0,0 +1,21 @@ +plant: + num_turbines: 50 +port: + assembly_storage: 1 + sub_assembly_lines: 3 + sub_storage: 1 + turbine_assembly_cranes: 1 +site: + depth: 500 + distance: 50 +substructure: + takt_time: 168 + towing_speed: 6 + unit_cost: 12e6 +ahts_vessel: test_ahts_vessel +towing_vessel: test_towing_vessel +towing_vessel_groups: + num_groups: 1 + ahts_vessels: 1 + towing_vessels: 1 +turbine: 12MW_generic diff --git a/tests/data/library/project/config/moored_install_multi_tow.yaml b/tests/data/library/project/config/moored_install_multi_tow.yaml new file mode 100644 index 00000000..ae4585e5 --- /dev/null +++ b/tests/data/library/project/config/moored_install_multi_tow.yaml @@ -0,0 +1,21 @@ +plant: + num_turbines: 50 +port: + assembly_storage: 1 + sub_assembly_lines: 1 + sub_storage: 1 + turbine_assembly_cranes: 1 +site: + depth: 500 + distance: 50 +substructure: + takt_time: 168 + towing_speed: 6 + unit_cost: 12e6 +ahts_vessel: test_ahts_vessel +towing_vessel: test_towing_vessel +towing_vessel_groups: + num_groups: 3 + ahts_vessels: 1 + towing_vessels: 1 +turbine: 12MW_generic diff --git a/tests/data/library/project/config/moored_install_no_supply.yaml b/tests/data/library/project/config/moored_install_no_supply.yaml index 249abd85..57d48179 100644 --- a/tests/data/library/project/config/moored_install_no_supply.yaml +++ b/tests/data/library/project/config/moored_install_no_supply.yaml @@ -10,10 +10,10 @@ substructure: takt_time: 0 towing_speed: 6 unit_cost: 12e6 -support_vessel: test_support_vessel +ahts_vessel: test_ahts_vessel towing_vessel: test_towing_vessel towing_vessel_groups: num_groups: 1 - station_keeping_vessels: 3 + ahts_vessels: 1 towing_vessels: 1 turbine: 12MW_generic diff --git a/tests/data/library/vessels/test_ahts_vessel.yaml b/tests/data/library/vessels/test_ahts_vessel.yaml new file mode 100644 index 00000000..28023f85 --- /dev/null +++ b/tests/data/library/vessels/test_ahts_vessel.yaml @@ -0,0 +1,6 @@ +transport_specs: + max_waveheight: 2.5 # m + max_windspeed: 20 # m/s + transit_speed: 6 # km/h +vessel_specs: + day_rate: 100000 # USD/day diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index e1fc0af7..c2ebba3f 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -14,16 +14,21 @@ from ORBIT.phases.install import MooredSubInstallation config = extract_library_specs("config", "moored_install") +multi_assembly = extract_library_specs( + "config", "moored_install_multi_assembly" +) +multi_tow = extract_library_specs("config", "moored_install_multi_tow") +multi_assembly_multi_tow = extract_library_specs( + "config", "moored_install_multi_assembly_multi_tow" +) no_supply = extract_library_specs("config", "moored_install_no_supply") def test_simulation_setup(): - sim = MooredSubInstallation(config) assert sim.config == config assert sim.env - assert sim.support_vessel assert len(sim.sub_assembly_lines) == config["port"]["sub_assembly_lines"] assert ( len(sim.turbine_assembly_lines) @@ -39,9 +44,18 @@ def test_simulation_setup(): @pytest.mark.parametrize( "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) -@pytest.mark.parametrize("config", (config, no_supply)) +@pytest.mark.parametrize( + "config", + (config, multi_assembly, multi_tow, multi_assembly_multi_tow, no_supply), + ids=[ + "1 assembly, 1 tow", + "3 assembly, 1 tow", + "1 assembly, 3 tow", + "3 assembly, 3 tow", + "no supply", + ], +) def test_for_complete_logging(weather, config): - sim = MooredSubInstallation(config, weather=weather) sim.run() @@ -56,3 +70,8 @@ def test_for_complete_logging(weather, config): assert ~df["cost"].isnull().any() _ = sim.agent_efficiencies _ = sim.detailed_output + + installed_mooring_lines = len( + [a for a in sim.env.actions if a["action"] == "Position Substructure"] + ) + assert installed_mooring_lines == sim.num_turbines From 841b4d0c4730891a23245e13d1ee1072967605c6 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Tue, 28 Mar 2023 09:24:40 -0600 Subject: [PATCH 063/240] Revised port_in_use constraint. --- ORBIT/phases/install/quayside_assembly_tow/common.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 5ca39c6a..49533caa 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -7,7 +7,7 @@ __email__ = "jake.nunemaker@nrel.gov" -from marmot import Agent, le, process +from marmot import Agent, le, process, false from marmot._exceptions import AgentNotRegistered @@ -237,7 +237,7 @@ def move_substructure(self): TODO: Move to dynamic process involving tow groups. """ - yield self.task("Move Substructure", 8, {"port_in_use": False}) + yield self.task("Move Substructure", 8, {"port_in_use": false()}) @process def prepare_for_assembly(self): From 27fa2516a1ba0d5800e45f7f21dd5bec5243adbb Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Thu, 30 Mar 2023 16:53:18 -0600 Subject: [PATCH 064/240] fix bug where nan cable sections persist throughout calculations and installation --- ORBIT/phases/design/_cables.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 27343a58..a51adae9 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -405,6 +405,7 @@ def cable_lengths_by_type(self): ] for name in self.cables } + lengths = {name: x[~np.isnan(x)] for name, x in lengths.items()} return lengths @property From afcef10a8db238bfe5c1cf5c00fb010ef3ae181c Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Thu, 30 Mar 2023 17:01:49 -0600 Subject: [PATCH 065/240] add error message for scour vessel limits being too low --- ORBIT/phases/install/scour_protection_install/standard.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/install/scour_protection_install/standard.py b/ORBIT/phases/install/scour_protection_install/standard.py index 9dd3ee9a..d2dffa37 100644 --- a/ORBIT/phases/install/scour_protection_install/standard.py +++ b/ORBIT/phases/install/scour_protection_install/standard.py @@ -14,7 +14,7 @@ from ORBIT.core import Vessel from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install import InstallPhase -from ORBIT.core.exceptions import CargoMassExceeded, InsufficientAmount +from ORBIT.core.exceptions import CargoMassExceeded, InsufficientAmount, VesselCapacityError class ScourProtectionInstallation(InstallPhase): @@ -173,6 +173,11 @@ def install_scour_protection( tonnes_per_substructure : int Number of tonnes required to be installed at each substation """ + if tonnes_per_substructure > vessel.rock_storage.available_capacity: + raise VesselCapacityError( + vessel, + f"tonnes per substructure ({tonnes_per_substructure})", + ) while turbines > 0: if vessel.at_port: From 9f7af8a4ddefc868e92b71516cdc56c9ea4c8324 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Tue, 4 Apr 2023 13:12:07 -0600 Subject: [PATCH 066/240] Revert "[pre-commit.ci] auto fixes from pre-commit.com hooks" This reverts commit c99b94c5333da5ea7e4005cfa658d7ac7a1fb722. --- LICENSE | 2 +- ORBIT/_version.py | 168 ++++------ ORBIT/api/wisdem.py | 1 + ORBIT/config.py | 1 + ORBIT/core/cargo.py | 1 + ORBIT/core/components.py | 1 + ORBIT/core/defaults/__init__.py | 1 + ORBIT/core/environment.py | 2 + ORBIT/core/exceptions.py | 1 + ORBIT/core/library.py | 2 +- ORBIT/core/logic/vessel_logic.py | 6 + ORBIT/core/port.py | 1 + ORBIT/core/supply_chain.py | 1 + ORBIT/core/vessel.py | 2 + ORBIT/manager.py | 20 +- ORBIT/parametric.py | 5 +- ORBIT/phases/base.py | 2 + ORBIT/phases/design/__init__.py | 1 + ORBIT/phases/design/array_system_design.py | 4 + ORBIT/phases/design/export_system_design.py | 2 + ORBIT/phases/design/monopile_design.py | 7 +- ORBIT/phases/design/mooring_system_design.py | 6 +- ORBIT/phases/design/oss_design.py | 3 +- .../phases/design/scour_protection_design.py | 3 +- .../phases/design/semi_submersible_design.py | 8 +- ORBIT/phases/design/spar_design.py | 7 +- ORBIT/phases/install/cable_install/array.py | 5 + ORBIT/phases/install/cable_install/common.py | 1 + ORBIT/phases/install/install_phase.py | 1 + ORBIT/phases/install/jacket_install/common.py | 1 + .../phases/install/jacket_install/standard.py | 9 +- .../phases/install/monopile_install/common.py | 2 + .../install/monopile_install/standard.py | 9 +- .../phases/install/mooring_install/mooring.py | 3 + ORBIT/phases/install/oss_install/common.py | 2 + ORBIT/phases/install/oss_install/floating.py | 9 +- ORBIT/phases/install/oss_install/standard.py | 3 + .../quayside_assembly_tow/gravity_base.py | 3 + .../install/quayside_assembly_tow/moored.py | 3 + .../scour_protection_install/standard.py | 1 + .../phases/install/turbine_install/common.py | 1 + .../install/turbine_install/standard.py | 4 + ORBIT/supply_chain.py | 245 +++++++------- docs/Makefile | 2 +- docs/conf.py | 4 +- library/cables/XLPE_500mm_220kV.yaml | 2 +- library/cables/XLPE_630mm_220kV.yaml | 2 +- library/cables/XLPE_800mm_220kV.yaml | 2 +- library/turbines/15MW_generic.yaml | 2 +- misc/supply_chain_plots.py | 183 ++++------- templates/design_module.py | 74 ++--- tests/api/test_wisdem_api.py | 3 + tests/conftest.py | 9 + tests/core/test_environment.py | 1 + tests/core/test_library.py | 2 + tests/core/test_port.py | 3 + .../phases/design/test_array_system_design.py | 2 + tests/phases/design/test_cable.py | 1 + tests/phases/design/test_electrical_design.py | 10 + .../design/test_export_system_design.py | 1 + tests/phases/design/test_monopile_design.py | 6 + .../design/test_mooring_system_design.py | 5 + tests/phases/design/test_oss_design.py | 4 + .../design/test_scour_protection_design.py | 1 + .../design/test_semisubmersible_design.py | 4 + tests/phases/design/test_spar_design.py | 4 + .../cable_install/test_array_install.py | 10 + .../install/cable_install/test_cable_tasks.py | 3 + .../cable_install/test_export_install.py | 10 + .../jacket_install/test_jacket_install.py | 10 + .../monopile_install/test_monopile_install.py | 9 + .../monopile_install/test_monopile_tasks.py | 3 + .../mooring_install/test_mooring_install.py | 5 + .../install/oss_install/test_oss_install.py | 10 + .../install/oss_install/test_oss_tasks.py | 3 + .../quayside_assembly_tow/test_common.py | 4 + .../test_gravity_based.py | 3 + .../quayside_assembly_tow/test_moored.py | 3 + .../test_scour_protection.py | 5 + tests/phases/install/test_install_phase.py | 3 + .../turbine_install/test_turbine_install.py | 12 + .../turbine_install/test_turbine_tasks.py | 3 + tests/phases/test_base.py | 5 + tests/test_config_management.py | 3 + .../test_design_install_phase_interactions.py | 5 +- tests/test_parametric.py | 9 +- tests/test_project_manager.py | 44 ++- versioneer.py | 298 +++++++----------- 88 files changed, 722 insertions(+), 625 deletions(-) diff --git a/LICENSE b/LICENSE index 1c0c15ea..dbb692d8 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ - Copyright (c) 2020 Alliance for Sustainable Energy, LLC + Copyright (c) 2020 Alliance for Sustainable Energy, LLC Apache License Version 2.0, January 2004 diff --git a/ORBIT/_version.py b/ORBIT/_version.py index f03f6681..fa1e63bc 100644 --- a/ORBIT/_version.py +++ b/ORBIT/_version.py @@ -1,3 +1,4 @@ + # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -9,11 +10,11 @@ """Git implementation of _version.py.""" +import errno import os import re -import sys -import errno import subprocess +import sys def get_keywords(): @@ -57,20 +58,17 @@ class NotThisMethod(Exception): def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f - return decorate -def run_command( - commands, args, cwd=None, verbose=False, hide_stderr=False, env=None -): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, + env=None): """Call the given command(s).""" assert isinstance(commands, list) p = None @@ -78,13 +76,10 @@ def run_command( try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen( - [c] + args, - cwd=cwd, - env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr else None), - ) + p = subprocess.Popen([c] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) break except EnvironmentError: e = sys.exc_info()[1] @@ -121,22 +116,16 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - "date": None, - } + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print( - "Tried directories %s but none started with prefix %s" - % (str(rootdirs), parentdir_prefix) - ) + print("Tried directories %s but none started with prefix %s" % + (str(rootdirs), parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -192,7 +181,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -201,7 +190,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r"\d", r)]) + tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -209,26 +198,19 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix) :] + r = ref[len(tag_prefix):] if verbose: print("picking %s" % r) - return { - "version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": None, - "date": date, - } + return {"version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": None, + "date": date} # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return { - "version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": "no suitable tags", - "date": None, - } + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} @register_vcs_handler("git", "pieces_from_vcs") @@ -243,9 +225,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command( - GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True - ) + out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=True) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -253,19 +234,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command( - GITS, - [ - "describe", - "--tags", - "--dirty", - "--always", - "--long", - "--match", - "%s*" % tag_prefix, - ], - cwd=root, - ) + describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", + "--always", "--long", + "--match", "%s*" % tag_prefix], + cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -288,18 +260,17 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[: git_describe.rindex("-dirty")] + git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ( - "unable to parse git-describe output: '%s'" % describe_out - ) + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) return pieces # tag @@ -308,12 +279,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( - full_tag, - tag_prefix, - ) + pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" + % (full_tag, tag_prefix)) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix) :] + pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -324,15 +293,13 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command( - GITS, ["rev-list", "HEAD", "--count"], cwd=root - ) + count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], + cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ - 0 - ].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], + cwd=root)[0].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -363,7 +330,8 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -477,13 +445,11 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return { - "version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None, - } + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None} if not style or style == "default": style = "pep440" # the default @@ -503,13 +469,9 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return { - "version": rendered, - "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], - "error": None, - "date": pieces.get("date"), - } + return {"version": rendered, "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} def get_versions(): @@ -523,9 +485,8 @@ def get_versions(): verbose = cfg.verbose try: - return git_versions_from_keywords( - get_keywords(), cfg.tag_prefix, verbose - ) + return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, + verbose) except NotThisMethod: pass @@ -534,16 +495,13 @@ def get_versions(): # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. - for i in cfg.versionfile_source.split("/"): + for i in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None, - } + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to find root of source tree", + "date": None} try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) @@ -557,10 +515,6 @@ def get_versions(): except NotThisMethod: pass - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", - "date": None, - } + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, + "error": "unable to compute version", "date": None} diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 63fd1460..8320e99c 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -7,6 +7,7 @@ import openmdao.api as om + from ORBIT import ProjectManager diff --git a/ORBIT/config.py b/ORBIT/config.py index 5a416b43..4a50732d 100644 --- a/ORBIT/config.py +++ b/ORBIT/config.py @@ -8,6 +8,7 @@ import yaml from yaml import Dumper + from ORBIT.core import loader diff --git a/ORBIT/core/cargo.py b/ORBIT/core/cargo.py index 0f618b4e..d02ab03f 100644 --- a/ORBIT/core/cargo.py +++ b/ORBIT/core/cargo.py @@ -6,6 +6,7 @@ class Cargo(Object): + def __repr__(self): return self.type diff --git a/ORBIT/core/components.py b/ORBIT/core/components.py index dec26889..e4e3792c 100644 --- a/ORBIT/core/components.py +++ b/ORBIT/core/components.py @@ -6,6 +6,7 @@ __email__ = "jake.nunemaker@nrel.gov" import simpy + from ORBIT.core.defaults import process_times as pt from ORBIT.core.exceptions import ItemNotFound, InsufficientCable diff --git a/ORBIT/core/defaults/__init__.py b/ORBIT/core/defaults/__init__.py index 1cc75bae..7df591ec 100644 --- a/ORBIT/core/defaults/__init__.py +++ b/ORBIT/core/defaults/__init__.py @@ -8,6 +8,7 @@ import os import yaml + from ORBIT.core.library import loader DIR = os.path.split(__file__)[0] diff --git a/ORBIT/core/environment.py b/ORBIT/core/environment.py index bade7d84..4654ec13 100644 --- a/ORBIT/core/environment.py +++ b/ORBIT/core/environment.py @@ -88,6 +88,7 @@ def standarize_state_inputs(self, _in): names = [] for name in list(_in.dtype.names): + if "windspeed" in name: try: val = name.split("_")[1].replace("m", "") @@ -138,6 +139,7 @@ def resolve_windspeed_constraints(self, constraints): return {**constraints, "windspeed": list(ws.values())[0]} for k, v in ws.items(): + if k == "windspeed": height = self.simplify_num(self.default_height) diff --git a/ORBIT/core/exceptions.py b/ORBIT/core/exceptions.py index ec9fa5d6..8d7d0ca4 100644 --- a/ORBIT/core/exceptions.py +++ b/ORBIT/core/exceptions.py @@ -31,6 +31,7 @@ def __init__(self, vessel, component): ) def __str__(self): + return self.message diff --git a/ORBIT/core/library.py b/ORBIT/core/library.py index c8217b15..6f771cc0 100644 --- a/ORBIT/core/library.py +++ b/ORBIT/core/library.py @@ -38,12 +38,12 @@ import yaml import pandas as pd from yaml import Dumper + from ORBIT.core.exceptions import LibraryItemNotFoundError ROOT = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../..")) default_library = os.path.join(ROOT, "library") - # Need a custom loader to read in scientific notation correctly class CustomSafeLoader(yaml.SafeLoader): def construct_python_tuple(self, node): diff --git a/ORBIT/core/logic/vessel_logic.py b/ORBIT/core/logic/vessel_logic.py index daa4a707..b27a3e78 100644 --- a/ORBIT/core/logic/vessel_logic.py +++ b/ORBIT/core/logic/vessel_logic.py @@ -7,6 +7,7 @@ from marmot import process + from ORBIT.core.defaults import process_times as pt from ORBIT.core.exceptions import ItemNotFound, MissingComponent @@ -148,6 +149,7 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): transit_time = vessel.transit_time(distance) while True: + if vessel.at_port: vessel.submit_debug_log(message=f"{vessel} is at port.") @@ -260,13 +262,16 @@ def get_list_of_items_from_port(vessel, port, items, **kwargs): proposed_mass = vessel.storage.current_cargo_mass + total_mass if vessel.storage.current_cargo_mass == 0: + if proposed_deck_space > vessel.storage.max_deck_space: + msg = ( f"Warning: '{vessel}' Deck Space Capacity Exceeded" ) vessel.submit_debug_log(message=msg) if proposed_mass > vessel.storage.max_cargo_mass: + msg = ( f"Warning: '{vessel}' Cargo Mass Capacity Exceeded" ) @@ -327,6 +332,7 @@ def shuttle_items_to_queue_wait( n = 0 while n < assigned: + vessel.submit_debug_log(message=f"{vessel} is at port.") # Get list of items diff --git a/ORBIT/core/port.py b/ORBIT/core/port.py index c24ccfa6..dbfc152a 100644 --- a/ORBIT/core/port.py +++ b/ORBIT/core/port.py @@ -7,6 +7,7 @@ import simpy + from ORBIT.core.exceptions import ItemNotFound diff --git a/ORBIT/core/supply_chain.py b/ORBIT/core/supply_chain.py index 6f271c9b..0f2f3e1a 100644 --- a/ORBIT/core/supply_chain.py +++ b/ORBIT/core/supply_chain.py @@ -41,6 +41,7 @@ def __init__( @process def start(self): + n = 0 while n < self.num: yield self.task( diff --git a/ORBIT/core/vessel.py b/ORBIT/core/vessel.py index c952e905..88c823a4 100644 --- a/ORBIT/core/vessel.py +++ b/ORBIT/core/vessel.py @@ -15,6 +15,7 @@ WindowNotFound, AgentNotRegistered, ) + from ORBIT.core.components import ( Crane, JackingSys, @@ -85,6 +86,7 @@ def submit_action_log(self, action, duration, **kwargs): def task_wrapper( self, name, duration, constraints={}, suspendable=False, **kwargs ): + duration /= self.avail yield self.task(name, duration, constraints, suspendable, **kwargs) diff --git a/ORBIT/manager.py b/ORBIT/manager.py index bd229183..5f85465d 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -14,9 +14,10 @@ from itertools import product import numpy as np -import ORBIT import pandas as pd from benedict import benedict + +import ORBIT from ORBIT.phases import DesignPhase, InstallPhase from ORBIT.core.library import ( initialize_library, @@ -168,12 +169,14 @@ def run(self, **kwargs): self._print_warnings() def _print_warnings(self): + try: df = pd.DataFrame(self.logs) df = df.loc[~df["message"].isnull()] df = df.loc[df["message"].str.contains("Exceeded")] for msg in df["message"].unique(): + idx = df.loc[df["message"] == msg].index[0] phase = df.loc[idx, "phase"] print(f"{phase}:\n\t {msg}") @@ -204,9 +207,7 @@ def register_design_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._design_phases]: - raise ValueError( - f"A phase with name '{phase.__name__}' already exists." - ) + raise ValueError(f"A phase with name '{phase.__name__}' already exists.") if len(re.split("[_ ]", phase.__name__)) > 1: raise ValueError(f"Registered phase name must not include a '_'.") @@ -230,9 +231,7 @@ def register_install_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._install_phases]: - raise ValueError( - f"A phase with name '{phase.__name__}' already exists." - ) + raise ValueError(f"A phase with name '{phase.__name__}' already exists.") if len(re.split("[_ ]", phase.__name__)) > 1: raise ValueError(f"Registered phase name must not include a '_'.") @@ -456,6 +455,7 @@ def remove_keys(cls, left, right): right = {k: right[k] for k in set(new).intersection(set(right))} for k, val in right.items(): + if isinstance(new.get(k, None), dict) and isinstance(val, dict): new[k] = cls.remove_keys(new[k], val) @@ -502,6 +502,7 @@ def create_config_for_phase(self, phase): @property def phase_ends(self): + ret = {} for k, t in self.phase_times.items(): try: @@ -694,6 +695,7 @@ def run_multiple_phases_overlapping(self, phases, **kwargs): # Run defined for name, start in defined.items(): + _, logs = self.run_install_phase(name, start, **kwargs) if logs is None: @@ -727,6 +729,7 @@ def run_dependent_phases(self, _phases, zero, **kwargs): skipped = {} while True: + phases = {**phases, **skipped} if not phases: break @@ -825,6 +828,7 @@ def _parse_install_phase_values(self, phases): depends = {} for k, v in phases.items(): + if isinstance(v, (int, float)): defined[k] = ceil(v) @@ -1102,6 +1106,7 @@ def progress_summary(self): summary = {} for i in range(1, len(self.month_bins)): + unique, counts = np.unique( arr["progress"][dig == i], return_counts=True ) @@ -1137,6 +1142,7 @@ def phase_dates(self): dates = {} for phase, _start in self.config["install_phases"].items(): + start = dt.datetime.strptime(_start, self.date_format_short) end = start + dt.timedelta(hours=ceil(self.phase_times[phase])) diff --git a/ORBIT/parametric.py b/ORBIT/parametric.py index 634b842c..6895400c 100644 --- a/ORBIT/parametric.py +++ b/ORBIT/parametric.py @@ -15,9 +15,10 @@ import pandas as pd import statsmodels.api as sm from yaml import Loader -from ORBIT import ProjectManager from benedict import benedict +from ORBIT import ProjectManager + class ParametricManager: """Class for configuring parametric ORBIT runs.""" @@ -201,6 +202,7 @@ def from_config(cls, data): funcs = {} for k, v in outputs.items(): + split = v.split("[") attr = split[0] @@ -296,6 +298,7 @@ def as_string(self): out = "" for i, (k, v) in enumerate(params.items()): + if i == 0: pre = "" diff --git a/ORBIT/phases/base.py b/ORBIT/phases/base.py index 1b39d91a..2e9b539d 100644 --- a/ORBIT/phases/base.py +++ b/ORBIT/phases/base.py @@ -10,6 +10,7 @@ from copy import deepcopy from benedict import benedict + from ORBIT.core.library import initialize_library, extract_library_data from ORBIT.core.exceptions import MissingInputs @@ -69,6 +70,7 @@ def _check_keys(cls, expected, config): missing = [] for k, v in expected.items(): + if isinstance(k, str) and "variable" in k: continue diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 8ef543e0..120d1e83 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -16,3 +16,4 @@ from .mooring_system_design import MooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign +from .electrical_export import ElectricalDesign diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 5298ebab..1a25ab9f 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -12,6 +12,7 @@ import numpy as np import pandas as pd import matplotlib.pyplot as plt + from ORBIT.core.library import export_library_specs, extract_library_specs from ORBIT.phases.design._cables import Plant, CableSystem @@ -566,6 +567,7 @@ def plot_array_system( for i, row in enumerate(self.sections_cables): for cable, width in zip(max_string, string_widths): + ix_to_plot = np.where(row == cable)[0] if ix_to_plot.size == 0: continue @@ -793,6 +795,7 @@ def create_project_csv(self, save_name): export_library_specs("cables", save_name, rows, file_ext="csv") def _format_windfarm_data(self): + # Separate the OSS data where substaion_id is equal to id substation_filter = ( self.location_data.substation_id == self.location_data.id @@ -1036,6 +1039,7 @@ def _create_windfarm_layout(self): self.sections_distance = self._compute_haversine_distance() def run(self): + self._initialize_cables() self.create_strings() self._initialize_custom_data() diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index bf7af015..6c6ae0a0 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -6,6 +6,7 @@ __email__ = "robert.hammond@nrel.gov" import numpy as np + from ORBIT.phases.design._cables import CableSystem @@ -212,6 +213,7 @@ def design_result(self): } for name, cable in self.cables.items(): + output["export_system"]["cable"] = { "linear_density": cable.linear_density, "sections": [self.length], diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index 082b3a9c..ab1e5349 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -9,6 +9,7 @@ from math import pi, log from scipy.optimize import fsolve + from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase @@ -229,7 +230,7 @@ def design_transition_piece(self, D_p, t_p, **kwargs): "diameter": D_tp, "mass": m_tp, "length": L_tp, - "deck_space": D_tp**2, + "deck_space": D_tp ** 2, "unit_cost": m_tp * self.tp_steel_cost, } @@ -354,7 +355,7 @@ def pile_mass(Dp, tp, Lt, **kwargs): """ density = kwargs.get("monopile_density", 7860) # kg/m3 - volume = (pi / 4) * (Dp**2 - (Dp - tp) ** 2) * Lt + volume = (pi / 4) * (Dp ** 2 - (Dp - tp) ** 2) * Lt mass = density * volume / 907.185 return mass @@ -559,7 +560,7 @@ def calculate_thrust_coefficient(rated_windspeed): """ ct = min( - [3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed**2), 1] + [3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed ** 2), 1] ) return ct diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 0dcf67d8..383a4924 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -76,7 +76,7 @@ def determine_mooring_line(self): """ tr = self.config["turbine"]["turbine_rating"] - fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 + fit = -0.0004 * (tr ** 2) + 0.0132 * tr + 0.0536 if fit <= 0.09: self.line_diam = 0.09 @@ -99,7 +99,7 @@ def calculate_breaking_load(self): """ self.breaking_load = ( - 419449 * (self.line_diam**2) + 93415 * self.line_diam - 3577.9 + 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 ) def calculate_line_length_mass(self): @@ -115,7 +115,7 @@ def calculate_line_length_mass(self): depth = self.config["site"]["depth"] self.line_length = ( - 0.0002 * (depth**2) + 1.264 * depth + 47.776 + fixed + 0.0002 * (depth ** 2) + 1.264 * depth + 47.776 + fixed ) self.line_mass = self.line_length * self.line_mass_per_m diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index 630275ff..e762eab5 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -7,6 +7,7 @@ import numpy as np + from ORBIT.phases.design import DesignPhase @@ -283,7 +284,7 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass**0.5574 + substructure_pile_mass = 8 * substructure_mass ** 0.5574 self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate diff --git a/ORBIT/phases/design/scour_protection_design.py b/ORBIT/phases/design/scour_protection_design.py index d36b91eb..efa66b4f 100644 --- a/ORBIT/phases/design/scour_protection_design.py +++ b/ORBIT/phases/design/scour_protection_design.py @@ -8,6 +8,7 @@ from math import ceil import numpy as np + from ORBIT.phases.design import DesignPhase @@ -114,7 +115,7 @@ def compute_scour_protection_tonnes_to_install(self): r = self.diameter / 2 + self.scour_depth / np.tan(np.radians(self.phi)) volume = ( - np.pi * self.protection_depth * (r**2 - (self.diameter / 2) ** 2) + np.pi * self.protection_depth * (r ** 2 - (self.diameter / 2) ** 2) ) self.scour_protection_tonnes = ceil( diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index 7bb34217..58404a29 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -67,7 +67,7 @@ def stiffened_column_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 + mass = -0.9581 * rating ** 2 + 40.89 * rating + 802.09 return mass @@ -89,7 +89,7 @@ def truss_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 + mass = 2.7894 * rating ** 2 + 15.591 * rating + 266.03 return mass @@ -111,7 +111,7 @@ def heave_plate_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.4397 * rating**2 + 21.545 * rating + 177.42 + mass = -0.4397 * rating ** 2 + 21.545 * rating + 177.42 return mass @@ -133,7 +133,7 @@ def secondary_steel_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.153 * rating**2 + 6.54 * rating + 128.34 + mass = -0.153 * rating ** 2 + 6.54 * rating + 128.34 return mass diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index c8b0862e..224c4a5e 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -7,6 +7,7 @@ from numpy import exp, log + from ORBIT.phases.design import DesignPhase @@ -71,7 +72,7 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) return mass @@ -112,7 +113,7 @@ def ballast_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 return mass @@ -137,7 +138,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 - + 0.196 * (rating**0.5) * log(rating) + + 0.196 * (rating ** 0.5) * log(rating) + 0.00001 * depth * log(depth) ) diff --git a/ORBIT/phases/install/cable_install/array.py b/ORBIT/phases/install/cable_install/array.py index 21120126..d4d8a181 100644 --- a/ORBIT/phases/install/cable_install/array.py +++ b/ORBIT/phases/install/cable_install/array.py @@ -10,6 +10,7 @@ import numpy as np from marmot import process + from ORBIT.core import Vessel from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase @@ -236,6 +237,7 @@ def install_array_cables( trench_vessel.at_site = True elif trench_vessel.at_site: + try: # Dig trench along each cable section distance trench_distance = trench_sections.pop(0) @@ -267,6 +269,7 @@ def install_array_cables( vessel.at_site = True elif vessel.at_site: + try: length, num_sections, *extra = sections.pop(0) if extra: @@ -288,10 +291,12 @@ def install_array_cables( break for _ in range(num_sections): + try: section = vessel.cable_storage.get_cable(length) except InsufficientCable: + yield vessel.transit(distance, **kwargs) yield load_cable_on_vessel(vessel, cable, **kwargs) yield vessel.transit(distance, **kwargs) diff --git a/ORBIT/phases/install/cable_install/common.py b/ORBIT/phases/install/cable_install/common.py index fa0833f2..f2481138 100644 --- a/ORBIT/phases/install/cable_install/common.py +++ b/ORBIT/phases/install/cable_install/common.py @@ -7,6 +7,7 @@ from marmot import process + from ORBIT.core.logic import position_onsite from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/install_phase.py b/ORBIT/phases/install/install_phase.py index c4d159d6..97b93c3b 100644 --- a/ORBIT/phases/install/install_phase.py +++ b/ORBIT/phases/install/install_phase.py @@ -12,6 +12,7 @@ import numpy as np import simpy import pandas as pd + from ORBIT.core import Port, Vessel, Environment from ORBIT.phases import BasePhase from ORBIT.core.defaults import common_costs diff --git a/ORBIT/phases/install/jacket_install/common.py b/ORBIT/phases/install/jacket_install/common.py index 5cd9feb2..4312bfcf 100644 --- a/ORBIT/phases/install/jacket_install/common.py +++ b/ORBIT/phases/install/jacket_install/common.py @@ -5,6 +5,7 @@ from marmot import false, process + from ORBIT.core import Cargo from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/jacket_install/standard.py b/ORBIT/phases/install/jacket_install/standard.py index 10391d6e..2f8f0c55 100644 --- a/ORBIT/phases/install/jacket_install/standard.py +++ b/ORBIT/phases/install/jacket_install/standard.py @@ -7,6 +7,7 @@ import numpy as np import simpy from marmot import process + from ORBIT.core import SubstructureDelivery from ORBIT.core.logic import ( prep_for_site_operations, @@ -110,7 +111,9 @@ def system_capex(self): ] def initialize_substructure_delivery(self): - """ """ + """ + + """ jacket = Jacket(**self.config["jacket"]) @@ -129,6 +132,7 @@ def initialize_substructure_delivery(self): self.supply_chain = self.config.get("jacket_supply_chain", {}) if self.supply_chain.get("enabled", False): + items = [jacket, self.tp] if self.tp else [jacket] delivery_time = self.supply_chain.get( "substructure_delivery_time", 168 @@ -369,6 +373,7 @@ def solo_install_jackets( vessel.at_site = True if vessel.at_site: + if vessel.storage.items: # Prep for jacket install yield prep_for_site_operations( @@ -433,7 +438,9 @@ def install_jackets_from_queue( wtiv.at_site = True if wtiv.at_site: + if queue.vessel: + # Prep for jacket install yield prep_for_site_operations( wtiv, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/monopile_install/common.py b/ORBIT/phases/install/monopile_install/common.py index ee1fcb74..04af017a 100644 --- a/ORBIT/phases/install/monopile_install/common.py +++ b/ORBIT/phases/install/monopile_install/common.py @@ -7,6 +7,7 @@ from marmot import false, process + from ORBIT.core import Cargo from ORBIT.core.logic import jackdown_if_required from ORBIT.core.defaults import process_times as pt @@ -339,6 +340,7 @@ def install_transition_piece(vessel, tp, **kwargs): yield bolt_transition_piece(vessel, **kwargs) elif connection == "grouted": + yield pump_transition_piece_grout(vessel, **kwargs) yield cure_transition_piece_grout(vessel) diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py index 02c7c259..5a204709 100644 --- a/ORBIT/phases/install/monopile_install/standard.py +++ b/ORBIT/phases/install/monopile_install/standard.py @@ -9,6 +9,7 @@ import numpy as np import simpy from marmot import process + from ORBIT.core import SubstructureDelivery from ORBIT.core.logic import ( prep_for_site_operations, @@ -105,7 +106,9 @@ def system_capex(self): ) * self.config["plant"]["num_turbines"] def initialize_substructure_delivery(self): - """ """ + """ + + """ monopile = Monopile(**self.config["monopile"]) tp = TransitionPiece(**self.config["transition_piece"]) @@ -116,6 +119,7 @@ def initialize_substructure_delivery(self): self.supply_chain = self.config.get("monopile_supply_chain", {}) if self.supply_chain.get("enabled", False): + delivery_time = self.supply_chain.get( "substructure_delivery_time", 168 ) @@ -342,6 +346,7 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): vessel.at_site = True if vessel.at_site: + if vessel.storage.items: # Prep for monopile install yield prep_for_site_operations( @@ -403,7 +408,9 @@ def install_monopiles_from_queue(wtiv, queue, monopiles, distance, **kwargs): wtiv.at_site = True if wtiv.at_site: + if queue.vessel: + # Prep for monopile install yield prep_for_site_operations( wtiv, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/mooring_install/mooring.py b/ORBIT/phases/install/mooring_install/mooring.py index c4175f28..3b3573b9 100644 --- a/ORBIT/phases/install/mooring_install/mooring.py +++ b/ORBIT/phases/install/mooring_install/mooring.py @@ -7,6 +7,7 @@ from marmot import process + from ORBIT.core import Cargo, Vessel from ORBIT.core.logic import position_onsite, get_list_of_items_from_port from ORBIT.core.defaults import process_times as pt @@ -160,7 +161,9 @@ def install_mooring_systems(vessel, port, distance, depth, systems, **kwargs): vessel.at_site = True if vessel.at_site: + if vessel.storage.items: + system = yield vessel.get_item_from_storage( "MooringSystem", **kwargs ) diff --git a/ORBIT/phases/install/oss_install/common.py b/ORBIT/phases/install/oss_install/common.py index f1c5527b..f90128ac 100644 --- a/ORBIT/phases/install/oss_install/common.py +++ b/ORBIT/phases/install/oss_install/common.py @@ -7,6 +7,7 @@ from marmot import process + from ORBIT.core import Cargo from ORBIT.core.logic import stabilize, jackdown_if_required from ORBIT.core.defaults import process_times as pt @@ -138,6 +139,7 @@ def install_topside(vessel, topside, **kwargs): yield bolt_transition_piece(vessel, **kwargs) elif connection == "grouted": + yield pump_transition_piece_grout(vessel, **kwargs) yield cure_transition_piece_grout(vessel, **kwargs) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index a293363d..6580e19a 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -6,10 +6,11 @@ __email__ = "jake.nunemaker@nrel.gov" -from marmot import Agent, le, process +from marmot import Agent, process, le +from marmot._exceptions import AgentNotRegistered + from ORBIT.core import WetStorage from ORBIT.core.logic import position_onsite -from marmot._exceptions import AgentNotRegistered from ORBIT.phases.install import InstallPhase from ORBIT.phases.install.mooring_install.mooring import ( install_mooring_line, @@ -143,6 +144,7 @@ def initialize_installation_vessel(self): @property def detailed_output(self): + return {} @@ -173,6 +175,7 @@ def install_floating_substations( travel_time = distance / towing_speed for _ in range(number): + start = vessel.env.now yield feed.get() delay = vessel.env.now - start @@ -193,7 +196,7 @@ def install_floating_substations( constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) - for _ in range(3): + for _ in range (3): yield perform_mooring_site_survey(vessel) yield install_mooring_anchor(vessel, depth, "Suction Pile") yield install_mooring_line(vessel, depth) diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index 15bcbd79..04038af9 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -8,6 +8,7 @@ import simpy from marmot import process + from ORBIT.core import Vessel from ORBIT.core.logic import shuttle_items_to_queue, prep_for_site_operations from ORBIT.phases.install import InstallPhase @@ -229,7 +230,9 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): vessel.at_site = True if vessel.at_site: + if queue.vessel: + # Prep for monopile install yield prep_for_site_operations( vessel, survey_required=True, **kwargs diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index a02a3547..4cbd97f6 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -8,6 +8,7 @@ import simpy from marmot import le, process + from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -292,6 +293,7 @@ def transfer_gbf_substructures_from_storage( transit_time = distance / group.transit_speed while True: + start = group.env.now assembly = yield feed.get() delay = group.env.now - start @@ -355,6 +357,7 @@ def install_gravity_base_foundations( n = 0 while n < substructures: if queue.vessel: + start = vessel.env.now if n == 0: vessel.mobilize() diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 8376b274..c38908b2 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -8,6 +8,7 @@ import simpy from marmot import le, process + from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -291,6 +292,7 @@ def transfer_moored_substructures_from_storage( transit_time = distance / group.transit_speed while True: + start = group.env.now assembly = yield feed.get() delay = group.env.now - start @@ -364,6 +366,7 @@ def install_moored_substructures( n = 0 while n < substructures: if queue.vessel: + start = vessel.env.now if n == 0: vessel.mobilize() diff --git a/ORBIT/phases/install/scour_protection_install/standard.py b/ORBIT/phases/install/scour_protection_install/standard.py index db1c8ce6..9dd3ee9a 100644 --- a/ORBIT/phases/install/scour_protection_install/standard.py +++ b/ORBIT/phases/install/scour_protection_install/standard.py @@ -10,6 +10,7 @@ import simpy from marmot import process + from ORBIT.core import Vessel from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install import InstallPhase diff --git a/ORBIT/phases/install/turbine_install/common.py b/ORBIT/phases/install/turbine_install/common.py index f65aa7a3..057ff1bd 100644 --- a/ORBIT/phases/install/turbine_install/common.py +++ b/ORBIT/phases/install/turbine_install/common.py @@ -7,6 +7,7 @@ from marmot import process + from ORBIT.core import Cargo from ORBIT.core.defaults import process_times as pt diff --git a/ORBIT/phases/install/turbine_install/standard.py b/ORBIT/phases/install/turbine_install/standard.py index 58e273ab..d23515a1 100644 --- a/ORBIT/phases/install/turbine_install/standard.py +++ b/ORBIT/phases/install/turbine_install/standard.py @@ -12,6 +12,7 @@ import numpy as np import simpy from marmot import process + from ORBIT.core import Vessel from ORBIT.core.logic import ( jackdown_if_required, @@ -320,6 +321,7 @@ def solo_install_turbines( vessel.at_site = True if vessel.at_site: + if vessel.storage.items: yield prep_for_site_operations(vessel, **kwargs) @@ -405,7 +407,9 @@ def install_turbine_components_from_queue( wtiv.at_site = True if wtiv.at_site: + if queue.vessel: + # Prep for turbine install yield prep_for_site_operations(wtiv, **kwargs) diff --git a/ORBIT/supply_chain.py b/ORBIT/supply_chain.py index 8290eae7..b17e2ae8 100644 --- a/ORBIT/supply_chain.py +++ b/ORBIT/supply_chain.py @@ -5,47 +5,71 @@ from copy import deepcopy - -from ORBIT import ProjectManager from benedict import benedict +from ORBIT import ProjectManager -DEFAULT_MULTIPLIERS = { - "blades": {"domestic": 0.026, "imported": 0.30}, - "nacelle": {"domestic": 0.025, "imported": 0.10}, - "tower": { - "domestic": 0.04, - "imported": 0.20, - "tariffs": 0.25, - }, - "monopile": { - "domestic": 0.085, - "imported": 0.28, - "tariffs": 0.25, - }, - "transition_piece": { - "domestic": 0.169, - "imported": 0.17, - "tariffs": 0.25, - }, - "array_cable": {"domestic": 0.19, "imported": 0.0}, - "export_cable": {"domestic": 0.231, "imported": 0.0}, - "oss_topside": {"domestic": 0.0, "imported": 0.0}, - "oss_substructure": {"domestic": 0.0, "imported": 0.0}, -} -TURBINE_CAPEX_SPLIT = {"blades": 0.135, "nacelle": 0.274, "tower": 0.162} +DEFAULT_MULTIPLIERS = { + "blades": { + "domestic": .026, + "imported": .30 + }, + "nacelle": { + "domestic": .025, + "imported": .10 + }, + "tower": { + "domestic": .04, + "imported": .20, + "tariffs": .25, + }, + "monopile": { + "domestic": .085, + "imported": .28, + "tariffs": .25, + }, + "transition_piece": { + "domestic": .169, + "imported": .17, + "tariffs": .25, + }, + "array_cable": { + "domestic": .19, + "imported": 0. + }, + "export_cable": { + "domestic": .231, + "imported": 0. + }, + "oss_topside": { + "domestic": 0., + "imported": 0. + }, + "oss_substructure": { + "domestic": 0., + "imported": 0. + }, + } + + +TURBINE_CAPEX_SPLIT = { + "blades": 0.135, + "nacelle": 0.274, + "tower": 0.162 +} LABOR_SPLIT = { "tower": 0.5, "monopile": 0.5, "transition_piece": 0.5, - "oss_topside": 0.5, + "oss_topside": 0.5 } class SupplyChainManager: + def __init__(self, supply_chain_configuration, **kwargs): """ Creates an instance of `SupplyChainManager`. @@ -87,17 +111,17 @@ def pre_process(self, config): """""" # Save original plant design - plant = deepcopy(config["plant"]) + plant = deepcopy(config['plant']) # Run ProjectManager without install phases to generate design results - install_phases = config["install_phases"] - config["install_phases"] = [] + install_phases = config['install_phases'] + config['install_phases'] = [] project = ProjectManager(config) project.run() config = deepcopy(project.config) # Replace calculated plant design with original - config["plant"] = plant + config['plant'] = plant # Run pre ORBIT supply chain adjustments config = self.process_turbine_capex(config) @@ -106,8 +130,8 @@ def pre_process(self, config): config = self.process_offshore_substation_topside_capex(config) # Add install phases back in - config["install_phases"] = install_phases - config["design_phases"] = [] + config['install_phases'] = install_phases + config['design_phases'] = [] return config @@ -130,51 +154,45 @@ def process_turbine_capex(self, config): ORBIT configuration. """ - blade_scenario = self.sc_config["blades"] - nacelle_scenario = self.sc_config["nacelle"] - tower_scenario = self.sc_config["blades"] + blade_scenario = self.sc_config['blades'] + nacelle_scenario = self.sc_config['nacelle'] + tower_scenario = self.sc_config['blades'] blade_mult = self.multipliers["blades"].get(blade_scenario, None) if blade_mult == None: - print( - f"Warning: scenario '{blade_scenario}' not found for category 'blades'." - ) - blade_mult = 0.0 + print(f"Warning: scenario '{blade_scenario}' not found for category 'blades'.") + blade_mult = 0. nacelle_mult = self.multipliers["nacelle"].get(nacelle_scenario, None) if nacelle_mult == None: - print( - f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'." - ) - nacelle_mult = 0.0 + print(f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'.") + nacelle_mult = 0. - raw_cost = config.get("project_parameters.turbine_capex", 1300) - blade_adder = raw_cost * self.turbine_split["blades"] * blade_mult - nacelle_adder = raw_cost * self.turbine_split["nacelle"] * nacelle_mult + raw_cost = config.get('project_parameters.turbine_capex', 1300) + blade_adder = raw_cost * self.turbine_split['blades'] * blade_mult + nacelle_adder = raw_cost * self.turbine_split['nacelle'] * nacelle_mult if tower_scenario == "domestic, imported steel": tower_adder = self.multipliers["tower"]["domestic"] * raw_cost - tower_tariffs = ( - raw_cost - * self.turbine_split["tower"] - * (1 - self.labor_split["tower"]) - * self.multipliers["tower"]["tariffs"] - ) + tower_tariffs = raw_cost * self.turbine_split['tower'] *\ + (1 - self.labor_split['tower']) * self.multipliers["tower"]['tariffs'] else: - tower_tariffs = 0.0 + tower_tariffs = 0. tower_mult = self.multipliers["tower"].get(tower_scenario, None) if tower_mult == None: - print( - f"Warning: scenario '{tower_scenario}' not found for category 'tower'." - ) - tower_mult = 0.0 + print(f"Warning: scenario '{tower_scenario}' not found for category 'tower'.") + tower_mult = 0. - tower_adder = raw_cost * self.turbine_split["tower"] * tower_mult + tower_adder = raw_cost * self.turbine_split['tower'] * tower_mult - config["project_parameters.turbine_capex"] = sum( - [raw_cost, blade_adder, nacelle_adder, tower_adder, tower_tariffs] - ) + config['project_parameters.turbine_capex'] = sum([ + raw_cost, + blade_adder, + nacelle_adder, + tower_adder, + tower_tariffs + ]) return config @@ -188,29 +206,28 @@ def process_monopile_capex(self, config): ORBIT configuration. """ - raw_cost = config["monopile.unit_cost"] - scenario = self.sc_config["monopile"] + raw_cost = config['monopile.unit_cost'] + scenario = self.sc_config['monopile'] if scenario == "domestic, imported steel": - adder = self.multipliers["monopile"]["domestic"] * raw_cost - tariffs = ( - raw_cost - * (1 - self.labor_split["monopile"]) - * self.multipliers["monopile"]["tariffs"] - ) + adder = self.multipliers['monopile']['domestic'] * raw_cost + tariffs = raw_cost * (1 - self.labor_split['monopile']) *\ + self.multipliers["monopile"]['tariffs'] else: - tariffs = 0.0 + tariffs = 0. mult = self.multipliers["monopile"].get(scenario, None) if mult == None: - print( - f"Warning: scenario '{scenario}' not found for category 'monopile'." - ) - mult = 0.0 + print(f"Warning: scenario '{scenario}' not found for category 'monopile'.") + mult = 0. adder = raw_cost * mult - config["monopile.unit_cost"] = sum([raw_cost, adder, tariffs]) + config['monopile.unit_cost'] = sum([ + raw_cost, + adder, + tariffs + ]) return config @@ -225,29 +242,28 @@ def process_transition_piece_capex(self, config): ORBIT configuration. """ - raw_cost = config["transition_piece.unit_cost"] - scenario = self.sc_config["transition_piece"] + raw_cost = config['transition_piece.unit_cost'] + scenario = self.sc_config['transition_piece'] if scenario == "domestic, imported steel": - adder = self.multipliers["transition_piece"]["domestic"] * raw_cost - tariffs = ( - raw_cost - * (1 - self.labor_split["transition_piece"]) - * self.multipliers["transition_piece"]["tariffs"] - ) + adder = self.multipliers['transition_piece']['domestic'] * raw_cost + tariffs = raw_cost * (1 - self.labor_split['transition_piece']) *\ + self.multipliers["transition_piece"]['tariffs'] else: - tariffs = 0.0 + tariffs = 0. mult = self.multipliers["transition_piece"].get(scenario, None) if mult == None: - print( - f"Warning: scenario '{scenario}' not found for category 'transition_piece'." - ) - mult = 0.0 + print(f"Warning: scenario '{scenario}' not found for category 'transition_piece'.") + mult = 0. adder = raw_cost * mult - config["transition_piece.unit_cost"] = sum([raw_cost, adder, tariffs]) + config['transition_piece.unit_cost'] = sum([ + raw_cost, + adder, + tariffs + ]) return config @@ -262,31 +278,28 @@ def process_offshore_substation_topside_capex(self, config): ORBIT configuration. """ - raw_cost = config["offshore_substation_topside.unit_cost"] - scenario = self.sc_config["oss_topside"] + raw_cost = config['offshore_substation_topside.unit_cost'] + scenario = self.sc_config['oss_topside'] if scenario == "domestic, imported steel": - adder = self.multipliers["oss_topside"]["domestic"] * raw_cost - tariffs = ( - raw_cost - * (1 - self.labor_split["oss_topside"]) - * self.multipliers["oss_topside"]["tariffs"] - ) + adder = self.multipliers['oss_topside']['domestic'] * raw_cost + tariffs = raw_cost * (1 - self.labor_split['oss_topside']) *\ + self.multipliers["oss_topside"]['tariffs'] else: - tariffs = 0.0 + tariffs = 0. mult = self.multipliers["oss_topside"].get(scenario, None) if mult == None: - print( - f"Warning: scenario '{scenario}' not found for category 'oss_topside'." - ) - mult = 0.0 + print(f"Warning: scenario '{scenario}' not found for category 'oss_topside'.") + mult = 0. adder = raw_cost * mult - config["offshore_substation_topside.unit_cost"] = sum( - [raw_cost, adder, tariffs] - ) + config['offshore_substation_topside.unit_cost'] = sum([ + raw_cost, + adder, + tariffs + ]) return config @@ -300,15 +313,13 @@ def process_array_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config["array_cable"] + scenario = self.sc_config['array_cable'] mult = self.multipliers["array_cable"].get(scenario, None) if mult == None: - print( - f"Warning: scenario '{scenario}' not found for category 'array_cable'." - ) - mult = 0.0 + print(f"Warning: scenario '{scenario}' not found for category 'array_cable'.") + mult = 0. - project.system_costs["ArrayCableInstallation"] *= 1 + mult + project.system_costs['ArrayCableInstallation'] *= (1 + mult) return project @@ -321,14 +332,12 @@ def process_export_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config["export_cable"] + scenario = self.sc_config['export_cable'] mult = self.multipliers["export_cable"].get(scenario, None) if mult == None: - print( - f"Warning: scenario '{scenario}' not found for category 'export_cable'." - ) - mult = 0.0 + print(f"Warning: scenario '{scenario}' not found for category 'export_cable'.") + mult = 0. - project.system_costs["ExportCableInstallation"] *= 1 + mult + project.system_costs['ExportCableInstallation'] *= (1 + mult) return project diff --git a/docs/Makefile b/docs/Makefile index 51285967..298ea9e2 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -16,4 +16,4 @@ help: # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile - @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py index 555a6637..38ceb207 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -11,10 +11,10 @@ import os import sys -import ORBIT - sys.path.insert(0, os.path.abspath("..")) +import ORBIT + # -- Project information ----------------------------------------------------- project = "ORBIT" diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index 0c0585e9..c602bbf4 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.43 # mH/km linear_density: 90 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_500mm_220kV -rated_voltage: 220 +rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index 8f2c0988..ff5e4820 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.41 # mH/km linear_density: 96 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_630mm_220kV -rated_voltage: 220 +rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index b0e48470..18ed6b96 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.40 # mH/km linear_density: 105 # t/km cable_type: HVAC # HVDC vs HVAC name: XLPE_800mm_220kV -rated_voltage: 220 +rated_voltage: 220 \ No newline at end of file diff --git a/library/turbines/15MW_generic.yaml b/library/turbines/15MW_generic.yaml index 0a3683f9..50478a79 100644 --- a/library/turbines/15MW_generic.yaml +++ b/library/turbines/15MW_generic.yaml @@ -17,4 +17,4 @@ tower: type: Tower length: 150 mass: 480 # t -turbine_rating: 15 # MW +turbine_rating: 15 # MW \ No newline at end of file diff --git a/misc/supply_chain_plots.py b/misc/supply_chain_plots.py index 00a13ba3..75b6fd5c 100644 --- a/misc/supply_chain_plots.py +++ b/misc/supply_chain_plots.py @@ -1,40 +1,31 @@ -import os +import pandas as pd import math - import numpy as np -import pandas as pd import matplotlib as mpl -import matplotlib.text as txt import matplotlib.pyplot as plt +import matplotlib.text as txt +import os - -def mysave(fig, froot, mode="png"): - assert mode in ["png", "eps", "pdf", "all"] +def mysave(fig, froot, mode='png'): + assert mode in ['png', 'eps', 'pdf', 'all'] fileName, fileExtension = os.path.splitext(froot) padding = 0.1 dpiVal = 200 legs = [] for a in fig.get_axes(): addLeg = a.get_legend() - if not addLeg is None: - legs.append(a.get_legend()) + if not addLeg is None: legs.append(a.get_legend()) ext = [] - if mode == "png" or mode == "all": - ext.append("png") - if mode == "eps": # or mode == 'all': - ext.append("eps") - if mode == "pdf" or mode == "all": - ext.append("pdf") + if mode == 'png' or mode == 'all': + ext.append('png') + if mode == 'eps': # or mode == 'all': + ext.append('eps') + if mode == 'pdf' or mode == 'all': + ext.append('pdf') for sfx in ext: - fig.savefig( - fileName + "." + sfx, - format=sfx, - pad_inches=padding, - bbox_inches="tight", - dpi=dpiVal, - bbox_extra_artists=legs, - ) + fig.savefig(fileName + '.' + sfx, format=sfx, pad_inches=padding, bbox_inches='tight', + dpi=dpiVal, bbox_extra_artists=legs) titleSize = 24 # 40 #38 @@ -47,48 +38,32 @@ def mysave(fig, froot, mode="png"): linewidth = 3 -def myformat( - ax, - linewidth=linewidth, - xticklabel=tickLabelSize, - yticklabel=tickLabelSize, - mode="save", -): - assert type(mode) == type("") - assert mode.lower() in ["save", "show"], "Unknown mode" - - def myformat( - myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel - ): - if mode.lower() == "show": +def myformat(ax, linewidth=linewidth, xticklabel=tickLabelSize, yticklabel=tickLabelSize, mode='save'): + assert type(mode) == type('') + assert mode.lower() in ['save', 'show'], 'Unknown mode' + + def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel): + if mode.lower() == 'show': for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize + 3 * deltaShow) for i in myax.get_lines(): - if i.get_marker() == "D": - continue # Don't modify baseline diamond + if i.get_marker() == 'D': continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() if not leg is None: - for t in leg.get_texts(): - t.set_fontsize(legendSize + deltaShow + 6) + for t in leg.get_texts(): t.set_fontsize(legendSize + deltaShow + 6) th = leg.get_title() if not th is None: th.set_fontsize(legendSize + deltaShow + 6) - myax.set_title( - myax.get_title(), size=titleSize + deltaShow, weight="bold" - ) - myax.set_xlabel( - myax.get_xlabel(), size=axLabelSize + deltaShow, weight="bold" - ) - myax.set_ylabel( - myax.get_ylabel(), size=axLabelSize + deltaShow, weight="bold" - ) + myax.set_title(myax.get_title(), size=titleSize + deltaShow, weight='bold') + myax.set_xlabel(myax.get_xlabel(), size=axLabelSize + deltaShow, weight='bold') + myax.set_ylabel(myax.get_ylabel(), size=axLabelSize + deltaShow, weight='bold') myax.tick_params(labelsize=tickLabelSize + deltaShow) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -100,29 +75,27 @@ def myformat( for i in myax.get_yticklines(): i.set_linewidth(3) - elif mode.lower() == "save": + elif mode.lower() == 'save': for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize) for i in myax.get_lines(): - if i.get_marker() == "D": - continue # Don't modify baseline diamond + if i.get_marker() == 'D': continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() if not leg is None: - for t in leg.get_texts(): - t.set_fontsize(legendSize) + for t in leg.get_texts(): t.set_fontsize(legendSize) th = leg.get_title() if not th is None: th.set_fontsize(legendSize) - myax.set_title(myax.get_title(), size=titleSize, weight="bold") - myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight="bold") - myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight="bold") + myax.set_title(myax.get_title(), size=titleSize, weight='bold') + myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight='bold') + myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight='bold') myax.tick_params(labelsize=tickLabelSize) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -135,62 +108,40 @@ def myformat( i.set_linewidth(3) if type(ax) == type([]): - for i in ax: - myformat(i) + for i in ax: myformat(i) else: myformat(ax) - def initFigAxis(figx=12, figy=9): fig = plt.figure(figsize=(figx, figy)) ax = fig.add_subplot(111) return fig, ax - def waterfall_plot(x, y, bottom, color, bar_text, fname=None): - """Waterfall plot comparing European andUS manufactining costs""" + """ Waterfall plot comparing European andUS manufactining costs""" fig, ax = initFigAxis() - h = ax.bar(x, y, bottom=bottom, color=color, edgecolor="k") + h = ax.bar(x, y,bottom=bottom, color=color, edgecolor='k') ax.get_yaxis().set_major_formatter( - mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ",")) - ) - ax.set_ylabel("Capital Expenditures, $/kW") - ax.set_title( - "Comparison of different cost premiums between \nimported and domestically manufactured components" - ) - - h[3].set_linestyle("--") + mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ','))) + ax.set_ylabel('Capital Expenditures, $/kW') + ax.set_title('Comparison of different cost premiums between \nimported and domestically manufactured components') + + h[3].set_linestyle('--') h[3].set_linewidth(1.75) - h[3].set_edgecolor("k") - - ax.text( - x[1], - 2000, - bar_text["transit"], - horizontalalignment="center", - ) - ax.text( - x[2], - 2000, - bar_text["factory"], - horizontalalignment="center", - ) - ax.text( - x[3], - 2000, - bar_text["margin"], - horizontalalignment="center", - ) + h[3].set_edgecolor('k') + + ax.text(x[1], 2000, bar_text['transit'], horizontalalignment='center',) + ax.text(x[2], 2000, bar_text['factory'], horizontalalignment='center',) + ax.text(x[3], 2000, bar_text['margin'], horizontalalignment='center',) if fname is not None: myformat(ax) mysave(fig, fname) plt.close() - def area_time_plot(x, y, color, fname=None): """Area plot showing changin component cost over time""" @@ -199,52 +150,40 @@ def area_time_plot(x, y, color, fname=None): y0 = np.zeros(len(x)) y_init = 0 - y_init = np.sum([v[0] for k, v in y.items()]) + y_init = np.sum([v[0] for k,v in y.items()]) - for k, v in y.items(): - y1 = [yi + vi for yi, vi in zip(y0, v)] + for k,v in y.items(): + y1 = [yi+vi for yi, vi in zip(y0,v)] ax.fill_between(x, y0 / y_init, y1 / y_init, color=color[k], label=k) - ax.plot(x, y1 / y_init, "w") + ax.plot(x, y1 / y_init, 'w') y0 = y1 # Define margin - ax.fill_between( - x, - y1 / y_init, - np.ones(len(x)), - color=color["Cost margin"], - label="Margin", - ) + ax.fill_between(x, y1 / y_init, np.ones(len(x)), color=color['Cost margin'], label='Margin') - final_margin = round(100 * (1 - y1[-1] / y_init), 1) + final_margin = round( 100* (1 - y1[-1] / y_init), 1) - y_margin = (1 + y1[-1] / y_init) / 2 + y_margin = ((1 + y1[-1] / y_init) /2) - margin_text = ( - " " - + str(final_margin) - + "% CapEx margin relative to \n European imports can cover \n local differences in wages, \n taxes, financing, etc" - ) + margin_text = ' ' + str(final_margin) + '% CapEx margin relative to \n European imports can cover \n local differences in wages, \n taxes, financing, etc' right_bound = 2030.5 right_spline_corr = 0.2 - ax.plot([2030, right_bound], [y_margin, y_margin], "k") - ax.text(right_bound, y_margin, margin_text, verticalalignment="center") - ax.spines["right"].set_position(("data", right_bound - right_spline_corr)) - ax.spines["top"].set_bounds(2022.65, right_bound - right_spline_corr) - ax.spines["bottom"].set_bounds(2022.65, right_bound - right_spline_corr) + ax.plot([2030, right_bound], [y_margin, y_margin], 'k') + ax.text(right_bound, y_margin, margin_text, verticalalignment='center') + ax.spines["right"].set_position(("data", right_bound-right_spline_corr)) + ax.spines["top"].set_bounds(2022.65, right_bound-right_spline_corr) + ax.spines["bottom"].set_bounds(2022.65, right_bound-right_spline_corr) - ax.text(2023, -0.215, "(Fully \nimported)", horizontalalignment="center") - ax.text(2030, -0.215, "(Fully \ndomestic)", horizontalalignment="center") + ax.text(2023, -0.215, '(Fully \nimported)', horizontalalignment='center') + ax.text(2030, -0.215, '(Fully \ndomestic)', horizontalalignment='center') - ax.set_yticklabels([-20, 0, 20, 40, 60, 80, 100]) + ax.set_yticklabels([-20, 0, 20, 40, 60, 80 ,100]) ax.legend(loc=(1, 0.05)) - ax.set_ylabel( - "CapEx breakdown relative to \ncomponents imported from Europe, %" - ) + ax.set_ylabel('CapEx breakdown relative to \ncomponents imported from Europe, %') if fname is not None: myformat(ax) diff --git a/templates/design_module.py b/templates/design_module.py index eed5b2c9..2b1bdafe 100644 --- a/templates/design_module.py +++ b/templates/design_module.py @@ -12,10 +12,12 @@ class TemplateDesign(DesignPhase): expected_config = { "required_input": "unit", - "optional_input": "unit, (optional, default: 'default')", + "optional_input": "unit, (optional, default: 'default')" } - output_config = {"example_output": "unit"} + output_config = { + "example_output": "unit" + } def __init__(self, config, **kwargs): """Creates an instance of `TemplateDesign`.""" @@ -43,7 +45,9 @@ def example_computation(self): def detailed_output(self): """Returns detailed output dictionary.""" - return {"example_detailed_output": self.result} + return { + "example_detailed_output": self.result + } @property def total_cost(self): @@ -56,7 +60,9 @@ def total_cost(self): def design_result(self): """Must match `self.output_config` structure.""" - return {"example_output": self.result} + return { + "example_output": self.result + } # === Annotated Example === @@ -69,21 +75,18 @@ class SparDesign(DesignPhase): # that ProjectManager doesn't raise a warning if doesn't find the input in # a project level config. expected_config = { - "site": { - "depth": "m" - }, # For common inputs that will be shared across many modules, - "plant": { - "num_turbines": "int" - }, # it's best to look up how the variable is named in existing modules - "turbine": { - "turbine_rating": "MW" - }, # so the user doesn't have to input the same thing twice. For example, avoid adding - # 'number_turbines' if 'num_turbines' is already used throughout ORBIT + "site": {"depth": "m"}, # For common inputs that will be shared across many modules, + "plant": {"num_turbines": "int"}, # it's best to look up how the variable is named in existing modules + "turbine": {"turbine_rating": "MW"}, # so the user doesn't have to input the same thing twice. For example, avoid adding + # 'number_turbines' if 'num_turbines' is already used throughout ORBIT + + + # Inputs can be grouped into dictionaries like the following: "spar_design": { - "stiffened_column_CR": "$/t (optional, default: 3120)", # I tend to group module specific cost rates - "tapered_column_CR": "$/t (optional, default: 4220)", # into dictionaries named after the component being considered - "ballast_material_CR": "$/t (optional, default: 100)", # eg. spar_design, gbf_design, etc. + "stiffened_column_CR": "$/t (optional, default: 3120)", # I tend to group module specific cost rates + "tapered_column_CR": "$/t (optional, default: 4220)", # into dictionaries named after the component being considered + "ballast_material_CR": "$/t (optional, default: 100)", # eg. spar_design, gbf_design, etc. "secondary_steel_CR": "$/t (optional, default: 7250)", "towing_speed": "km/h (optional, default: 6)", }, @@ -94,8 +97,8 @@ class SparDesign(DesignPhase): # results are used as inputs to installation modules. As such, these output # names should match the input names of the respective installation module output_config = { - "substructure": { # Typically a design phase ouptuts a component design - "mass": "t", # grouped into a dictionary, eg. "substructure" dict to the left. + "substructure": { # Typically a design phase ouptuts a component design + "mass": "t", # grouped into a dictionary, eg. "substructure" dict to the left. "ballasted_mass": "t", "unit_cost": "USD", "towing_speed": "km/h", @@ -111,18 +114,13 @@ def __init__(self, config, **kwargs): config : dict """ - config = self.initialize_library( - config, **kwargs - ) # These first two lines are required in all modules. They initialize the library - self.config = self.validate_config( - config - ) # if it hasn't already been and validate the config against '.expected_config' from above - - self._design = self.config.get( - "spar_design", {} - ) # Not required, but I often save module specific outputs to "_design" for later use - # If the "spar_design" sub dictionary isn't found, an empty one is returned to - # work with later methods. + config = self.initialize_library(config, **kwargs) # These first two lines are required in all modules. They initialize the library + self.config = self.validate_config(config) # if it hasn't already been and validate the config against '.expected_config' from above + + + self._design = self.config.get("spar_design", {}) # Not required, but I often save module specific outputs to "_design" for later use + # If the "spar_design" sub dictionary isn't found, an empty one is returned to + # work with later methods. self._outputs = {} def run(self): @@ -154,7 +152,7 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) return mass @@ -176,10 +174,8 @@ def stiffened_column_cost(self): Calculates the cost of the stiffened column for a single spar. From original OffshoreBOS model. """ - cr = self._design.get( - "stiffened_column_CR", 3120 - ) # This is how I typically handle outputs. This will look for the key in - # self._design, and return default value if it isn't found. + cr = self._design.get("stiffened_column_CR", 3120) # This is how I typically handle outputs. This will look for the key in + # self._design, and return default value if it isn't found. return self.stiffened_column_mass * cr @property @@ -198,7 +194,7 @@ def ballast_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 return mass @@ -223,7 +219,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 - + 0.196 * (rating**0.5) * log(rating) + + 0.196 * (rating ** 0.5) * log(rating) + 0.00001 * depth * log(depth) ) @@ -271,7 +267,7 @@ def substructure_cost(self): # The following properties are required methods for a DesignPhase # .detailed_output returns any relevant detailed outputs from the module - # in a dictionary. + # in a dictionary. @property def detailed_output(self): """Returns detailed phase information.""" diff --git a/tests/api/test_wisdem_api.py b/tests/api/test_wisdem_api.py index 4cc5fa25..e15c8156 100644 --- a/tests/api/test_wisdem_api.py +++ b/tests/api/test_wisdem_api.py @@ -11,6 +11,7 @@ def test_wisdem_monopile_api_default(): + prob = om.Problem(reports=False) prob.model = Orbit(floating=False, jacket=False, jacket_legs=0) prob.setup() @@ -22,6 +23,7 @@ def test_wisdem_monopile_api_default(): def test_wisdem_jacket_api_default(): + prob = om.Problem(reports=False) prob.model = Orbit(floating=False, jacket=True, jacket_legs=3) prob.setup() @@ -33,6 +35,7 @@ def test_wisdem_jacket_api_default(): def test_wisdem_floating_api_default(): + prob = om.Problem(reports=False) prob.model = Orbit(floating=True, jacket=False, jacket_legs=0) prob.setup() diff --git a/tests/conftest.py b/tests/conftest.py index 5579f62c..a480e04e 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -5,6 +5,7 @@ import pytest from marmot import Environment + from ORBIT.core import Vessel from tests.data import test_weather from ORBIT.core.library import initialize_library, extract_library_specs @@ -23,23 +24,27 @@ def pytest_configure(): @pytest.fixture() def env(): + return Environment("Test Environment", state=test_weather) @pytest.fixture() def wtiv(): + specs = extract_library_specs("wtiv", "test_wtiv") return Vessel("Test WTIV", specs) @pytest.fixture() def feeder(): + specs = extract_library_specs("feeder", "test_feeder") return Vessel("Test Feeder", specs) @pytest.fixture() def cable_vessel(): + specs = extract_library_specs( "array_cable_install_vessel", "test_cable_lay_vessel" ) @@ -48,6 +53,7 @@ def cable_vessel(): @pytest.fixture() def heavy_lift(): + specs = extract_library_specs( "oss_install_vessel", "test_heavy_lift_vessel" ) @@ -56,16 +62,19 @@ def heavy_lift(): @pytest.fixture() def spi_vessel(): + specs = extract_library_specs("spi_vessel", "test_scour_protection_vessel") return Vessel("Test SPI Vessel", specs) @pytest.fixture() def simple_cable(): + return SimpleCable(linear_density=50.0) @pytest.fixture(scope="function") def tmp_yaml_del(): + yield os.remove("tmp.yaml") diff --git a/tests/core/test_environment.py b/tests/core/test_environment.py index b5f5208b..0ce94758 100644 --- a/tests/core/test_environment.py +++ b/tests/core/test_environment.py @@ -8,6 +8,7 @@ import pandas as pd import pytest from marmot import le + from ORBIT.core import Environment from tests.data import test_weather as _weather diff --git a/tests/core/test_library.py b/tests/core/test_library.py index 9cac3f50..7320a9f6 100644 --- a/tests/core/test_library.py +++ b/tests/core/test_library.py @@ -9,6 +9,7 @@ from copy import deepcopy import pytest + from ORBIT import ProjectManager from ORBIT.core import library from ORBIT.core.exceptions import LibraryItemNotFoundError @@ -57,6 +58,7 @@ def test_extract_library_specs_fail(): def test_phase_specific_file_extraction(): + project = ProjectManager(config) turbine_config = project.create_config_for_phase("TurbineInstallation") monopile_config = project.create_config_for_phase("MonopileInstallation") diff --git a/tests/core/test_port.py b/tests/core/test_port.py index 6415118d..915af401 100644 --- a/tests/core/test_port.py +++ b/tests/core/test_port.py @@ -8,6 +8,7 @@ import pytest from marmot import Environment + from ORBIT.core import Port, Cargo from ORBIT.core.exceptions import ItemNotFound @@ -18,6 +19,7 @@ def __init__(self): def test_port_creation(): + env = Environment() port = Port(env) item = SampleItem() @@ -30,6 +32,7 @@ def test_port_creation(): def test_get_item(): + env = Environment() port = Port(env) item = SampleItem() diff --git a/tests/phases/design/test_array_system_design.py b/tests/phases/design/test_array_system_design.py index 39c42a82..cd1ad5cd 100644 --- a/tests/phases/design/test_array_system_design.py +++ b/tests/phases/design/test_array_system_design.py @@ -10,6 +10,7 @@ import numpy as np import pytest + from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ArraySystemDesign, CustomArraySystemDesign from ORBIT.core.exceptions import LibraryItemNotFoundError @@ -208,6 +209,7 @@ def test_correct_turbines(): def test_floating_calculations(): + base = deepcopy(config_full_ring) base["site"]["depth"] = 50 number = base["plant"]["num_turbines"] diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index c141f7cc..e3e972e2 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -111,6 +111,7 @@ def test_power_factor(): np.arange(0, 1, 0.15), # inductance range(100, 1001, 150), # capacitance ): + c["conductor_size"] = i[0] c["ac_resistance"] = i[1] c["inductance"] = i[2] diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index ed8c6d82..605ea434 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -32,6 +32,7 @@ ), ) def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): + config = { "site": {"distance_to_landfall": distance_to_landfall, "depth": depth}, "plant": {"capacity": plant_cap}, @@ -58,6 +59,7 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_ac_oss_kwargs(): + test_kwargs = { "mpt_cost_rate": 13500, "topside_fab_cost_rate": 17000, @@ -78,6 +80,7 @@ def test_ac_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): + config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v @@ -98,6 +101,7 @@ def test_dc_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): + config = deepcopy(base) config["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" config["substation_design"] = {} @@ -134,6 +138,7 @@ def test_hvdc_substation(): def test_export_kwargs(): + test_kwargs = { "num_redundant": 2, "touchdown_distance": 50, @@ -145,6 +150,7 @@ def test_export_kwargs(): base_cost = o.total_cost for k, v in test_kwargs.items(): + config = deepcopy(base) config["export_system_design"] = {"cables": "XLPE_630mm_220kV"} config["export_system_design"][k] = v @@ -251,6 +257,7 @@ def test_design_result(): def test_floating_length_calculations(): + base = deepcopy(config) base["site"]["depth"] = 250 base["export_system_design"]["touchdown_distance"] = 0 @@ -270,6 +277,7 @@ def test_floating_length_calculations(): def test_HVDC_cable(): + base = deepcopy(config) base["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} @@ -288,6 +296,7 @@ def test_HVDC_cable(): def test_num_crossing(): + base_sim = ElectricalDesign(config) base_sim.run() @@ -301,6 +310,7 @@ def test_num_crossing(): def test_cost_crossing(): + base_sim = ElectricalDesign(config) base_sim.run() diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 32e91dd9..7039bb5b 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -104,6 +104,7 @@ def test_design_result(): def test_floating_length_calculations(): + base = deepcopy(config) base["site"]["depth"] = 250 base["export_system_design"]["touchdown_distance"] = 0 diff --git a/tests/phases/design/test_monopile_design.py b/tests/phases/design/test_monopile_design.py index 2f69ed18..0762b46b 100644 --- a/tests/phases/design/test_monopile_design.py +++ b/tests/phases/design/test_monopile_design.py @@ -10,6 +10,7 @@ from itertools import product import pytest + from ORBIT.phases.design import MonopileDesign base = { @@ -36,6 +37,7 @@ product(range(10, 51, 10), range(8, 13, 1), turbines), ) def test_paramater_sweep(depth, mean_ws, turbine): + config = { "site": {"depth": depth, "mean_windspeed": mean_ws}, "plant": {"num_turbines": 20}, @@ -59,6 +61,7 @@ def test_paramater_sweep(depth, mean_ws, turbine): def test_monopile_kwargs(): + test_kwargs = { "yield_stress": 400000000, "load_factor": 1.25, @@ -77,6 +80,7 @@ def test_monopile_kwargs(): base_results = m._outputs["monopile"] for k, v in test_kwargs.items(): + config = deepcopy(base) config["monopile_design"] = {} config["monopile_design"][k] = v @@ -89,6 +93,7 @@ def test_monopile_kwargs(): def test_transition_piece_kwargs(): + test_kwargs = { # Transition piece specific "monopile_tp_connection_thickness": 0.005, @@ -102,6 +107,7 @@ def test_transition_piece_kwargs(): base_results = m._outputs["transition_piece"] for k, v in test_kwargs.items(): + config = deepcopy(base) config["monopile_design"] = {} config["monopile_design"][k] = v diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index c59ef535..88a7a747 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -9,6 +9,7 @@ from copy import deepcopy import pytest + from ORBIT.phases.design import MooringSystemDesign base = { @@ -20,6 +21,7 @@ @pytest.mark.parametrize("depth", range(10, 1000, 100)) def test_depth_sweep(depth): + config = deepcopy(base) config["site"]["depth"] = depth @@ -32,6 +34,7 @@ def test_depth_sweep(depth): @pytest.mark.parametrize("rating", range(3, 15, 1)) def test_rating_sweeip(rating): + config = deepcopy(base) config["turbine"]["turbine_rating"] = rating @@ -43,6 +46,7 @@ def test_rating_sweeip(rating): def test_drag_embedment_fixed_length(): + m = MooringSystemDesign(base) m.run() @@ -71,6 +75,7 @@ def test_drag_embedment_fixed_length(): def test_custom_num_lines(): + config = deepcopy(base) config["mooring_system_design"] = {"num_lines": 5} diff --git a/tests/phases/design/test_oss_design.py b/tests/phases/design/test_oss_design.py index f17b3bd7..b2dd6316 100644 --- a/tests/phases/design/test_oss_design.py +++ b/tests/phases/design/test_oss_design.py @@ -8,6 +8,7 @@ from itertools import product import pytest + from ORBIT.phases.design import OffshoreSubstationDesign base = { @@ -23,6 +24,7 @@ product(range(10, 51, 10), range(3, 13, 1), range(20, 80, 10)), ) def test_parameter_sweep(depth, num_turbines, turbine_rating): + config = { "site": {"depth": depth}, "plant": {"num_turbines": num_turbines}, @@ -49,6 +51,7 @@ def test_parameter_sweep(depth, num_turbines, turbine_rating): def test_oss_kwargs(): + test_kwargs = { "mpt_cost_rate": 13500, "topside_fab_cost_rate": 15500, @@ -69,6 +72,7 @@ def test_oss_kwargs(): base_cost = o.total_cost for k, v in test_kwargs.items(): + config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v diff --git a/tests/phases/design/test_scour_protection_design.py b/tests/phases/design/test_scour_protection_design.py index d4168fd1..301e5894 100644 --- a/tests/phases/design/test_scour_protection_design.py +++ b/tests/phases/design/test_scour_protection_design.py @@ -10,6 +10,7 @@ import numpy as np import pytest + from ORBIT.phases.design import ScourProtectionDesign config_min_defined = { diff --git a/tests/phases/design/test_semisubmersible_design.py b/tests/phases/design/test_semisubmersible_design.py index 30a134f3..7c710fb9 100644 --- a/tests/phases/design/test_semisubmersible_design.py +++ b/tests/phases/design/test_semisubmersible_design.py @@ -8,6 +8,7 @@ from itertools import product import pytest + from ORBIT.phases.design import SemiSubmersibleDesign base = { @@ -22,6 +23,7 @@ "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) ) def test_parameter_sweep(depth, turbine_rating): + config = { "site": {"depth": depth}, "plant": {"num_turbines": 50}, @@ -39,6 +41,7 @@ def test_parameter_sweep(depth, turbine_rating): def test_design_kwargs(): + test_kwargs = { "stiffened_column_CR": 3000, "truss_CR": 6000, @@ -51,6 +54,7 @@ def test_design_kwargs(): base_cost = s.total_cost for k, v in test_kwargs.items(): + config = deepcopy(base) config["semisubmersible_design"] = {} config["semisubmersible_design"][k] = v diff --git a/tests/phases/design/test_spar_design.py b/tests/phases/design/test_spar_design.py index dbc937c1..393cf7c1 100644 --- a/tests/phases/design/test_spar_design.py +++ b/tests/phases/design/test_spar_design.py @@ -8,6 +8,7 @@ from itertools import product import pytest + from ORBIT.phases.design import SparDesign base = { @@ -22,6 +23,7 @@ "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) ) def test_parameter_sweep(depth, turbine_rating): + config = { "site": {"depth": depth}, "plant": {"num_turbines": 50}, @@ -39,6 +41,7 @@ def test_parameter_sweep(depth, turbine_rating): def test_design_kwargs(): + test_kwargs = { "stiffened_column_CR": 3000, "tapered_column_CR": 4000, @@ -51,6 +54,7 @@ def test_design_kwargs(): base_cost = s.total_cost for k, v in test_kwargs.items(): + config = deepcopy(base) config["spar_design"] = {} config["spar_design"][k] = v diff --git a/tests/phases/install/cable_install/test_array_install.py b/tests/phases/install/cable_install/test_array_install.py index f9b1c9a9..5a01c14b 100644 --- a/tests/phases/install/cable_install/test_array_install.py +++ b/tests/phases/install/cable_install/test_array_install.py @@ -12,6 +12,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -27,6 +28,7 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): + sim = ArrayCableInstallation(config) assert sim.env @@ -35,6 +37,7 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): + sim = ArrayCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -50,6 +53,7 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): + sim = ArrayCableInstallation(config, weather=weather) sim.run() @@ -68,6 +72,7 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): + sim = ArrayCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time @@ -84,6 +89,7 @@ def test_simultaneous_speed_kwargs(): def test_separate_speed_kwargs(): + sim = ArrayCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -108,6 +114,7 @@ def test_separate_speed_kwargs(): def test_kwargs_for_array_install(): + sim = ArrayCableInstallation(base_config) sim.run() baseline = sim.total_phase_time @@ -124,6 +131,7 @@ def test_kwargs_for_array_install(): failed = [] for kw in keywords: + default = pt[kw] if "speed" in kw: @@ -155,6 +163,7 @@ def test_kwargs_for_array_install(): def test_kwargs_for_array_install_in_ProjectManager(): + base = deepcopy(base_config) base["install_phases"] = ["ArrayCableInstallation"] @@ -174,6 +183,7 @@ def test_kwargs_for_array_install_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] if "speed" in kw: diff --git a/tests/phases/install/cable_install/test_cable_tasks.py b/tests/phases/install/cable_install/test_cable_tasks.py index f3d03350..3ab42d15 100644 --- a/tests/phases/install/cable_install/test_cable_tasks.py +++ b/tests/phases/install/cable_install/test_cable_tasks.py @@ -9,6 +9,7 @@ import pytest + from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.cable_install.common import ( tow_plow, @@ -27,6 +28,7 @@ def test_load_cable_on_vessel(env, cable_vessel, feeder, simple_cable): + env.register(cable_vessel) cable_vessel.initialize(mobilize=False) @@ -57,6 +59,7 @@ def test_load_cable_on_vessel(env, cable_vessel, feeder, simple_cable): ], ) def test_task(env, cable_vessel, task, log, args): + env.register(cable_vessel) cable_vessel.initialize(mobilize=False) diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index f4237200..80889fb1 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -12,6 +12,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -27,6 +28,7 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): + sim = ExportCableInstallation(config) assert sim.env assert sim.cable @@ -40,6 +42,7 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): + sim = ExportCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -55,6 +58,7 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): + sim = ExportCableInstallation(config, weather=weather) sim.run() @@ -73,6 +77,7 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): + sim = ExportCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time @@ -89,6 +94,7 @@ def test_simultaneous_speed_kwargs(): def test_separate_speed_kwargs(): + sim = ExportCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -113,6 +119,7 @@ def test_separate_speed_kwargs(): def test_kwargs_for_export_install(): + new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -144,6 +151,7 @@ def test_kwargs_for_export_install(): failed = [] for kw in keywords: + default = pt[kw] if "speed" in kw: @@ -175,6 +183,7 @@ def test_kwargs_for_export_install(): def test_kwargs_for_export_install_in_ProjectManager(): + new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -206,6 +215,7 @@ def test_kwargs_for_export_install_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] if "speed" in kw: diff --git a/tests/phases/install/jacket_install/test_jacket_install.py b/tests/phases/install/jacket_install/test_jacket_install.py index c601a5c6..6811e631 100644 --- a/tests/phases/install/jacket_install/test_jacket_install.py +++ b/tests/phases/install/jacket_install/test_jacket_install.py @@ -10,6 +10,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,6 +29,7 @@ ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_simulation_setup(config): + sim = JacketInstallation(config) assert sim.config == config assert sim.env @@ -48,6 +50,7 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): + sim = JacketInstallation(config) assert sim.wtiv assert sim.wtiv.jacksys @@ -71,6 +74,7 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): + sim = JacketInstallation(config, weather=weather) sim.run() @@ -93,6 +97,7 @@ def test_for_complete_logging(weather, config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_num_legs(config): + base = JacketInstallation(config) base.run() @@ -111,6 +116,7 @@ def test_num_legs(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_foundation_type(config): + base = JacketInstallation(config) base.run() @@ -128,6 +134,7 @@ def test_foundation_type(config): def test_kwargs_piles(): + sim = JacketInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -147,6 +154,7 @@ def test_kwargs_piles(): failed = [] for kw in keywords: + default = pt[kw] kwargs = {kw: default + 2} @@ -168,6 +176,7 @@ def test_kwargs_piles(): def test_kwargs_suction(): + config_wtiv_suction = deepcopy(config_wtiv) config_wtiv_suction["jacket"]["foundation_type"] = "suction" @@ -188,6 +197,7 @@ def test_kwargs_suction(): failed = [] for kw in keywords: + default = pt[kw] kwargs = {kw: default + 2} diff --git a/tests/phases/install/monopile_install/test_monopile_install.py b/tests/phases/install/monopile_install/test_monopile_install.py index 1759bc3e..57538063 100644 --- a/tests/phases/install/monopile_install/test_monopile_install.py +++ b/tests/phases/install/monopile_install/test_monopile_install.py @@ -10,6 +10,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,6 +29,7 @@ ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_simulation_setup(config): + sim = MonopileInstallation(config) assert sim.config == config assert sim.env @@ -48,6 +50,7 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): + sim = MonopileInstallation(config) assert sim.wtiv assert sim.wtiv.jacksys @@ -71,6 +74,7 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): + sim = MonopileInstallation(config, weather=weather) sim.run() @@ -88,6 +92,7 @@ def test_for_complete_logging(weather, config): def test_kwargs(): + sim = MonopileInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -108,6 +113,7 @@ def test_kwargs(): failed = [] for kw in keywords: + default = pt[kw] if kw == "mono_drive_rate": @@ -139,6 +145,7 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): + base = deepcopy(config_wtiv) base["install_phases"] = ["MonopileInstallation"] project = ProjectManager(base) @@ -161,6 +168,7 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] if kw == "mono_drive_rate": @@ -195,6 +203,7 @@ def test_kwargs_in_ProjectManager(): def test_grout_kwargs(): + sim = MonopileInstallation(config_wtiv) sim.run() diff --git a/tests/phases/install/monopile_install/test_monopile_tasks.py b/tests/phases/install/monopile_install/test_monopile_tasks.py index 2fa11d9e..bff023f5 100644 --- a/tests/phases/install/monopile_install/test_monopile_tasks.py +++ b/tests/phases/install/monopile_install/test_monopile_tasks.py @@ -9,6 +9,7 @@ import pytest + from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.monopile_install.common import ( drive_monopile, @@ -34,6 +35,7 @@ ], ) def test_task(env, wtiv, task, log, args): + env.register(wtiv) wtiv.initialize(mobilize=False) @@ -53,6 +55,7 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): + env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/install/mooring_install/test_mooring_install.py b/tests/phases/install/mooring_install/test_mooring_install.py index 3583bbda..116f7558 100644 --- a/tests/phases/install/mooring_install/test_mooring_install.py +++ b/tests/phases/install/mooring_install/test_mooring_install.py @@ -12,6 +12,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -60,6 +61,7 @@ def test_full_run_logging(weather): ], ) def test_kwargs(anchor, key): + new = deepcopy(config) new["mooring_system"]["anchor_type"] = anchor @@ -72,6 +74,7 @@ def test_kwargs(anchor, key): failed = [] for kw in keywords: + default = pt[kw] kwargs = {kw: default + 2} @@ -100,6 +103,7 @@ def test_kwargs(anchor, key): ], ) def test_kwargs_in_ProjectManager(anchor, key): + base = deepcopy(config) base["mooring_system"]["anchor_type"] = anchor base["install_phases"] = ["MooringSystemInstallation"] @@ -113,6 +117,7 @@ def test_kwargs_in_ProjectManager(anchor, key): failed = [] for kw in keywords: + default = pt[kw] processes = {kw: default + 2} new_config = deepcopy(base) diff --git a/tests/phases/install/oss_install/test_oss_install.py b/tests/phases/install/oss_install/test_oss_install.py index 30ed4475..be32be3d 100644 --- a/tests/phases/install/oss_install/test_oss_install.py +++ b/tests/phases/install/oss_install/test_oss_install.py @@ -10,6 +10,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -32,6 +33,7 @@ ids=["single_feeder", "multi_feeder"], ) def test_simulation_setup(config): + sim = OffshoreSubstationInstallation(config) assert sim.config == config assert sim.env @@ -43,6 +45,7 @@ def test_simulation_setup(config): def test_floating_simulation_setup(): + sim = FloatingSubstationInstallation(config_floating) assert sim.config == config_floating assert sim.env @@ -55,6 +58,7 @@ def test_floating_simulation_setup(): ids=["single_feeder", "multi_feeder"], ) def test_vessel_initialization(config): + sim = OffshoreSubstationInstallation(config) assert sim.oss_vessel assert sim.oss_vessel.crane @@ -78,6 +82,7 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): + # No weather sim = OffshoreSubstationInstallation(config, weather=weather) sim.run() @@ -99,6 +104,7 @@ def test_for_complete_logging(weather, config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging_floating(weather): + sim = FloatingSubstationInstallation(config_floating, weather=weather) sim.run() @@ -112,6 +118,7 @@ def test_for_complete_logging_floating(weather): def test_kwargs(): + sim = OffshoreSubstationInstallation(config_single) sim.run() baseline = sim.total_phase_time @@ -132,6 +139,7 @@ def test_kwargs(): failed = [] for kw in keywords: + default = pt[kw] if kw == "mono_drive_rate": @@ -163,6 +171,7 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): + base = deepcopy(config_single) base["install_phases"] = ["OffshoreSubstationInstallation"] @@ -186,6 +195,7 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] if kw == "mono_drive_rate": diff --git a/tests/phases/install/oss_install/test_oss_tasks.py b/tests/phases/install/oss_install/test_oss_tasks.py index 758df489..67a28c40 100644 --- a/tests/phases/install/oss_install/test_oss_tasks.py +++ b/tests/phases/install/oss_install/test_oss_tasks.py @@ -9,6 +9,7 @@ import pytest + from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.oss_install.common import ( lift_topside, @@ -24,6 +25,7 @@ ], ) def test_task(env, wtiv, task, log, args): + env.register(wtiv) wtiv.initialize(mobilize=False) @@ -42,6 +44,7 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): + env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/install/quayside_assembly_tow/test_common.py b/tests/phases/install/quayside_assembly_tow/test_common.py index b9a08bac..00fa2b4e 100644 --- a/tests/phases/install/quayside_assembly_tow/test_common.py +++ b/tests/phases/install/quayside_assembly_tow/test_common.py @@ -8,6 +8,7 @@ import pandas as pd import pytest + from ORBIT.core import WetStorage from ORBIT.phases.install.quayside_assembly_tow.common import ( TurbineAssemblyLine, @@ -27,6 +28,7 @@ ], ) def test_SubstructureAssemblyLine(env, num, assigned, expected): + _assigned = len(assigned) storage = WetStorage(env, capacity=float("inf")) @@ -52,6 +54,7 @@ def test_SubstructureAssemblyLine(env, num, assigned, expected): ], ) def test_TurbineAssemblyLine(env, num, assigned): + _assigned = len(assigned) feed = WetStorage(env, capacity=float("inf")) target = WetStorage(env, capacity=float("inf")) @@ -89,6 +92,7 @@ def test_TurbineAssemblyLine(env, num, assigned): ], ) def test_Sub_to_Turbine_assembly_interaction(env, sub_lines, turb_lines): + num_turbines = 50 assigned = [1] * num_turbines diff --git a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py index 25d7db92..dafad84b 100644 --- a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py +++ b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py @@ -8,6 +8,7 @@ import pandas as pd import pytest + from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import GravityBasedInstallation @@ -17,6 +18,7 @@ def test_simulation_setup(): + sim = GravityBasedInstallation(config) assert sim.config == config assert sim.env @@ -39,6 +41,7 @@ def test_simulation_setup(): ) @pytest.mark.parametrize("config", (config, no_supply)) def test_for_complete_logging(weather, config): + sim = GravityBasedInstallation(config, weather=weather) sim.run() diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index 72619642..e1fc0af7 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -8,6 +8,7 @@ import pandas as pd import pytest + from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import MooredSubInstallation @@ -17,6 +18,7 @@ def test_simulation_setup(): + sim = MooredSubInstallation(config) assert sim.config == config assert sim.env @@ -39,6 +41,7 @@ def test_simulation_setup(): ) @pytest.mark.parametrize("config", (config, no_supply)) def test_for_complete_logging(weather, config): + sim = MooredSubInstallation(config, weather=weather) sim.run() diff --git a/tests/phases/install/scour_protection_install/test_scour_protection.py b/tests/phases/install/scour_protection_install/test_scour_protection.py index ae1c9313..85e372c7 100644 --- a/tests/phases/install/scour_protection_install/test_scour_protection.py +++ b/tests/phases/install/scour_protection_install/test_scour_protection.py @@ -12,6 +12,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -50,6 +51,7 @@ def test_full_run_logging(weather): def test_kwargs(): + sim = ScourProtectionInstallation(config) sim.run() baseline = sim.total_phase_time @@ -59,6 +61,7 @@ def test_kwargs(): failed = [] for kw in keywords: + default = pt[kw] kwargs = {kw: default + 2} @@ -80,6 +83,7 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): + base = deepcopy(config) base["install_phases"] = ["ScourProtectionInstallation"] @@ -92,6 +96,7 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] processes = {kw: default + 2} diff --git a/tests/phases/install/test_install_phase.py b/tests/phases/install/test_install_phase.py index cba9802c..6b600eb2 100644 --- a/tests/phases/install/test_install_phase.py +++ b/tests/phases/install/test_install_phase.py @@ -9,6 +9,7 @@ import pandas as pd import pytest from marmot import Environment + from ORBIT.phases.install import InstallPhase @@ -44,6 +45,7 @@ def setup_simulation(self): def test_abstract_methods(): + with pytest.raises(TypeError): install = BadInstallPhase(base_config) @@ -51,6 +53,7 @@ def test_abstract_methods(): def test_run(): + sim = SampleInstallPhase(base_config) sim.run(until=10) diff --git a/tests/phases/install/turbine_install/test_turbine_install.py b/tests/phases/install/turbine_install/test_turbine_install.py index 0592999a..aac2de9f 100644 --- a/tests/phases/install/turbine_install/test_turbine_install.py +++ b/tests/phases/install/turbine_install/test_turbine_install.py @@ -10,6 +10,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -32,6 +33,7 @@ ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_simulation_setup(config): + sim = TurbineInstallation(config) assert sim.config == config assert sim.env @@ -54,6 +56,7 @@ def test_simulation_setup(config): ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_vessel_creation(config): + sim = TurbineInstallation(config) assert sim.wtiv assert sim.wtiv.crane @@ -77,6 +80,7 @@ def test_vessel_creation(config): "config, expected", [(config_wtiv, 72), (config_long_mobilize, 14 * 24)] ) def test_vessel_mobilize(config, expected): + sim = TurbineInstallation(config) assert sim.wtiv @@ -93,6 +97,7 @@ def test_vessel_mobilize(config, expected): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(weather, config): + sim = TurbineInstallation(config, weather=weather) sim.run() @@ -115,6 +120,7 @@ def test_for_complete_logging(weather, config): ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) def test_for_complete_installation(config): + sim = TurbineInstallation(config) sim.run() @@ -125,6 +131,7 @@ def test_for_complete_installation(config): def test_kwargs(): + sim = TurbineInstallation(config_wtiv) sim.run() baseline = sim.total_phase_time @@ -146,6 +153,7 @@ def test_kwargs(): failed = [] for kw in keywords: + default = pt[kw] kwargs = {kw: default + 2} @@ -167,6 +175,7 @@ def test_kwargs(): def test_kwargs_in_ProjectManager(): + base = deepcopy(config_wtiv) base["install_phases"] = ["TurbineInstallation"] @@ -191,6 +200,7 @@ def test_kwargs_in_ProjectManager(): failed = [] for kw in keywords: + default = pt[kw] processes = {kw: default + 2} @@ -215,6 +225,7 @@ def test_kwargs_in_ProjectManager(): def test_multiple_tower_sections(): + sim = TurbineInstallation(config_wtiv) sim.run() baseline = len( @@ -234,6 +245,7 @@ def test_multiple_tower_sections(): df = pd.DataFrame(sim.env.actions) for vessel in df["agent"].unique(): + vl = df[df["agent"] == vessel].copy() vl = vl.assign(shift=(vl["time"] - vl["time"].shift(1))) diff --git a/tests/phases/install/turbine_install/test_turbine_tasks.py b/tests/phases/install/turbine_install/test_turbine_tasks.py index 2042f639..055da73d 100644 --- a/tests/phases/install/turbine_install/test_turbine_tasks.py +++ b/tests/phases/install/turbine_install/test_turbine_tasks.py @@ -9,6 +9,7 @@ import pytest + from ORBIT.core.exceptions import MissingComponent from ORBIT.phases.install.turbine_install.common import ( lift_nacelle, @@ -32,6 +33,7 @@ ], ) def test_task(env, wtiv, task, log, args): + env.register(wtiv) wtiv.initialize(mobilize=False) @@ -54,6 +56,7 @@ def test_task(env, wtiv, task, log, args): ], ) def test_task_fails(env, feeder, task, log, args): + env.register(feeder) feeder.initialize(mobilize=False) diff --git a/tests/phases/test_base.py b/tests/phases/test_base.py index 01e37b7b..209983ac 100644 --- a/tests/phases/test_base.py +++ b/tests/phases/test_base.py @@ -18,12 +18,14 @@ def test_good_config(): + config = deepcopy(expected_config) missing = BasePhase._check_keys(expected_config, config) assert len(missing) == 0 def test_missing_key(): + config = deepcopy(expected_config) _ = config.pop("param1") missing = BasePhase._check_keys(expected_config, config) @@ -31,6 +33,7 @@ def test_missing_key(): def test_optional(): + config = deepcopy(expected_config) _ = config["param2"].pop("param4") missing = BasePhase._check_keys(expected_config, config) @@ -38,6 +41,7 @@ def test_optional(): def test_variable_key(): + config = deepcopy(expected_config) _ = config.pop("param5 (variable)") @@ -46,6 +50,7 @@ def test_variable_key(): def test_optional_dict(): + config = deepcopy(expected_config) _ = config.pop("param6") diff --git a/tests/test_config_management.py b/tests/test_config_management.py index ffd84920..f635f271 100644 --- a/tests/test_config_management.py +++ b/tests/test_config_management.py @@ -7,6 +7,7 @@ import os import pytest + from ORBIT import ProjectManager, load_config, save_config from ORBIT.core.library import extract_library_specs @@ -14,6 +15,7 @@ def test_save_and_load_equality(tmp_yaml_del): + save_config(complete_project, "tmp.yaml", overwrite=True) new = load_config("tmp.yaml") @@ -21,6 +23,7 @@ def test_save_and_load_equality(tmp_yaml_del): def test_orbit_version_ProjectManager(): + config = ProjectManager.compile_input_dict( ["MonopileDesign", "MonopileInstallation"] ) diff --git a/tests/test_design_install_phase_interactions.py b/tests/test_design_install_phase_interactions.py index 656db0d8..059202fb 100644 --- a/tests/test_design_install_phase_interactions.py +++ b/tests/test_design_install_phase_interactions.py @@ -6,8 +6,9 @@ from copy import deepcopy -from ORBIT import ProjectManager from numpy.testing import assert_almost_equal + +from ORBIT import ProjectManager from ORBIT.core.library import extract_library_specs fixed = extract_library_specs("config", "complete_project") @@ -15,6 +16,7 @@ def test_fixed_phase_cost_passing(): + project = ProjectManager(fixed) project.run() @@ -45,6 +47,7 @@ def test_fixed_phase_cost_passing(): def test_floating_phase_cost_passing(): + project = ProjectManager(floating) project.run() diff --git a/tests/test_parametric.py b/tests/test_parametric.py index 5d33cfca..4d73da75 100644 --- a/tests/test_parametric.py +++ b/tests/test_parametric.py @@ -7,8 +7,9 @@ import pandas as pd import pytest -from ORBIT import ProjectManager, ParametricManager from benedict import benedict + +from ORBIT import ProjectManager, ParametricManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.phases.install import TurbineInstallation @@ -23,6 +24,7 @@ def test_for_equal_results(): + config = benedict(deepcopy(complete_project)) config["site.distance"] = 20 project = ProjectManager(config) @@ -35,6 +37,7 @@ def test_for_equal_results(): def test_weather(): + without = ParametricManager(complete_project, params, funcs) without.run() @@ -47,6 +50,7 @@ def test_weather(): def test_individual_phase(): + config = benedict(deepcopy(complete_project)) config["site.distance"] = 20 phase = TurbineInstallation(config) @@ -63,6 +67,7 @@ def test_individual_phase(): def test_bad_result_attribute(): + funcs = {"result": lambda phase: phase.nonexistent_result} parametric = ParametricManager( @@ -74,6 +79,7 @@ def test_bad_result_attribute(): def test_bad_result_structure(): + funcs = {"result": "bos_capex"} parametric = ParametricManager( @@ -85,6 +91,7 @@ def test_bad_result_structure(): def test_product_option(): + params = {"site.distance": [20, 40, 60], "site.depth": [20, 40, 60]} parametric = ParametricManager( diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 9cbf9ad3..7e62a225 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -8,9 +8,10 @@ import pandas as pd import pytest + from ORBIT import ProjectManager +from ORBIT.phases import InstallPhase, DesignPhase from tests.data import test_weather -from ORBIT.phases import DesignPhase, InstallPhase from ORBIT.manager import ProjectProgress from ORBIT.core.library import extract_library_specs from ORBIT.core.exceptions import ( @@ -25,10 +26,10 @@ config = extract_library_specs("config", "project_manager") complete_project = extract_library_specs("config", "complete_project") - ### Top Level @pytest.mark.parametrize("weather", (None, weather_df)) def test_complete_run(weather): + project = ProjectManager(config, weather=weather) project.run() @@ -46,9 +47,11 @@ def test_for_required_phase_structure(): """ for p in ProjectManager._install_phases: + assert isinstance(p.expected_config, dict) for p in ProjectManager._design_phases: + assert isinstance(p.expected_config, dict) assert isinstance(p.output_config, dict) @@ -127,6 +130,7 @@ class SpecificTurbineInstallation(InstallPhase): ] for test in tests: + i, expected = test response = TestProjectManager.find_key_match(i) @@ -139,11 +143,13 @@ class SpecificTurbineInstallation(InstallPhase): ] for f in fails: + assert TestProjectManager.find_key_match(f) is None ### Overlapping Install Phases def test_install_phase_start_parsing(): + config_mixed_starts = deepcopy(config) config_mixed_starts["install_phases"] = { "MonopileInstallation": 0, @@ -163,6 +169,7 @@ def test_install_phase_start_parsing(): def test_chained_dependencies(): + config_chained = deepcopy(config) config_chained["spi_vessel"] = "test_scour_protection_vessel" config_chained["scour_protection"] = { @@ -226,6 +233,7 @@ def test_index_starts(m_start, t_start): ], ) def test_start_dates_with_weather(m_start, t_start, expected): + config_with_defined_starts = deepcopy(config) config_with_defined_starts["install_phases"] = { "MonopileInstallation": m_start, @@ -275,6 +283,7 @@ def test_duplicate_phase_definitions(): def test_custom_install_phases(): + # Not a subclass class CustomInstallPhase: pass @@ -296,6 +305,7 @@ class MonopileInstallation(InstallPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileInstallation) + # Bad name format class MonopileInstallation_Custom(InstallPhase): pass @@ -308,13 +318,11 @@ class CustomInstallPhase(InstallPhase): pass ProjectManager.register_install_phase(CustomInstallPhase) - assert ( - ProjectManager.find_key_match("CustomInstallPhase") - == CustomInstallPhase - ) + assert ProjectManager.find_key_match("CustomInstallPhase") == CustomInstallPhase def test_custom_design_phases(): + # Not a subclass class CustomDesignPhase: pass @@ -336,6 +344,7 @@ class MonopileDesign(DesignPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileDesign) + # Bad name format class MonopileDesign_Custom(DesignPhase): pass @@ -348,13 +357,11 @@ class CustomDesignPhase(DesignPhase): pass ProjectManager.register_design_phase(CustomDesignPhase) - assert ( - ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase - ) - + assert ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase ### Design Phase Interactions def test_design_phases(): + config_with_design = deepcopy(config) # Add MonopileDesign @@ -379,6 +386,7 @@ def test_design_phases(): ### Outputs def test_resolve_project_capacity(): + # Missing turbine rating config1 = {"plant": {"capacity": 600, "num_turbines": 40}} @@ -459,6 +467,7 @@ def test_resolve_project_capacity(): ### Exceptions def test_incomplete_config(): + incomplete_config = deepcopy(config) _ = incomplete_config["site"].pop("depth") @@ -468,6 +477,7 @@ def test_incomplete_config(): def test_wrong_phases(): + wrong_phases = deepcopy(config) wrong_phases["install_phases"].append("IncorrectPhaseName") @@ -477,6 +487,7 @@ def test_wrong_phases(): def test_bad_dates(): + bad_dates = deepcopy(config) bad_dates["install_phases"] = { "MonopileInstallation": "03/01/2015", @@ -489,6 +500,7 @@ def test_bad_dates(): def test_no_defined_start(): + missing_start = deepcopy(config) missing_start["install_phases"] = { "MonopileInstallation": ("TurbineInstallation", 0.1), @@ -501,6 +513,7 @@ def test_no_defined_start(): def test_circular_dependencies(): + circular_deps = deepcopy(config) circular_deps["spi_vessel"] = "test_scour_protection_vessel" circular_deps["scour_protection"] = { @@ -519,6 +532,7 @@ def test_circular_dependencies(): def test_dependent_phase_ordering(): + wrong_order = deepcopy(config) wrong_order["spi_vessel"] = "test_scour_protection_vessel" wrong_order["scour_protection"] = { @@ -538,6 +552,7 @@ def test_dependent_phase_ordering(): def test_ProjectProgress(): + data = [ ("Export System", 10), ("Offshore Substation", 20), @@ -577,6 +592,7 @@ def test_ProjectProgress(): def test_ProjectProgress_with_incomplete_project(): + project = ProjectManager(config) project.run() @@ -591,6 +607,7 @@ def test_ProjectProgress_with_incomplete_project(): def test_ProjectProgress_with_complete_project(): + project = ProjectManager(complete_project) project.run() @@ -616,6 +633,7 @@ def test_ProjectProgress_with_complete_project(): def test_monthly_expenses(): + project = ProjectManager(complete_project) project.run() _ = project.monthly_expenses @@ -631,6 +649,7 @@ def test_monthly_expenses(): def test_monthly_revenue(): + project = ProjectManager(complete_project) project.run() _ = project.monthly_revenue @@ -647,6 +666,7 @@ def test_monthly_revenue(): def test_cash_flow(): + project = ProjectManager(complete_project) project.run() _ = project.cash_flow @@ -664,6 +684,7 @@ def test_cash_flow(): def test_npv(): + project = ProjectManager(complete_project) project.run() baseline = project.npv @@ -700,6 +721,7 @@ def test_npv(): def test_soft_costs(): + project = ProjectManager(complete_project) baseline = project.soft_capex @@ -735,6 +757,7 @@ def test_soft_costs(): def test_project_costs(): + project = ProjectManager(complete_project) baseline = project.project_capex @@ -760,6 +783,7 @@ def test_project_costs(): def test_capex_categories(): + project = ProjectManager(complete_project) project.run() baseline = project.capex_breakdown diff --git a/versioneer.py b/versioneer.py index 96361d2f..64fea1c8 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,3 +1,4 @@ + # Version: 0.18 """The Versioneer - like a rocketeer, but for versions. @@ -276,18 +277,16 @@ """ from __future__ import print_function - -import os -import re -import sys -import json -import errno -import subprocess - try: import configparser except ImportError: import ConfigParser as configparser +import errno +import json +import os +import re +import subprocess +import sys class VersioneerConfig: @@ -309,13 +308,11 @@ def get_root(): setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ( - "Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND')." - ) + err = ("Versioneer was unable to run the project root directory. " + "Versioneer requires setup.py to be executed from " + "its immediate directory (like 'python setup.py COMMAND'), " + "or in a way that lets it use sys.argv[0] to find the root " + "(like 'python path/to/setup.py COMMAND').") raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools @@ -328,10 +325,8 @@ def get_root(): me_dir = os.path.normcase(os.path.splitext(me)[0]) vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) if me_dir != vsr_dir: - print( - "Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py) - ) + print("Warning: build in %s is using versioneer.py from %s" + % (os.path.dirname(me), versioneer_py)) except NameError: pass return root @@ -353,7 +348,6 @@ def get(parser, name): if parser.has_option("versioneer", name): return parser.get("versioneer", name) return None - cfg = VersioneerConfig() cfg.VCS = VCS cfg.style = get(parser, "style") or "" @@ -378,20 +372,17 @@ class NotThisMethod(Exception): def register_vcs_handler(vcs, method): # decorator """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f - return decorate -def run_command( - commands, args, cwd=None, verbose=False, hide_stderr=False, env=None -): +def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, + env=None): """Call the given command(s).""" assert isinstance(commands, list) p = None @@ -399,13 +390,10 @@ def run_command( try: dispcmd = str([c] + args) # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen( - [c] + args, - cwd=cwd, - env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr else None), - ) + p = subprocess.Popen([c] + args, cwd=cwd, env=env, + stdout=subprocess.PIPE, + stderr=(subprocess.PIPE if hide_stderr + else None)) break except EnvironmentError: e = sys.exc_info()[1] @@ -430,9 +418,7 @@ def run_command( return stdout, p.returncode -LONG_VERSION_PY[ - "git" -] = ''' +LONG_VERSION_PY['git'] = ''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build @@ -1007,7 +993,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " - tags = set([r[len(TAG) :] for r in refs if r.startswith(TAG)]) + tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d @@ -1016,7 +1002,7 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r"\d", r)]) + tags = set([r for r in refs if re.search(r'\d', r)]) if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: @@ -1024,26 +1010,19 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): - r = ref[len(tag_prefix) :] + r = ref[len(tag_prefix):] if verbose: print("picking %s" % r) - return { - "version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": None, - "date": date, - } + return {"version": r, + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": None, + "date": date} # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") - return { - "version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, - "error": "no suitable tags", - "date": None, - } + return {"version": "0+unknown", + "full-revisionid": keywords["full"].strip(), + "dirty": False, "error": "no suitable tags", "date": None} @register_vcs_handler("git", "pieces_from_vcs") @@ -1058,9 +1037,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - out, rc = run_command( - GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True - ) + out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, + hide_stderr=True) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -1068,19 +1046,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command( - GITS, - [ - "describe", - "--tags", - "--dirty", - "--always", - "--long", - "--match", - "%s*" % tag_prefix, - ], - cwd=root, - ) + describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", + "--always", "--long", + "--match", "%s*" % tag_prefix], + cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -1103,18 +1072,17 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: - git_describe = git_describe[: git_describe.rindex("-dirty")] + git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX - mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) + mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ( - "unable to parse git-describe output: '%s'" % describe_out - ) + pieces["error"] = ("unable to parse git-describe output: '%s'" + % describe_out) return pieces # tag @@ -1123,12 +1091,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) - pieces["error"] = "tag '%s' doesn't start with prefix '%s'" % ( - full_tag, - tag_prefix, - ) + pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" + % (full_tag, tag_prefix)) return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix) :] + pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) @@ -1139,15 +1105,13 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = run_command( - GITS, ["rev-list", "HEAD", "--count"], cwd=root - ) + count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], + cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[ - 0 - ].strip() + date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], + cwd=root)[0].strip() pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces @@ -1203,22 +1167,16 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): for i in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): - return { - "version": dirname[len(parentdir_prefix) :], - "full-revisionid": None, - "dirty": False, - "error": None, - "date": None, - } + return {"version": dirname[len(parentdir_prefix):], + "full-revisionid": None, + "dirty": False, "error": None, "date": None} else: rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: - print( - "Tried directories %s but none started with prefix %s" - % (str(rootdirs), parentdir_prefix) - ) + print("Tried directories %s but none started with prefix %s" % + (str(rootdirs), parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @@ -1247,17 +1205,11 @@ def versions_from_file(filename): contents = f.read() except EnvironmentError: raise NotThisMethod("unable to read _version.py") - mo = re.search( - r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, - re.M | re.S, - ) + mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", + contents, re.M | re.S) if not mo: - mo = re.search( - r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, - re.M | re.S, - ) + mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", + contents, re.M | re.S) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) @@ -1266,9 +1218,8 @@ def versions_from_file(filename): def write_to_version_file(filename, versions): """Write the given version number to the given _version.py file.""" os.unlink(filename) - contents = json.dumps( - versions, sort_keys=True, indent=1, separators=(",", ": ") - ) + contents = json.dumps(versions, sort_keys=True, + indent=1, separators=(",", ": ")) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) @@ -1300,7 +1251,8 @@ def render_pep440(pieces): rendered += ".dirty" else: # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) + rendered = "0+untagged.%d.g%s" % (pieces["distance"], + pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered @@ -1414,13 +1366,11 @@ def render_git_describe_long(pieces): def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: - return { - "version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None, - } + return {"version": "unknown", + "full-revisionid": pieces.get("long"), + "dirty": None, + "error": pieces["error"], + "date": None} if not style or style == "default": style = "pep440" # the default @@ -1440,13 +1390,9 @@ def render(pieces, style): else: raise ValueError("unknown style '%s'" % style) - return { - "version": rendered, - "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], - "error": None, - "date": pieces.get("date"), - } + return {"version": rendered, "full-revisionid": pieces["long"], + "dirty": pieces["dirty"], "error": None, + "date": pieces.get("date")} class VersioneerBadRootError(Exception): @@ -1469,9 +1415,8 @@ def get_versions(verbose=False): handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose - assert ( - cfg.versionfile_source is not None - ), "please set versioneer.versionfile_source" + assert cfg.versionfile_source is not None, \ + "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) @@ -1525,13 +1470,9 @@ def get_versions(verbose=False): if verbose: print("unable to compute version") - return { - "version": "0+unknown", - "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", - "date": None, - } + return {"version": "0+unknown", "full-revisionid": None, + "dirty": None, "error": "unable to compute version", + "date": None} def get_version(): @@ -1580,7 +1521,6 @@ def run(self): print(" date: %s" % vers.get("date")) if vers["error"]: print(" error: %s" % vers["error"]) - cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools @@ -1613,17 +1553,14 @@ def run(self): # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: - target_versionfile = os.path.join( - self.build_lib, cfg.versionfile_build - ) + target_versionfile = os.path.join(self.build_lib, + cfg.versionfile_build) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) - cmds["build_py"] = cmd_build_py if "cx_Freeze" in sys.modules: # cx_freeze enabled? from cx_Freeze.dist import build_exe as _build_exe - # nczeczulin reports that py2exe won't like the pep440-style string # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. # setup(console=[{ @@ -1644,21 +1581,17 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - + f.write(LONG % + {"DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + }) cmds["build_exe"] = cmd_build_exe del cmds["build_py"] - if "py2exe" in sys.modules: # py2exe enabled? + if 'py2exe' in sys.modules: # py2exe enabled? try: from py2exe.distutils_buildexe import py2exe as _py2exe # py3 except ImportError: @@ -1677,17 +1610,13 @@ def run(self): os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - + f.write(LONG % + {"DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + }) cmds["py2exe"] = cmd_py2exe # we override different "sdist" commands for both environments @@ -1714,10 +1643,8 @@ def make_release_tree(self, base_dir, files): # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) - write_to_version_file( - target_versionfile, self._versioneer_generated_versions - ) - + write_to_version_file(target_versionfile, + self._versioneer_generated_versions) cmds["sdist"] = cmd_sdist return cmds @@ -1772,15 +1699,11 @@ def do_setup(): root = get_root() try: cfg = get_config_from_root(root) - except ( - EnvironmentError, - configparser.NoSectionError, - configparser.NoOptionError, - ) as e: + except (EnvironmentError, configparser.NoSectionError, + configparser.NoOptionError) as e: if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print( - "Adding sample versioneer config to setup.cfg", file=sys.stderr - ) + print("Adding sample versioneer config to setup.cfg", + file=sys.stderr) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) @@ -1789,18 +1712,15 @@ def do_setup(): print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] - f.write( - LONG - % { - "DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - } - ) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") + f.write(LONG % {"DOLLAR": "$", + "STYLE": cfg.style, + "TAG_PREFIX": cfg.tag_prefix, + "PARENTDIR_PREFIX": cfg.parentdir_prefix, + "VERSIONFILE_SOURCE": cfg.versionfile_source, + }) + + ipy = os.path.join(os.path.dirname(cfg.versionfile_source), + "__init__.py") if os.path.exists(ipy): try: with open(ipy, "r") as f: @@ -1842,10 +1762,8 @@ def do_setup(): else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: - print( - " appending versionfile_source ('%s') to MANIFEST.in" - % cfg.versionfile_source - ) + print(" appending versionfile_source ('%s') to MANIFEST.in" % + cfg.versionfile_source) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: From 70a9b82c17111a856d23b0f15fb62493b2c6f903 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 5 Apr 2023 09:14:02 -0600 Subject: [PATCH 067/240] 275 kV costs, remove double count in system_capex --- ORBIT/phases/install/oss_install/standard.py | 2 +- library/cables/XLPE_1200mm_275kV.yaml | 2 +- library/cables/XLPE_1600mm_275kV.yaml | 2 +- library/cables/XLPE_1900mm_275kV.yaml | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index 04038af9..4131214e 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -80,7 +80,7 @@ def __init__(self, config, weather=None, **kwargs): def system_capex(self): """Returns procurement CapEx of the offshore substations.""" - return self.config["num_substations"] * ( + return ( self.config["offshore_substation_topside"]["unit_cost"] + self.config["offshore_substation_substructure"]["unit_cost"] ) diff --git a/library/cables/XLPE_1200mm_275kV.yaml b/library/cables/XLPE_1200mm_275kV.yaml index 84fed976..3ec31c86 100644 --- a/library/cables/XLPE_1200mm_275kV.yaml +++ b/library/cables/XLPE_1200mm_275kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.026 # ohm/km capacitance: 196 # nF/km conductor_size: 1200 # mm^2 -cost_per_km: 0 # $ +cost_per_km: 1300000 # $ current_capacity: 547 # A # ESTIMATE inductance: 0.37 # mH/km linear_density: 148 # t/km diff --git a/library/cables/XLPE_1600mm_275kV.yaml b/library/cables/XLPE_1600mm_275kV.yaml index 2a1f97cf..6a28b149 100644 --- a/library/cables/XLPE_1600mm_275kV.yaml +++ b/library/cables/XLPE_1600mm_275kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.022 # ohm/km capacitance: 221 # nF/km conductor_size: 1600 # mm^2 -cost_per_km: 0 # $ +cost_per_km: 1500000 # $ current_capacity: 730 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 176 # t/km diff --git a/library/cables/XLPE_1900mm_275kV.yaml b/library/cables/XLPE_1900mm_275kV.yaml index 43c2a1eb..3ddd1a3e 100644 --- a/library/cables/XLPE_1900mm_275kV.yaml +++ b/library/cables/XLPE_1900mm_275kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.020 # ohm/km capacitance: 224 # nF/km conductor_size: 1900 # mm^2 -cost_per_km: 0 # $ +cost_per_km: 1700000 # $ current_capacity: 910 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 185 # t/km From eacaf12a434943cd554a76a7278d38ee0723dedb Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Thu, 6 Apr 2023 09:39:09 -0600 Subject: [PATCH 068/240] revise substation calc (cost is per oss now) --- ORBIT/phases/design/electrical_export.py | 14 +++++++------- ORBIT/phases/install/oss_install/standard.py | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 51a8c7f6..ee78b28e 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -274,9 +274,9 @@ def calc_crossing_cost(self): @property def total_substation_cost(self): - return ( - self.topside_cost + self.substructure_cost + self.substation_cost - ) + return (self.topside_cost + + self.substructure_cost + + self.substation_cost) def calc_num_substations(self): """Computes number of substations""" @@ -307,7 +307,7 @@ def substation_cost(self): + self.dc_breaker_cost + self.ancillary_system_cost + self.land_assembly_cost - ) + ) / self.num_substations def calc_mpt_cost(self): """Computes transformer cost""" @@ -360,7 +360,7 @@ def calc_dc_breaker_cost(self): else: num_dc_breaker = self.num_cables self.dc_breaker_cost = num_dc_breaker * self._design.get( - "dc_breaker_cost", 4000000 + "dc_breaker_cost", 40000000 ) # 4e6 def calc_ancillary_system_cost(self): @@ -435,7 +435,7 @@ def calc_substructure_mass_and_cost(self): self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate - ) * self.num_substations + ) self.substructure_mass = substructure_mass + substructure_pile_mass @@ -484,7 +484,7 @@ def calc_topside_mass_and_cost(self): ) self.topside_cost = ( self.topside_mass * topside_fab_cost_rate + topside_design_cost - ) * self.num_substations + ) def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index 4131214e..43bd62af 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -80,7 +80,7 @@ def __init__(self, config, weather=None, **kwargs): def system_capex(self): """Returns procurement CapEx of the offshore substations.""" - return ( + return self.num_substations * ( self.config["offshore_substation_topside"]["unit_cost"] + self.config["offshore_substation_substructure"]["unit_cost"] ) From a604f5b845090fca748ee63df13ea537c6f020ee Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Fri, 7 Apr 2023 09:28:45 -0600 Subject: [PATCH 069/240] Added pathway for onshore construction cost into export system install. --- ORBIT/phases/design/electrical_export.py | 2 ++ ORBIT/phases/install/cable_install/export.py | 10 +++++++--- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index ee78b28e..5f7dfc92 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -495,3 +495,5 @@ def calc_onshore_cost(self): + self.mpt_cost + self.switchgear_cost ) + + self._outputs["export_system"]["onshore_construction_cost"] = self.onshore_cost diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index f1ee11a2..87d96537 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -52,6 +52,8 @@ class ExportCableInstallation(InstallPhase): }, "interconnection_distance": "km (optional); default: 3km", "interconnection_voltage": "kV (optional); default: 345kV", + "onshore_construction_cost": "$, (optional)", + "onshore_construction_time": "h, (optional)" }, } @@ -146,14 +148,16 @@ def onshore_construction(self, **kwargs): ---------- construction_time : int | float Amount of time onshore construction takes. - Default: 48h + Default: 0h construction_rate : int | float Day rate of onshore construction. Default: 50000 USD/day """ - construction_time = kwargs.get("onshore_construction_time", 0.0) - construction_cost = self.calculate_onshore_transmission_cost(**kwargs) + construction_time = self.config["export_system"].get("onshore_construction_time", 0.0) + construction_cost = self.config["export_system"].get("onshore_construction_cost", None) + if construction_cost is None: + construction_cost = self.calculate_onshore_transmission_cost(**kwargs) if construction_time: _ = self.env.timeout(construction_time) From 4f18e7b3794af12af27ffe026b453fe8c8215267 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Fri, 7 Apr 2023 09:33:18 -0600 Subject: [PATCH 070/240] removed onshore_construction_time from kwargs tests. --- tests/phases/install/cable_install/test_export_install.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 80889fb1..12f0c1dc 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -135,7 +135,6 @@ def test_kwargs_for_export_install(): baseline = sim.total_phase_time keywords = [ - "onshore_construction_time", "cable_load_time", "site_position_time", "cable_prep_time", @@ -199,7 +198,6 @@ def test_kwargs_for_export_install_in_ProjectManager(): baseline = project.phase_times["ExportCableInstallation"] keywords = [ - "onshore_construction_time", "cable_load_time", "site_position_time", "cable_prep_time", From f66affc21aa4db4a0b0e66c702ce23da021807c8 Mon Sep 17 00:00:00 2001 From: asharma Date: Sat, 8 Apr 2023 18:53:33 -0600 Subject: [PATCH 071/240] improve delay message and formatting --- ORBIT/phases/install/oss_install/floating.py | 41 +++++++++++--------- 1 file changed, 23 insertions(+), 18 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 88f40dae..3d4e551b 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -6,11 +6,10 @@ __email__ = "jake.nunemaker@nrel.gov" -from marmot import Agent, process, le -from marmot._exceptions import AgentNotRegistered - +from marmot import Agent, le, process from ORBIT.core import WetStorage from ORBIT.core.logic import position_onsite +from marmot._exceptions import AgentNotRegistered from ORBIT.phases.install import InstallPhase from ORBIT.phases.install.mooring_install.mooring import ( install_mooring_line, @@ -41,15 +40,19 @@ class FloatingSubstationInstallation(InstallPhase): "type": "Floating", "takt_time": "int | float (optional, default: 0)", "unit_cost": "USD", - #"mooring_cost": "USD", - "towing_speed": "int | float (optional, default: 6 km/h)" - }, - "mooring_system": { - #"system_cost": "USD", "}, # system cost is for all moorings in the whole farm, so you dont want this to be added to each substation - "num_lines", "int", - "line_cost", "USD", - "anchor_cost", "USD"} - } + # "mooring_cost": "USD", + "towing_speed": "int | float (optional, default: 6 km/h)", + }, + "mooring_system": { + # "system_cost": "USD", "}, # system cost is for all moorings in the whole farm, so you dont want this to be added to each substation + "num_lines", + "int", + "line_cost", + "USD", + "anchor_cost", + "USD", + }, + } def __init__(self, config, weather=None, **kwargs): """ @@ -98,11 +101,15 @@ def system_capex(self): num_mooring_lines = self.config["mooring_system"]["num_lines"] line_cost = self.config["mooring_system"]["line_cost"] anchor_cost = self.config["mooring_system"]["anchor_cost"] - mooring_system_for_each_oss = num_mooring_lines*(line_cost + anchor_cost) + mooring_system_for_each_oss = num_mooring_lines * ( + line_cost + anchor_cost + ) # print('topside: ' + str(topside)) # print('oss substructure' + str(substructure)) # print('mooring system' + str(mooring_system_for_each_oss)) - return self.num_substations * (topside + substructure + mooring_system_for_each_oss) + return self.num_substations * ( + topside + substructure + mooring_system_for_each_oss + ) def initialize_substructure_production(self): """ @@ -153,7 +160,6 @@ def initialize_installation_vessel(self): @property def detailed_output(self): - return {} @@ -184,13 +190,12 @@ def install_floating_substations( travel_time = distance / towing_speed for _ in range(number): - start = vessel.env.now yield feed.get() delay = vessel.env.now - start if delay > 0: vessel.submit_action_log( - "Delay: Waiting on Completed Assembly", delay + "Delay: Waiting on Substation Assembly", delay ) yield vessel.task( @@ -205,7 +210,7 @@ def install_floating_substations( constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) - for _ in range (3): + for _ in range(3): yield perform_mooring_site_survey(vessel) yield install_mooring_anchor(vessel, depth, "Suction Pile") yield install_mooring_line(vessel, depth) From 9684fec263afb41bd7a7ac1dc0fa777ef5a57fe3 Mon Sep 17 00:00:00 2001 From: asharma Date: Sat, 8 Apr 2023 18:58:09 -0600 Subject: [PATCH 072/240] use user-defined wave height and wind speed limits --- .../install/quayside_assembly_tow/common.py | 12 +++++++++- .../install/quayside_assembly_tow/moored.py | 24 +++++++++++++------ library/vessels/example_ahts_vessel.yaml | 6 ++--- library/vessels/example_towing_vessel.yaml | 4 ++-- 4 files changed, 33 insertions(+), 13 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 49533caa..ada96e21 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -7,7 +7,7 @@ __email__ = "jake.nunemaker@nrel.gov" -from marmot import Agent, le, process, false +from marmot import Agent, le, false, process from marmot._exceptions import AgentNotRegistered @@ -328,12 +328,22 @@ def __init__(self, vessel_specs, ahts_vessel_specs=None, num=1): self._specs = vessel_specs self.day_rate_towing = self._specs["vessel_specs"]["day_rate"] self.day_rate_anchor = 0.0 + self.max_waveheight = self._specs["transport_specs"]["max_waveheight"] + self.max_windspeed = self._specs["transport_specs"]["max_windspeed"] self.transit_speed = self._specs["transport_specs"]["transit_speed"] if ahts_vessel_specs is not None: self.day_rate_anchor = ahts_vessel_specs["vessel_specs"][ "day_rate" ] + self.max_waveheight = min( + vessel_specs["transport_specs"]["max_waveheight"], + ahts_vessel_specs["transport_specs"]["max_waveheight"], + ) + self.max_windspeed = min( + vessel_specs["transport_specs"]["max_windspeed"], + ahts_vessel_specs["transport_specs"]["max_windspeed"], + ) self.transit_speed = min( vessel_specs["transport_specs"]["transit_speed"], ahts_vessel_specs["transport_specs"]["transit_speed"], diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 561df3a9..54fbfe39 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -8,7 +8,6 @@ import simpy from marmot import le, process - from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -299,10 +298,10 @@ def towing_group_actions( Distance from port to site. towing_vessels : int Number of vessels to use for towing to site. + ahts_vessels : int + Number of anchor handling tug vessels. towing_speed : int | float - Configured towing speed (km/h) - num_substructures : int - Number of substructures to be installed corresponding to number of turbines + Configured towing speed (km/h). """ towing_time = distance / towing_speed @@ -314,7 +313,7 @@ def towing_group_actions( if delay > 0: group.submit_action_log( - "Delay: No Completed Assemblies Available", + "Delay: No Completed Turbine Assemblies", delay, num_vessels=towing_vessels, num_ahts_vessels=ahts_vessels, @@ -325,7 +324,10 @@ def towing_group_actions( 6, num_vessels=towing_vessels, num_ahts_vessels=ahts_vessels, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, + constraints={ + "windspeed": le(group.max_windspeed), + "waveheight": le(group.max_waveheight), + }, ) yield group.group_task( @@ -333,7 +335,10 @@ def towing_group_actions( towing_time, num_vessels=towing_vessels, num_ahts_vessels=ahts_vessels, - constraints={"windspeed": le(15), "waveheight": le(2.5)}, + constraints={ + "windspeed": le(group.max_windspeed), + "waveheight": le(group.max_waveheight), + }, ) # At Site @@ -376,4 +381,9 @@ def towing_group_actions( transit_time, num_vessels=towing_vessels, num_ahts_vessels=ahts_vessels, + suspendable=True, + constraints={ + "windspeed": le(group.max_windspeed), + "waveheight": le(group.max_waveheight), + }, ) diff --git a/library/vessels/example_ahts_vessel.yaml b/library/vessels/example_ahts_vessel.yaml index 28023f85..338152ac 100644 --- a/library/vessels/example_ahts_vessel.yaml +++ b/library/vessels/example_ahts_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: - max_waveheight: 2.5 # m - max_windspeed: 20 # m/s + max_waveheight: 3.0 # m + max_windspeed: 15 # m/s transit_speed: 6 # km/h vessel_specs: - day_rate: 100000 # USD/day + day_rate: 100000 # USD/day diff --git a/library/vessels/example_towing_vessel.yaml b/library/vessels/example_towing_vessel.yaml index 5aa4bf58..c4de57e5 100644 --- a/library/vessels/example_towing_vessel.yaml +++ b/library/vessels/example_towing_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: - max_waveheight: 2.5 # m - max_windspeed: 20 # m/s + max_waveheight: 3.0 # m + max_windspeed: 15 # m/s transit_speed: 6 # km/h vessel_specs: day_rate: 30000 # USD/day From 25fafaf2a9a2eaf8d1b7fe2aa8f194eecc792141 Mon Sep 17 00:00:00 2001 From: Shields Date: Fri, 14 Apr 2023 14:05:17 -0600 Subject: [PATCH 073/240] Added dynamic cables (20% cost adder), cable lay/bury times, and cable lay vessel day rate --- ORBIT/core/defaults/process_times.yaml | 6 +++--- library/cables/HVDC_2000mm_320kV_dynamic.yaml | 11 +++++++++++ library/cables/XLPE_1000m_220kV_dynamic.yaml | 10 ++++++++++ library/cables/XLPE_185mm_66kV_dynamic.yaml | 9 +++++++++ library/cables/XLPE_500mm_132kV.yaml | 2 +- library/cables/XLPE_500mm_132kV_dynamic.yaml | 10 ++++++++++ library/cables/XLPE_630mm_66kV_dynamic.yaml | 11 +++++++++++ library/vessels/example_cable_lay_vessel.yaml | 2 +- 8 files changed, 56 insertions(+), 5 deletions(-) create mode 100644 library/cables/HVDC_2000mm_320kV_dynamic.yaml create mode 100644 library/cables/XLPE_1000m_220kV_dynamic.yaml create mode 100644 library/cables/XLPE_185mm_66kV_dynamic.yaml create mode 100644 library/cables/XLPE_500mm_132kV_dynamic.yaml create mode 100644 library/cables/XLPE_630mm_66kV_dynamic.yaml diff --git a/ORBIT/core/defaults/process_times.yaml b/ORBIT/core/defaults/process_times.yaml index c1b94b26..f8a3a1d3 100644 --- a/ORBIT/core/defaults/process_times.yaml +++ b/ORBIT/core/defaults/process_times.yaml @@ -13,9 +13,9 @@ "cable_lower_time": 1 # hr "cable_pull_in_time": 5.5 # hr "cable_termination_time": 5.5 # hr -"cable_lay_speed": 1 # km/hr -"cable_lay_bury_speed": 0.3 # km/hr -"cable_bury_speed": 0.5 # km/hr +"cable_lay_speed": 0.4 # km/hr (10 km/day) +"cable_lay_bury_speed": 0.0625 # km/hr (1-2 km/day) +"cable_bury_speed": 0.4 # km/hr "cable_splice_time": 48 # hr "cable_raise_time": 0.5 # hr diff --git a/library/cables/HVDC_2000mm_320kV_dynamic.yaml b/library/cables/HVDC_2000mm_320kV_dynamic.yaml new file mode 100644 index 00000000..3a03d881 --- /dev/null +++ b/library/cables/HVDC_2000mm_320kV_dynamic.yaml @@ -0,0 +1,11 @@ +# Copper from Prysmian +ac_resistance: 0 # ohm/km +capacitance: 295000 # nF/km +conductor_size: 2000 # mm^2 +cost_per_km: 600000 # $ (20% adder over HVDC_2000mm_320kV) +current_capacity: 1900 # A # ESTIMATE +inductance: 0.127 # mH/km +linear_density: 53 # t/km +cable_type: HVDC-monopole # HVDC vs HVAC +name: HVDC_2000mm_320kV +rated_voltage: 320 diff --git a/library/cables/XLPE_1000m_220kV_dynamic.yaml b/library/cables/XLPE_1000m_220kV_dynamic.yaml new file mode 100644 index 00000000..d179ae21 --- /dev/null +++ b/library/cables/XLPE_1000m_220kV_dynamic.yaml @@ -0,0 +1,10 @@ +ac_resistance: 0.16 # ohm/km +capacitance: 190 # nF/km +conductor_size: 1000 # mm^2 +cost_per_km: 1020000 # $ (20% adder over XLPE_1000m_220kV) +current_capacity: 825 # A +inductance: 0.38 # mH/km +linear_density: 115 # t/km +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1000m_220kV +rated_voltage: 220 diff --git a/library/cables/XLPE_185mm_66kV_dynamic.yaml b/library/cables/XLPE_185mm_66kV_dynamic.yaml new file mode 100644 index 00000000..5a9e706e --- /dev/null +++ b/library/cables/XLPE_185mm_66kV_dynamic.yaml @@ -0,0 +1,9 @@ +ac_resistance: 0.128 # +capacitance: 163 # +conductor_size: 185 # +cost_per_km: 240000 # $ (20% adder over XLPE_185mm_66kV) +current_capacity: 445 # At 2m burial depth +inductance: 0.443 # +linear_density: 26.1 # +name: XLPE_185mm_66kV +rated_voltage: 66 diff --git a/library/cables/XLPE_500mm_132kV.yaml b/library/cables/XLPE_500mm_132kV.yaml index e58a7a02..af7061c7 100644 --- a/library/cables/XLPE_500mm_132kV.yaml +++ b/library/cables/XLPE_500mm_132kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.06 capacitance: 200 conductor_size: 500 -cost_per_km: 200000 +cost_per_km: 500000 current_capacity: 625 inductance: 0.4 linear_density: 50 diff --git a/library/cables/XLPE_500mm_132kV_dynamic.yaml b/library/cables/XLPE_500mm_132kV_dynamic.yaml new file mode 100644 index 00000000..b0b1ec59 --- /dev/null +++ b/library/cables/XLPE_500mm_132kV_dynamic.yaml @@ -0,0 +1,10 @@ +ac_resistance: 0.06 +capacitance: 200 +conductor_size: 500 +cost_per_km: 600000 # $ (20% adder over XLPE_500mm_132kV) +current_capacity: 625 +inductance: 0.4 +linear_density: 50 +cable_type: HVAC +name: XLPE_500mm_132kV +rated_voltage: 132 diff --git a/library/cables/XLPE_630mm_66kV_dynamic.yaml b/library/cables/XLPE_630mm_66kV_dynamic.yaml new file mode 100644 index 00000000..69d857c3 --- /dev/null +++ b/library/cables/XLPE_630mm_66kV_dynamic.yaml @@ -0,0 +1,11 @@ +ac_resistance: 0.04 +capacitance: 300 +conductor_size: 630 +cost_per_km: 480000 # $ (20% adder over XLPE_630mm_66kV) +current_capacity: 775 +inductance: 0.35 +linear_density: 42.5 +name: XLPE_630mm_66kV +rated_voltage: 66 +switchgear_cost: 1e6 +cable_type: HVAC # HVDC vs HVAC diff --git a/library/vessels/example_cable_lay_vessel.yaml b/library/vessels/example_cable_lay_vessel.yaml index 728ac348..7813dc7b 100644 --- a/library/vessels/example_cable_lay_vessel.yaml +++ b/library/vessels/example_cable_lay_vessel.yaml @@ -3,7 +3,7 @@ transport_specs: max_windspeed: 25 # m/s transit_speed: 11.5 # km/hr vessel_specs: - day_rate: 120000 # USD/day, cost of operating vessel with crew + day_rate: 225000 # USD/day, cost of operating vessel with crew min_draft: 4.8 # m overall_length: 99.0 # m cable_storage: From 2cd2098d4a703e421fb879fc3fc80f2d959deb33 Mon Sep 17 00:00:00 2001 From: Shields Date: Fri, 14 Apr 2023 17:07:05 -0600 Subject: [PATCH 074/240] Update CLV carousel specs to match Leonardo da --- library/vessels/example_cable_lay_vessel.yaml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/vessels/example_cable_lay_vessel.yaml b/library/vessels/example_cable_lay_vessel.yaml index 7813dc7b..8840ba6c 100644 --- a/library/vessels/example_cable_lay_vessel.yaml +++ b/library/vessels/example_cable_lay_vessel.yaml @@ -4,7 +4,7 @@ transport_specs: transit_speed: 11.5 # km/hr vessel_specs: day_rate: 225000 # USD/day, cost of operating vessel with crew - min_draft: 4.8 # m - overall_length: 99.0 # m + min_draft: 8.5 # m + overall_length: 171.0 # m cable_storage: - max_mass: 4000 # t + max_mass: 13000 # t From 347fcf2cec5f5046418244f0e53e5de43079c1c0 Mon Sep 17 00:00:00 2001 From: asharma Date: Sun, 16 Apr 2023 20:30:09 -0600 Subject: [PATCH 075/240] change delay message --- ORBIT/phases/install/oss_install/floating.py | 4 +++- ORBIT/phases/install/quayside_assembly_tow/common.py | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 3d4e551b..6e7f9a4b 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -308,7 +308,9 @@ def assemble_substructure(self): delay = self.env.now - start if delay > 0: - self.submit_action_log("Delay: No Wet Storage Available", delay) + self.submit_action_log( + "Delay: No Substructure Storage Available", delay + ) @process def start(self): diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index ada96e21..4083cc36 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -94,7 +94,9 @@ def assemble_substructure(self): delay = self.env.now - start if delay > 0: - self.submit_action_log("Delay: No Wet Storage Available", delay) + self.submit_action_log( + "Delay: No Substructure Storage Available", delay + ) @process def start(self): From b3150a575cc69a873ea14c88289e9e70f7322c43 Mon Sep 17 00:00:00 2001 From: asharma Date: Tue, 18 Apr 2023 16:43:16 -0600 Subject: [PATCH 076/240] change vessel speeds --- library/vessels/example_ahts_vessel.yaml | 2 +- library/vessels/example_towing_vessel.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/vessels/example_ahts_vessel.yaml b/library/vessels/example_ahts_vessel.yaml index 338152ac..66c2eeda 100644 --- a/library/vessels/example_ahts_vessel.yaml +++ b/library/vessels/example_ahts_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: max_waveheight: 3.0 # m max_windspeed: 15 # m/s - transit_speed: 6 # km/h + transit_speed: 14 # km/h vessel_specs: day_rate: 100000 # USD/day diff --git a/library/vessels/example_towing_vessel.yaml b/library/vessels/example_towing_vessel.yaml index c4de57e5..695a8f94 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: 6 # km/h + transit_speed: 14 # km/h vessel_specs: day_rate: 30000 # USD/day From 65bfb0d34f787dcd9e4eb4420f3fde911ae22270 Mon Sep 17 00:00:00 2001 From: asharma Date: Thu, 20 Apr 2023 11:49:58 -0600 Subject: [PATCH 077/240] remove duplicate transit back to port --- ORBIT/phases/install/cable_install/array.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/ORBIT/phases/install/cable_install/array.py b/ORBIT/phases/install/cable_install/array.py index d4d8a181..5fbb5923 100644 --- a/ORBIT/phases/install/cable_install/array.py +++ b/ORBIT/phases/install/cable_install/array.py @@ -10,7 +10,6 @@ import numpy as np from marmot import process - from ORBIT.core import Vessel from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase @@ -237,7 +236,6 @@ def install_array_cables( trench_vessel.at_site = True elif trench_vessel.at_site: - try: # Dig trench along each cable section distance trench_distance = trench_sections.pop(0) @@ -269,7 +267,6 @@ def install_array_cables( vessel.at_site = True elif vessel.at_site: - try: length, num_sections, *extra = sections.pop(0) if extra: @@ -291,12 +288,10 @@ def install_array_cables( break for _ in range(num_sections): - try: section = vessel.cable_storage.get_cable(length) except InsufficientCable: - yield vessel.transit(distance, **kwargs) yield load_cable_on_vessel(vessel, cable, **kwargs) yield vessel.transit(distance, **kwargs) @@ -330,11 +325,6 @@ def install_array_cables( vessel, installed, total_cable_length, breakpoints ) - # Transit back to port - vessel.at_site = False - yield vessel.transit(distance, **kwargs) - vessel.at_port = True - ## Burial Process if burial_vessel is None: vessel.submit_debug_log( From d118855a1a28662ed098a91e376a4cd03a1a990b Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Fri, 21 Apr 2023 09:44:38 -0600 Subject: [PATCH 078/240] Added project progress debug logs to MooredSubInstallation and FloatingOSSInstallation so monthly_opex works. --- ORBIT/phases/install/oss_install/floating.py | 6 ++++++ ORBIT/phases/install/quayside_assembly_tow/moored.py | 3 +++ 2 files changed, 9 insertions(+) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 6e7f9a4b..471118db 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -229,6 +229,12 @@ def install_floating_substations( yield vessel.transit(distance) + # TODO: Revise this to work with multiple substations + vessel.submit_debug_log( + message="Substation installation complete!", + progress="Offshore Substation", + ) + class SubstationAssemblyLine(Agent): """Substation Assembly Line Class.""" diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 54fbfe39..c087e066 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -376,6 +376,9 @@ def towing_group_actions( constraints={"windspeed": le(15), "waveheight": le(2.5)}, ) + group.submit_debug_log(progress="Substructure") + group.submit_debug_log(progress="Turbine") + yield group.group_task( "Transit", transit_time, From c540a766172f8e79db29c70b66a99af2956a2778 Mon Sep 17 00:00:00 2001 From: asharma Date: Sat, 22 Apr 2023 00:08:49 -0600 Subject: [PATCH 079/240] allow separate cable lay burial rates --- ORBIT/core/defaults/process_times.yaml | 1 - ORBIT/phases/install/cable_install/common.py | 4 +--- library/vessels/example_cable_lay_vessel.yaml | 1 + .../vessels/test_cable_lay_vessel.yaml | 1 + .../cable_install/test_array_install.py | 19 ++++--------------- .../cable_install/test_export_install.py | 19 ++++--------------- 6 files changed, 11 insertions(+), 34 deletions(-) diff --git a/ORBIT/core/defaults/process_times.yaml b/ORBIT/core/defaults/process_times.yaml index f8a3a1d3..1ec8d812 100644 --- a/ORBIT/core/defaults/process_times.yaml +++ b/ORBIT/core/defaults/process_times.yaml @@ -14,7 +14,6 @@ "cable_pull_in_time": 5.5 # hr "cable_termination_time": 5.5 # hr "cable_lay_speed": 0.4 # km/hr (10 km/day) -"cable_lay_bury_speed": 0.0625 # km/hr (1-2 km/day) "cable_bury_speed": 0.4 # km/hr "cable_splice_time": 48 # hr "cable_raise_time": 0.5 # hr diff --git a/ORBIT/phases/install/cable_install/common.py b/ORBIT/phases/install/cable_install/common.py index f2481138..483e9718 100644 --- a/ORBIT/phases/install/cable_install/common.py +++ b/ORBIT/phases/install/cable_install/common.py @@ -7,7 +7,6 @@ from marmot import process - from ORBIT.core.logic import position_onsite from ORBIT.core.defaults import process_times as pt @@ -176,8 +175,7 @@ def lay_bury_cable(vessel, distance, **kwargs): kwargs = {**kwargs, **getattr(vessel, "_transport_specs", {})} - key = "cable_lay_bury_speed" - lay_bury_speed = kwargs.get(key, pt[key]) + lay_bury_speed = vessel._vessel_specs.get("cable_lay_bury_speed", 0.0625) lay_bury_time = distance / lay_bury_speed yield vessel.task_wrapper( diff --git a/library/vessels/example_cable_lay_vessel.yaml b/library/vessels/example_cable_lay_vessel.yaml index 8840ba6c..3fd571c8 100644 --- a/library/vessels/example_cable_lay_vessel.yaml +++ b/library/vessels/example_cable_lay_vessel.yaml @@ -6,5 +6,6 @@ vessel_specs: day_rate: 225000 # USD/day, cost of operating vessel with crew min_draft: 8.5 # m overall_length: 171.0 # m + cable_lay_bury_speed: 0.0625 # km/hr cable_storage: max_mass: 13000 # t diff --git a/tests/data/library/vessels/test_cable_lay_vessel.yaml b/tests/data/library/vessels/test_cable_lay_vessel.yaml index 73bfb1a8..ee0f1b34 100644 --- a/tests/data/library/vessels/test_cable_lay_vessel.yaml +++ b/tests/data/library/vessels/test_cable_lay_vessel.yaml @@ -6,5 +6,6 @@ vessel_specs: day_rate: 50000 # USD/day, cost of operating vessel with crew min_draft: 4.8 # m overall_length: 99.0 # m + cable_lay_bury_speed: 0.0625 # km/hr cable_storage: max_mass: 6000 diff --git a/tests/phases/install/cable_install/test_array_install.py b/tests/phases/install/cable_install/test_array_install.py index 5a01c14b..dc94153e 100644 --- a/tests/phases/install/cable_install/test_array_install.py +++ b/tests/phases/install/cable_install/test_array_install.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,7 +27,6 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): - sim = ArrayCableInstallation(config) assert sim.env @@ -37,7 +35,6 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): - sim = ArrayCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -53,7 +50,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): - sim = ArrayCableInstallation(config, weather=weather) sim.run() @@ -72,24 +68,21 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): - sim = ArrayCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time - key = "cable_lay_bury_speed" - val = pt[key] * 0.1 - - kwargs = {key: val} + sim.install_vessel._vessel_specs["cable_lay_bury_speed"] = ( + sim.install_vessel._vessel_specs["cable_lay_bury_speed"] * 0.1 + ) - sim = ArrayCableInstallation(simul_config, **kwargs) + sim = ArrayCableInstallation(simul_config) sim.run() assert sim.total_phase_time > baseline def test_separate_speed_kwargs(): - sim = ArrayCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -114,7 +107,6 @@ def test_separate_speed_kwargs(): def test_kwargs_for_array_install(): - sim = ArrayCableInstallation(base_config) sim.run() baseline = sim.total_phase_time @@ -131,7 +123,6 @@ def test_kwargs_for_array_install(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: @@ -163,7 +154,6 @@ def test_kwargs_for_array_install(): def test_kwargs_for_array_install_in_ProjectManager(): - base = deepcopy(base_config) base["install_phases"] = ["ArrayCableInstallation"] @@ -183,7 +173,6 @@ def test_kwargs_for_array_install_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 12f0c1dc..3a03a9df 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -12,7 +12,6 @@ import pandas as pd import pytest - from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -28,7 +27,6 @@ "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_simulation_setup(config): - sim = ExportCableInstallation(config) assert sim.env assert sim.cable @@ -42,7 +40,6 @@ def test_simulation_setup(config): "config", (base_config, simul_config), ids=["separate", "simultaneous"] ) def test_vessel_initialization(config): - sim = ExportCableInstallation(config) assert sim.install_vessel assert sim.install_vessel.cable_storage @@ -58,7 +55,6 @@ def test_vessel_initialization(config): "weather", (None, test_weather), ids=["no_weather", "test_weather"] ) def test_for_complete_logging(config, weather): - sim = ExportCableInstallation(config, weather=weather) sim.run() @@ -77,24 +73,21 @@ def test_for_complete_logging(config, weather): def test_simultaneous_speed_kwargs(): - sim = ExportCableInstallation(simul_config) sim.run() baseline = sim.total_phase_time - key = "cable_lay_bury_speed" - val = pt[key] * 0.1 - - kwargs = {key: val} + sim.install_vessel._vessel_specs["cable_lay_bury_speed"] = ( + sim.install_vessel._vessel_specs["cable_lay_bury_speed"] * 0.1 + ) - sim = ExportCableInstallation(simul_config, **kwargs) + sim = ExportCableInstallation(simul_config) sim.run() assert sim.total_phase_time > baseline def test_separate_speed_kwargs(): - sim = ExportCableInstallation(base_config) sim.run() df = pd.DataFrame(sim.env.actions) @@ -119,7 +112,6 @@ def test_separate_speed_kwargs(): def test_kwargs_for_export_install(): - new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -150,7 +142,6 @@ def test_kwargs_for_export_install(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: @@ -182,7 +173,6 @@ def test_kwargs_for_export_install(): def test_kwargs_for_export_install_in_ProjectManager(): - new_export_system = { "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, "system_cost": 200e6, @@ -213,7 +203,6 @@ def test_kwargs_for_export_install_in_ProjectManager(): failed = [] for kw in keywords: - default = pt[kw] if "speed" in kw: From 50144ca43eaf75e44256b22e7af64e9273607787 Mon Sep 17 00:00:00 2001 From: asharma Date: Sun, 30 Apr 2023 19:07:23 -0600 Subject: [PATCH 080/240] account for multiple assembly lines in installation costs --- ORBIT/phases/install/install_phase.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/install/install_phase.py b/ORBIT/phases/install/install_phase.py index 97b93c3b..0fbad57a 100644 --- a/ORBIT/phases/install/install_phase.py +++ b/ORBIT/phases/install/install_phase.py @@ -12,7 +12,6 @@ import numpy as np import simpy import pandas as pd - from ORBIT.core import Port, Vessel, Environment from ORBIT.phases import BasePhase from ORBIT.core.defaults import common_costs @@ -121,9 +120,14 @@ def port_costs(self): return 0 else: - key = "port_cost_per_month" port_config = self.config.get("port", {}) + assert port_config.get("sub_assembly_lines", 1) == port_config.get( + "turbine_assembly_cranes", 1 + ), "Number of substructure assembly lines is not equal to number of turbine assembly cranes" + + key = "port_cost_per_month" rate = port_config.get("monthly_rate", common_costs[key]) + rate += rate * (port_config.get("sub_assembly_lines", 1) - 1) * 0.5 months = self.total_phase_time / (8760 / 12) return months * rate From 5a38ca4fb21c46329a2695efd28356a6b55a5293 Mon Sep 17 00:00:00 2001 From: asharma Date: Fri, 26 May 2023 13:40:05 -0600 Subject: [PATCH 081/240] update vessel specs --- library/vessels/example_towing_vessel.yaml | 2 +- tests/data/library/vessels/test_ahts_vessel.yaml | 8 ++++---- tests/data/library/vessels/test_towing_vessel.yaml | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/library/vessels/example_towing_vessel.yaml b/library/vessels/example_towing_vessel.yaml index 695a8f94..0dcdc3ef 100644 --- a/library/vessels/example_towing_vessel.yaml +++ b/library/vessels/example_towing_vessel.yaml @@ -3,4 +3,4 @@ transport_specs: max_windspeed: 15 # m/s transit_speed: 14 # km/h vessel_specs: - day_rate: 30000 # USD/day + day_rate: 35000 # USD/day diff --git a/tests/data/library/vessels/test_ahts_vessel.yaml b/tests/data/library/vessels/test_ahts_vessel.yaml index 28023f85..66c2eeda 100644 --- a/tests/data/library/vessels/test_ahts_vessel.yaml +++ b/tests/data/library/vessels/test_ahts_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: - max_waveheight: 2.5 # m - max_windspeed: 20 # m/s - transit_speed: 6 # km/h + max_waveheight: 3.0 # m + max_windspeed: 15 # m/s + transit_speed: 14 # km/h vessel_specs: - day_rate: 100000 # USD/day + day_rate: 100000 # USD/day diff --git a/tests/data/library/vessels/test_towing_vessel.yaml b/tests/data/library/vessels/test_towing_vessel.yaml index 5aa4bf58..0dcdc3ef 100644 --- a/tests/data/library/vessels/test_towing_vessel.yaml +++ b/tests/data/library/vessels/test_towing_vessel.yaml @@ -1,6 +1,6 @@ transport_specs: - max_waveheight: 2.5 # m - max_windspeed: 20 # m/s - transit_speed: 6 # km/h + max_waveheight: 3.0 # m + max_windspeed: 15 # m/s + transit_speed: 14 # km/h vessel_specs: - day_rate: 30000 # USD/day + day_rate: 35000 # USD/day From 3e7560e7b574a6488b0d08406883c2f2afc64117 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Mon, 26 Jun 2023 13:20:50 -0400 Subject: [PATCH 082/240] cost updates, vessel updates --- ORBIT/core/defaults/process_times.yaml | 6 +- ORBIT/phases/design/electrical_export.py | 127 ++++++++++++------ library/cables/HVDC_2000mm_320kV.yaml | 2 +- library/cables/HVDC_2500mm_525kV.yaml | 2 +- library/cables/XLPE_1000m_220kV.yaml | 2 +- library/cables/XLPE_1900mm_275kV.yaml | 2 +- library/vessels/example_cable_lay_vessel.yaml | 2 +- 7 files changed, 97 insertions(+), 46 deletions(-) diff --git a/ORBIT/core/defaults/process_times.yaml b/ORBIT/core/defaults/process_times.yaml index 1c141c78..4be5543d 100644 --- a/ORBIT/core/defaults/process_times.yaml +++ b/ORBIT/core/defaults/process_times.yaml @@ -13,9 +13,9 @@ "cable_lower_time": 1 # hr "cable_pull_in_time": 5.5 # hr "cable_termination_time": 5.5 # hr -"cable_lay_speed": 1 # km/hr -"cable_lay_bury_speed": 0.3 # km/hr -"cable_bury_speed": 0.5 # km/hr +"cable_lay_speed": 0.4 # km/hr +"cable_lay_bury_speed": 0.0625 # km/hr +"cable_bury_speed": 0.4 # km/hr "cable_splice_time": 48 # hr "cable_raise_time": 0.5 # hr diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index ee78b28e..fbcac70a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -33,11 +33,12 @@ class ElectricalDesign(CableSystem): "topside_design_cost": "USD (optional)", "shunt_cost_rate": "USD/MW (optional)", "switchgear_cost": "USD (optional)", - "dc_breaker_cost": "int (optional)", + "dc_breaker_cost": "USD (optional)", "backup_gen_cost": "USD (optional)", "workspace_cost": "USD (optional)", "other_ancillary_cost": "USD (optional)", "converter_cost": "USD (optional)", + "onshore_converter_cost": "USD (optional)", "topside_assembly_factor": "float (optional)", "oss_substructure_cost_rate": "USD/t (optional)", "oss_pile_cost_rate": "USD/t (optional)", @@ -188,10 +189,12 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if self.cable.cable_type == "HVDC-monopole": + num_required = 2 * np.ceil( + self._plant_capacity / self.cable.cable_power + ) + num_redundant = 2 * self._design.get("num_redundant", 0) + elif self.cable.cable_type == "HVDC-bipole": num_required = 2 * np.ceil( self._plant_capacity / self.cable.cable_power ) @@ -292,7 +295,7 @@ def calc_num_substations(self): ) else: self.num_substations = self._design.get( - "num_substations", int(np.ceil(self._plant_capacity / 800)) + "num_substations", int(np.ceil(self._plant_capacity / 1200)) ) @property @@ -313,9 +316,19 @@ def calc_mpt_cost(self): """Computes transformer cost""" self.num_mpt = self.num_cables - self.mpt_cost = self.num_mpt * self._design.get( - "mpt_cost_rate", 1750000 - ) + if self.cable.cable_type == "HVDC-monopole": + self.mpt_cost = self.num_cables * self._design.get( + "mpt_cost", 0 + ) + + elif self.cable.cable_type == "HVDC-bipole": + self.mpt_cost = self.num_cables * self._design.get( + "mpt_cost", 0 + ) + else: + self.mpt_cost = self.num_cables * self._design.get( + "mpt_cost", 2.1e6 + ) self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 ) @@ -335,7 +348,7 @@ def calc_shunt_reactor_cost(self): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( compensation - * self._design.get("shunt_cost_rate", 99000) + * self._design.get("shunt_cost_rate", 7.2e3) * self.num_cables ) @@ -350,18 +363,22 @@ def calc_switchgear_costs(self): else: num_switchgear = self.num_cables self.switchgear_cost = num_switchgear * self._design.get( - "switchgear_cost", 134000 + "switchgear_cost", 3e6 ) def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost""" - if self.cable.cable_type == "HVAC": - num_dc_breaker = 0 + if self.cable.cable_type == "HVDC-monopole": + self.dc_breaker_cost = self.num_cables * self._design.get( + "breaker_cost", 7.5e6 + ) + + elif self.cable.cable_type == "HVDC-bipole": + self.dc_breaker_cost = self.num_cables * self._design.get( + "breaker_cost", 12.5e6 + ) else: - num_dc_breaker = self.num_cables - self.dc_breaker_cost = num_dc_breaker * self._design.get( - "dc_breaker_cost", 40000000 - ) # 4e6 + self.dc_breaker_cost = 0 def calc_ancillary_system_cost(self): """ @@ -386,16 +403,17 @@ def calc_converter_cost(self): """Computes converter cost""" if self.cable.cable_type == "HVDC-monopole": - self.num_converters = self.num_cables / 2 + self.converter_cost = self.num_substations * self._design.get( + "converter_cost", 92e6 + ) elif self.cable.cable_type == "HVDC-bipole": - self.num_converters = self.num_cables + self.converter_cost = self.num_substations * self._design.get( + "converter_cost", 216e6 + ) else: - self.num_converters = 0 + self.converter_cost = 0 - self.converter_cost = self.num_converters * self._design.get( - "converter_cost", 137e6 - ) def calc_assembly_cost(self): """ @@ -423,21 +441,32 @@ def calc_substructure_mass_and_cost(self): oss_substructure_cost_rate : int | float oss_pile_cost_rate : int | float """ - _design = self.config.get("substation_design", {}) - oss_substructure_cost_rate = _design.get( - "oss_substructure_cost_rate", 3000 - ) - oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) - substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass**0.5574 - self.substructure_cost = ( - substructure_mass * oss_substructure_cost_rate - + substructure_pile_mass * oss_pile_cost_rate - ) + if self.cable.cable_type == "HVDC-monopole": + self.substructure_cost = _design.get( + "oss_substructure_cost_rate", 213e6 + ) + self.substructure_mass = substructure_mass + elif self.cable.cable_type == "HVDC-bipole": + self.substructure_cost = _design.get( + "oss_substructure_cost_rate", 345e6 + ) + self.substructure_mass = substructure_mass + else: + oss_substructure_cost_rate = _design.get( + "oss_substructure_cost_rate", 77.8 + ) + oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + substructure_pile_mass = 8 * substructure_mass**0.5574 + self.substructure_cost = ( + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate + ) + + self.substructure_mass = substructure_mass + substructure_pile_mass - self.substructure_mass = substructure_mass + substructure_pile_mass + def calc_substructure_length(self): """ @@ -488,10 +517,32 @@ def calc_topside_mass_and_cost(self): def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" + + if self.cable.cable_type == "HVDC-monopole": + self.onshore_converter_cost = self.num_substations * self._design.get( + "onshore_converter_cost", 157e6 + ) + self.ais_cost = 0 + self.onshore_construction = 87.3e6 + self.onshore_compensation = 0 + elif self.cable.cable_type == "HVDC-bipole": + self.onshore_converter_cost = self.num_substations * self._design.get( + "onshore_converter_cost", 350e6 + ) + self.ais_cost = 0 + self.onshore_construction = 100e6 + self.onshore_compensation = 0 + else: + self.onshore_converter_cost = 0 + self.ais_cost = self.num_cables * 9.33e6 + self.onshore_compensation = self.num_cables * (31.3e6 + 8.66e6) + self.onshore_construction = 0 + self.onshore_cost = ( - self.converter_cost - + self.dc_breaker_cost + self.onshore_converter_cost + + self.onshore_construction + +self.onshore_compensation + self.mpt_cost - + self.switchgear_cost + + self.ais_cost ) diff --git a/library/cables/HVDC_2000mm_320kV.yaml b/library/cables/HVDC_2000mm_320kV.yaml index 17ad7bf1..6472598c 100644 --- a/library/cables/HVDC_2000mm_320kV.yaml +++ b/library/cables/HVDC_2000mm_320kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0 # ohm/km capacitance: 295000 # nF/km conductor_size: 2000 # mm^2 -cost_per_km: 500000 # $ +cost_per_km: 650000 # $ 500k current_capacity: 1900 # A # ESTIMATE inductance: 0.127 # mH/km linear_density: 53 # t/km diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml index 9d9aee22..02417eca 100644 --- a/library/cables/HVDC_2500mm_525kV.yaml +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0 # ohm/km capacitance: 227000 # nF/km conductor_size: 2500 # mm^2 -cost_per_km: 825000 # $ +cost_per_km: 1100000 # $ 825k current_capacity: 1905 # A inductance: 0.149 # mH/km linear_density: 74 # t/km diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index 93fe52da..ab3e10f8 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.16 # ohm/km capacitance: 190 # nF/km conductor_size: 1000 # mm^2 -cost_per_km: 850000 # $ +cost_per_km: 2150000 # $ 850k current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km diff --git a/library/cables/XLPE_1900mm_275kV.yaml b/library/cables/XLPE_1900mm_275kV.yaml index 3ddd1a3e..2789b98b 100644 --- a/library/cables/XLPE_1900mm_275kV.yaml +++ b/library/cables/XLPE_1900mm_275kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.020 # ohm/km capacitance: 224 # nF/km conductor_size: 1900 # mm^2 -cost_per_km: 1700000 # $ +cost_per_km: 1020000 # $ 170k current_capacity: 910 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 185 # t/km diff --git a/library/vessels/example_cable_lay_vessel.yaml b/library/vessels/example_cable_lay_vessel.yaml index 728ac348..7813dc7b 100644 --- a/library/vessels/example_cable_lay_vessel.yaml +++ b/library/vessels/example_cable_lay_vessel.yaml @@ -3,7 +3,7 @@ transport_specs: max_windspeed: 25 # m/s transit_speed: 11.5 # km/hr vessel_specs: - day_rate: 120000 # USD/day, cost of operating vessel with crew + day_rate: 225000 # USD/day, cost of operating vessel with crew min_draft: 4.8 # m overall_length: 99.0 # m cable_storage: From 0911febfdb5678123a880fb62ab51ace749c48b2 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Mon, 26 Jun 2023 13:21:24 -0400 Subject: [PATCH 083/240] cost updates, vessel updates --- ORBIT/phases/design/electrical_export.py | 44 ++++++++++-------------- 1 file changed, 19 insertions(+), 25 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index fbcac70a..9a2a2e6e 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -277,9 +277,9 @@ def calc_crossing_cost(self): @property def total_substation_cost(self): - return (self.topside_cost - + self.substructure_cost - + self.substation_cost) + return ( + self.topside_cost + self.substructure_cost + self.substation_cost + ) def calc_num_substations(self): """Computes number of substations""" @@ -317,18 +317,14 @@ def calc_mpt_cost(self): self.num_mpt = self.num_cables if self.cable.cable_type == "HVDC-monopole": - self.mpt_cost = self.num_cables * self._design.get( - "mpt_cost", 0 - ) + self.mpt_cost = self.num_cables * self._design.get("mpt_cost", 0) elif self.cable.cable_type == "HVDC-bipole": - self.mpt_cost = self.num_cables * self._design.get( - "mpt_cost", 0 - ) + self.mpt_cost = self.num_cables * self._design.get("mpt_cost", 0) else: self.mpt_cost = self.num_cables * self._design.get( "mpt_cost", 2.1e6 - ) + ) self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 ) @@ -404,17 +400,16 @@ def calc_converter_cost(self): if self.cable.cable_type == "HVDC-monopole": self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 92e6 - ) + "converter_cost", 92e6 + ) elif self.cable.cable_type == "HVDC-bipole": self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 216e6 - ) + "converter_cost", 216e6 + ) else: self.converter_cost = 0 - def calc_assembly_cost(self): """ Calculates the cost of assembly on land. @@ -463,10 +458,8 @@ def calc_substructure_mass_and_cost(self): substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate ) - - self.substructure_mass = substructure_mass + substructure_pile_mass - + self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): """ @@ -517,17 +510,19 @@ def calc_topside_mass_and_cost(self): def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" - + if self.cable.cable_type == "HVDC-monopole": - self.onshore_converter_cost = self.num_substations * self._design.get( - "onshore_converter_cost", 157e6 + self.onshore_converter_cost = ( + self.num_substations + * self._design.get("onshore_converter_cost", 157e6) ) self.ais_cost = 0 self.onshore_construction = 87.3e6 self.onshore_compensation = 0 elif self.cable.cable_type == "HVDC-bipole": - self.onshore_converter_cost = self.num_substations * self._design.get( - "onshore_converter_cost", 350e6 + self.onshore_converter_cost = ( + self.num_substations + * self._design.get("onshore_converter_cost", 350e6) ) self.ais_cost = 0 self.onshore_construction = 100e6 @@ -538,11 +533,10 @@ def calc_onshore_cost(self): self.onshore_compensation = self.num_cables * (31.3e6 + 8.66e6) self.onshore_construction = 0 - self.onshore_cost = ( self.onshore_converter_cost + self.onshore_construction - +self.onshore_compensation + + self.onshore_compensation + self.mpt_cost + self.ais_cost ) From 72b655ad25e5fcfbc113ebc77675415dffaa7160 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Mon, 26 Jun 2023 16:05:49 -0400 Subject: [PATCH 084/240] costs to include pm + profit --- ORBIT/phases/design/electrical_export.py | 40 ++++++++++++------------ library/cables/HVDC_2000mm_320kV.yaml | 2 +- library/cables/HVDC_2500mm_525kV.yaml | 2 +- library/cables/XLPE_1000m_220kV.yaml | 2 +- library/cables/XLPE_1900mm_275kV.yaml | 2 +- 5 files changed, 24 insertions(+), 24 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 9a2a2e6e..60414528 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -323,7 +323,7 @@ def calc_mpt_cost(self): self.mpt_cost = self.num_cables * self._design.get("mpt_cost", 0) else: self.mpt_cost = self.num_cables * self._design.get( - "mpt_cost", 2.1e6 + "mpt_cost", 2.87e6 ) self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 @@ -344,7 +344,7 @@ def calc_shunt_reactor_cost(self): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( compensation - * self._design.get("shunt_cost_rate", 7.2e3) + * self._design.get("shunt_cost_rate", 1e4) * self.num_cables ) @@ -359,19 +359,19 @@ def calc_switchgear_costs(self): else: num_switchgear = self.num_cables self.switchgear_cost = num_switchgear * self._design.get( - "switchgear_cost", 3e6 + "switchgear_cost", 4e6 ) def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost""" if self.cable.cable_type == "HVDC-monopole": self.dc_breaker_cost = self.num_cables * self._design.get( - "breaker_cost", 7.5e6 + "breaker_cost", 10.5e6 ) elif self.cable.cable_type == "HVDC-bipole": self.dc_breaker_cost = self.num_cables * self._design.get( - "breaker_cost", 12.5e6 + "breaker_cost", 17.5e6 ) else: self.dc_breaker_cost = 0 @@ -400,12 +400,12 @@ def calc_converter_cost(self): if self.cable.cable_type == "HVDC-monopole": self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 92e6 + "converter_cost", 127e6 ) elif self.cable.cable_type == "HVDC-bipole": self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 216e6 + "converter_cost", 296e6 ) else: self.converter_cost = 0 @@ -440,26 +440,26 @@ def calc_substructure_mass_and_cost(self): substructure_mass = 0.4 * self.topside_mass if self.cable.cable_type == "HVDC-monopole": self.substructure_cost = _design.get( - "oss_substructure_cost_rate", 213e6 + "oss_substructure_cost_rate", 294e6 ) - self.substructure_mass = substructure_mass elif self.cable.cable_type == "HVDC-bipole": self.substructure_cost = _design.get( - "oss_substructure_cost_rate", 345e6 + "oss_substructure_cost_rate", 476e6 ) - self.substructure_mass = substructure_mass else: - oss_substructure_cost_rate = _design.get( - "oss_substructure_cost_rate", 77.8 - ) - oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) - substructure_pile_mass = 8 * substructure_mass**0.5574 - self.substructure_cost = ( - substructure_mass * oss_substructure_cost_rate - + substructure_pile_mass * oss_pile_cost_rate + self.substructure_cost = _design.get( + "oss_substructure_cost_rate", 107.3e6 ) + # oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + # substructure_pile_mass = 8 * substructure_mass**0.5574 + # self.substructure_cost = (77.8 + # substructure_mass * oss_substructure_cost_rate + # + substructure_pile_mass * oss_pile_cost_rate + # ) + + # self.substructure_mass = substructure_mass + substructure_pile_mass + self.substructure_mass = substructure_mass - self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): """ diff --git a/library/cables/HVDC_2000mm_320kV.yaml b/library/cables/HVDC_2000mm_320kV.yaml index 6472598c..615de0e0 100644 --- a/library/cables/HVDC_2000mm_320kV.yaml +++ b/library/cables/HVDC_2000mm_320kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0 # ohm/km capacitance: 295000 # nF/km conductor_size: 2000 # mm^2 -cost_per_km: 650000 # $ 500k +cost_per_km: 828000 # $ 500k current_capacity: 1900 # A # ESTIMATE inductance: 0.127 # mH/km linear_density: 53 # t/km diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml index 02417eca..0c9eb507 100644 --- a/library/cables/HVDC_2500mm_525kV.yaml +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0 # ohm/km capacitance: 227000 # nF/km conductor_size: 2500 # mm^2 -cost_per_km: 1100000 # $ 825k +cost_per_km: 1380000 # $ 825k current_capacity: 1905 # A inductance: 0.149 # mH/km linear_density: 74 # t/km diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index ab3e10f8..e0019021 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.16 # ohm/km capacitance: 190 # nF/km conductor_size: 1000 # mm^2 -cost_per_km: 2150000 # $ 850k +cost_per_km: 1350000 # $ 850k current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km diff --git a/library/cables/XLPE_1900mm_275kV.yaml b/library/cables/XLPE_1900mm_275kV.yaml index 2789b98b..9ec49a9e 100644 --- a/library/cables/XLPE_1900mm_275kV.yaml +++ b/library/cables/XLPE_1900mm_275kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0.020 # ohm/km capacitance: 224 # nF/km conductor_size: 1900 # mm^2 -cost_per_km: 1020000 # $ 170k +cost_per_km: 1280000 # $ 170k current_capacity: 910 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 185 # t/km From b02df954c83e895cddb75ea38ca796d843ae8c7a Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Wed, 6 Sep 2023 10:20:28 -0600 Subject: [PATCH 085/240] fix topside, substructure switch --- ORBIT/phases/design/electrical_export.py | 55 ++++++++++++------------ library/cables/HVDC_2500mm_525kV.yaml | 2 +- library/cables/XLPE_1000m_220kV.yaml | 2 +- 3 files changed, 30 insertions(+), 29 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 60414528..d485a50f 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -436,29 +436,21 @@ def calc_substructure_mass_and_cost(self): oss_substructure_cost_rate : int | float oss_pile_cost_rate : int | float """ + _design = self.config.get("substation_design", {}) substructure_mass = 0.4 * self.topside_mass - if self.cable.cable_type == "HVDC-monopole": - self.substructure_cost = _design.get( - "oss_substructure_cost_rate", 294e6 - ) - elif self.cable.cable_type == "HVDC-bipole": - self.substructure_cost = _design.get( - "oss_substructure_cost_rate", 476e6 - ) - else: - self.substructure_cost = _design.get( - "oss_substructure_cost_rate", 107.3e6 - ) - # oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) - # substructure_pile_mass = 8 * substructure_mass**0.5574 - # self.substructure_cost = (77.8 - # substructure_mass * oss_substructure_cost_rate - # + substructure_pile_mass * oss_pile_cost_rate - # ) - - # self.substructure_mass = substructure_mass + substructure_pile_mass - self.substructure_mass = substructure_mass + oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + oss_substructure_cost_rate = _design.get( + "oss_substructure_cost_rate", 3000 + ) + + substructure_pile_mass = 8 * substructure_mass**0.5574 + self.substructure_cost = ( + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate + ) + + self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): @@ -497,16 +489,25 @@ def calc_topside_mass_and_cost(self): """ _design = self.config.get("substation_design", {}) - topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) - topside_design_cost = _design.get("topside_design_cost", 4.5e6) + #topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) + #topside_design_cost = _design.get("topside_design_cost", 4.5e6) self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 ) - self.topside_cost = ( - self.topside_mass * topside_fab_cost_rate + topside_design_cost - ) + if self.cable.cable_type == "HVDC-monopole": + self.topside_cost = _design.get( + "topside_design_cost", 294e6 + ) + elif self.cable.cable_type == "HVDC-bipole": + self.topside_cost = _design.get( + "topside_design_cost", 476e6 + ) + else: + self.topside_cost = _design.get( + "topside_design_cost", 107.3e6 + ) def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" @@ -531,7 +532,7 @@ def calc_onshore_cost(self): self.onshore_converter_cost = 0 self.ais_cost = self.num_cables * 9.33e6 self.onshore_compensation = self.num_cables * (31.3e6 + 8.66e6) - self.onshore_construction = 0 + self.onshore_construction = 5e6 * self.num_substations self.onshore_cost = ( self.onshore_converter_cost diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml index 0c9eb507..f5f9c60c 100644 --- a/library/cables/HVDC_2500mm_525kV.yaml +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -2,7 +2,7 @@ ac_resistance: 0 # ohm/km capacitance: 227000 # nF/km conductor_size: 2500 # mm^2 -cost_per_km: 1380000 # $ 825k +cost_per_km: 1420000 # $ 825k current_capacity: 1905 # A inductance: 0.149 # mH/km linear_density: 74 # t/km diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000m_220kV.yaml index e0019021..df8ac888 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000m_220kV.yaml @@ -1,7 +1,7 @@ ac_resistance: 0.16 # ohm/km capacitance: 190 # nF/km conductor_size: 1000 # mm^2 -cost_per_km: 1350000 # $ 850k +cost_per_km: 1420000 # $ 850k current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km From 3baed36052d7503de6ea6f2db0b40945d637ea35 Mon Sep 17 00:00:00 2001 From: Jake Nunemaker Date: Fri, 20 Oct 2023 09:48:54 -0600 Subject: [PATCH 086/240] Revert solo monopile install to original get items from port method --- ORBIT/phases/install/monopile_install/standard.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py index da16ad13..47ae2923 100644 --- a/ORBIT/phases/install/monopile_install/standard.py +++ b/ORBIT/phases/install/monopile_install/standard.py @@ -14,7 +14,7 @@ from ORBIT.core.logic import ( prep_for_site_operations, shuttle_items_to_queue_wait, - get_list_of_items_from_port_wait, + get_list_of_items_from_port, ) from ORBIT.phases.install import InstallPhase from ORBIT.core.exceptions import ItemNotFound @@ -326,7 +326,7 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): if vessel.at_port: try: # Get substructure + transition piece from port - yield get_list_of_items_from_port_wait( + yield get_list_of_items_from_port( vessel, port, component_list, **kwargs ) From 7d678afd37927fffa00bdc9d7793199b20d1bb7b Mon Sep 17 00:00:00 2001 From: Rolph Date: Fri, 10 Nov 2023 09:34:54 -0700 Subject: [PATCH 087/240] adding more cables --- library/cables/HVDC_2000mm_320kV_dynamic.yaml | 11 +++++++++++ library/cables/XLPE_1000m_220kV_dynamic.yaml | 10 ++++++++++ 2 files changed, 21 insertions(+) create mode 100644 library/cables/HVDC_2000mm_320kV_dynamic.yaml create mode 100644 library/cables/XLPE_1000m_220kV_dynamic.yaml diff --git a/library/cables/HVDC_2000mm_320kV_dynamic.yaml b/library/cables/HVDC_2000mm_320kV_dynamic.yaml new file mode 100644 index 00000000..bceee48c --- /dev/null +++ b/library/cables/HVDC_2000mm_320kV_dynamic.yaml @@ -0,0 +1,11 @@ +# Copper from Prysmian +ac_resistance: 0 # ohm/km +capacitance: 295000 # nF/km +conductor_size: 2000 # mm^2 +cost_per_km: 993600 # $ +current_capacity: 1900 # A # ESTIMATE +inductance: 0.127 # mH/km +linear_density: 53 # t/km +cable_type: HVDC-monopole # HVDC vs HVAC +name: HVDC_2000mm_320kV_dynamic +rated_voltage: 320 diff --git a/library/cables/XLPE_1000m_220kV_dynamic.yaml b/library/cables/XLPE_1000m_220kV_dynamic.yaml new file mode 100644 index 00000000..e6d88e3e --- /dev/null +++ b/library/cables/XLPE_1000m_220kV_dynamic.yaml @@ -0,0 +1,10 @@ +ac_resistance: 0.16 # ohm/km +capacitance: 190 # nF/km +conductor_size: 1000 # mm^2 +cost_per_km: 1700000 # $ +current_capacity: 825 # A +inductance: 0.38 # mH/km +linear_density: 115 # t/km +cable_type: HVAC # HVDC vs HVAC +name: XLPE_1000m_220kV_dynamic +rated_voltage: 220 From d1cf904dba8cd5a51ac2596134d0cb4bfcf06135 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Dec 2023 15:27:07 -0700 Subject: [PATCH 088/240] Autoupdate pre-commit, began cleaning up electrical_export. Simplfiied some if conditions and the format of some returns --- .pre-commit-config.yaml | 6 +-- ORBIT/phases/design/electrical_export.py | 69 ++++++++++++------------ 2 files changed, 36 insertions(+), 39 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 84ca9757..cc2c098f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,14 +3,14 @@ ci: repos: - repo: https://github.com/timothycrosley/isort - rev: 4.3.21 + rev: 5.13.1 hooks: - id: isort name: isort stages: [commit] - repo: https://github.com/psf/black - rev: stable + rev: 23.11.0 hooks: - id: black name: black @@ -34,7 +34,7 @@ repos: args: [--autofix] - repo: https://github.com/pre-commit/mirrors-pylint - rev: v2.1.1 + rev: v3.0.0a5 hooks: - id: pylint exclude: ^tests/ diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 28acb58a..81889494 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -1,9 +1,12 @@ +"""Provides the `ElectricalDesign class.""" + __author__ = ["Sophie Bredenkamp"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "" __email__ = [] import numpy as np + from ORBIT.phases.design._cables import CableSystem @@ -106,7 +109,7 @@ def run(self): self.calc_crossing_cost() self._outputs["export_system"] = {"system_cost": self.total_cable_cost} - for name, cable in self.cables.items(): + for _, cable in self.cables.items(): self._outputs["export_system"]["cable"] = { "linear_density": cable.linear_density, "sections": [self.length], @@ -176,8 +179,6 @@ def design_result(self): """ return self._outputs - #################### CABLES ######################## - @property def total_cable_cost(self): """Returns total export system cable cost.""" @@ -189,12 +190,10 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. """ - if self.cable.cable_type == "HVDC-monopole": - num_required = 2 * np.ceil( - self._plant_capacity / self.cable.cable_power - ) - num_redundant = 2 * self._design.get("num_redundant", 0) - elif self.cable.cable_type == "HVDC-bipole": + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): num_required = 2 * np.ceil( self._plant_capacity / self.cable.cable_power ) @@ -273,10 +272,10 @@ def calc_crossing_cost(self): "crossing_unit_cost", 500000 ) * self._crossing_design.get("crossing_number", 0) - #################### SUBSTATION #################### - @property def total_substation_cost(self): + """Returns the total substation cost.""" + return ( self.topside_cost + self.substructure_cost + self.substation_cost ) @@ -285,17 +284,20 @@ def calc_num_substations(self): """Computes number of substations""" self._design = self.config.get("substation_design", {}) - if self.cable.cable_type == "HVDC-monopole": - self.num_substations = self._design.get( - "num_substations", int(self.num_cables / 2) - ) - elif self.cable.cable_type == "HVDC-bipole": + + substation_capacity = 1200 # MW + + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): self.num_substations = self._design.get( "num_substations", int(self.num_cables / 2) ) else: self.num_substations = self._design.get( - "num_substations", int(np.ceil(self._plant_capacity / 1200)) + "num_substations", + int(np.ceil(self._plant_capacity / substation_capacity)), ) @property @@ -340,7 +342,7 @@ def calc_shunt_reactor_cost(self): ): compensation = 0 else: - for name, cable in self.cables.items(): + for _, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( compensation @@ -436,22 +438,21 @@ def calc_substructure_mass_and_cost(self): oss_substructure_cost_rate : int | float oss_pile_cost_rate : int | float """ - + _design = self.config.get("substation_design", {}) substructure_mass = 0.4 * self.topside_mass oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) oss_substructure_cost_rate = _design.get( "oss_substructure_cost_rate", 3000 ) - + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( - substructure_mass * oss_substructure_cost_rate - + substructure_pile_mass * oss_pile_cost_rate + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate ) - - self.substructure_mass = substructure_mass + substructure_pile_mass + self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): """ @@ -489,25 +490,19 @@ def calc_topside_mass_and_cost(self): """ _design = self.config.get("substation_design", {}) - #topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) - #topside_design_cost = _design.get("topside_design_cost", 4.5e6) + # topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) + # topside_design_cost = _design.get("topside_design_cost", 4.5e6) self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 ) if self.cable.cable_type == "HVDC-monopole": - self.topside_cost = _design.get( - "topside_design_cost", 294e6 - ) + self.topside_cost = _design.get("topside_design_cost", 294e6) elif self.cable.cable_type == "HVDC-bipole": - self.topside_cost = _design.get( - "topside_design_cost", 476e6 - ) + self.topside_cost = _design.get("topside_design_cost", 476e6) else: - self.topside_cost = _design.get( - "topside_design_cost", 107.3e6 - ) + self.topside_cost = _design.get("topside_design_cost", 107.3e6) def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" @@ -542,4 +537,6 @@ def calc_onshore_cost(self): + self.ais_cost ) - self._outputs["export_system"]["onshore_construction_cost"] = self.onshore_cost + self._outputs["export_system"][ + "onshore_construction_cost" + ] = self.onshore_cost From 845c5ba35a2997c32f64e25086753a4880d99e52 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Dec 2023 15:35:41 -0700 Subject: [PATCH 089/240] Updated calc_mpt_cost to have 0 cost and 0 rating for hvdc system. --- ORBIT/phases/design/electrical_export.py | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 81889494..22725f4d 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -285,7 +285,7 @@ def calc_num_substations(self): self._design = self.config.get("substation_design", {}) - substation_capacity = 1200 # MW + hvac_substation_capacity = 1200 # MW if ( self.cable.cable_type == "HVDC-monopole" @@ -297,7 +297,7 @@ def calc_num_substations(self): else: self.num_substations = self._design.get( "num_substations", - int(np.ceil(self._plant_capacity / substation_capacity)), + int(np.ceil(self._plant_capacity / hvac_substation_capacity)), ) @property @@ -318,18 +318,23 @@ def calc_mpt_cost(self): """Computes transformer cost""" self.num_mpt = self.num_cables - if self.cable.cable_type == "HVDC-monopole": - self.mpt_cost = self.num_cables * self._design.get("mpt_cost", 0) - elif self.cable.cable_type == "HVDC-bipole": - self.mpt_cost = self.num_cables * self._design.get("mpt_cost", 0) + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): + self.mpt_cost = 0 + self.mpt_rating = 0 + else: self.mpt_cost = self.num_cables * self._design.get( "mpt_cost", 2.87e6 ) - self.mpt_rating = ( - round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 - ) + + self.mpt_rating = ( + round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) + * 10.0 + ) def calc_shunt_reactor_cost(self): """Computes shunt reactor cost""" From 5c120815d5b4db9d6bf1dc8ebd636022565b7270 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Dec 2023 15:44:30 -0700 Subject: [PATCH 090/240] Updated calc_dc_breaker to make sure the cost is 0 for hvac cases --- ORBIT/phases/design/electrical_export.py | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 22725f4d..bd7c63d5 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -365,23 +365,25 @@ def calc_switchgear_costs(self): num_switchgear = 0 else: num_switchgear = self.num_cables + self.switchgear_cost = num_switchgear * self._design.get( "switchgear_cost", 4e6 ) def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost""" - if self.cable.cable_type == "HVDC-monopole": - self.dc_breaker_cost = self.num_cables * self._design.get( - "breaker_cost", 10.5e6 - ) - elif self.cable.cable_type == "HVDC-bipole": - self.dc_breaker_cost = self.num_cables * self._design.get( - "breaker_cost", 17.5e6 - ) + if ( + self.cable.cable_type == "HVDC-monopole" + or self.cable.cable_type == "HVDC-bipole" + ): + num_dc_breakers = self.num_cables else: - self.dc_breaker_cost = 0 + num_dc_breakers = 0 + + self.dc_breaker_cost = num_dc_breakers * self._design.get( + "breaker_cost", 10.5e6 + ) def calc_ancillary_system_cost(self): """ From 6699b9fa2c4c2c480a48596b6afd4badd37d4ad1 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Dec 2023 17:35:51 -0700 Subject: [PATCH 091/240] Updated test_electrical_design and commented out sections that break. Temporarily --- tests/phases/design/test_electrical_design.py | 32 ++++++++----------- 1 file changed, 14 insertions(+), 18 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 605ea434..be186739 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -8,6 +8,7 @@ from itertools import product import pytest + from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ElectricalDesign @@ -32,7 +33,6 @@ ), ) def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): - config = { "site": {"distance_to_landfall": distance_to_landfall, "depth": depth}, "plant": {"capacity": plant_cap}, @@ -48,21 +48,20 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): # Check valid substructure mass assert ( - 200 <= o._outputs["offshore_substation_substructure"]["mass"] <= 2500 + 200 <= o._outputs["offshore_substation_substructure"]["mass"] <= 2700 ) # Check valid topside mass - assert 200 <= o._outputs["offshore_substation_topside"]["mass"] <= 5000 + assert 200 <= o._outputs["offshore_substation_topside"]["mass"] <= 5500 # Check valid substation cost - assert 1e6 <= o.total_cost <= 1e9 + assert 1e6 <= o.total_substation_cost <= 1e9 def test_ac_oss_kwargs(): - test_kwargs = { - "mpt_cost_rate": 13500, - "topside_fab_cost_rate": 17000, + # "mpt_cost_rate": 13500, # breaks + # "topside_fab_cost_rate": 17000, # breaks "topside_design_cost": 7e6, "shunt_cost_rate": 40000, "switchgear_cost": 15e5, @@ -80,7 +79,6 @@ def test_ac_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v @@ -93,7 +91,11 @@ def test_ac_oss_kwargs(): def test_dc_oss_kwargs(): - test_kwargs = {"converter_cost": 300e6, "dc_breaker_cost": 300e6} + test_kwargs = { + "converter_cost": 300e6, + # "dc_breaker_cost": 300e6 # breaks here + } + dc_base = deepcopy(base) dc_base["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" o = ElectricalDesign(dc_base) @@ -101,7 +103,6 @@ def test_dc_oss_kwargs(): base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): - config = deepcopy(base) config["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" config["substation_design"] = {} @@ -123,7 +124,8 @@ def test_hvdc_substation(): assert o.shunt_reactor_cost == 0 assert o.dc_breaker_cost != 0 assert o.switchgear_cost == 0 - assert o.num_cables / o.num_converters == 2 + assert o.mpt_cost == 0 + # assert o.num_cables / o.num_converters == 2 # breaks config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} @@ -131,14 +133,13 @@ def test_hvdc_substation(): o = ElectricalDesign(config) o.run() - assert o.num_converters == o.num_cables + # assert o.num_converters == o.num_cables # breaks # EXPORT CABLE TESTING def test_export_kwargs(): - test_kwargs = { "num_redundant": 2, "touchdown_distance": 50, @@ -150,7 +151,6 @@ def test_export_kwargs(): base_cost = o.total_cost for k, v in test_kwargs.items(): - config = deepcopy(base) config["export_system_design"] = {"cables": "XLPE_630mm_220kV"} config["export_system_design"][k] = v @@ -257,7 +257,6 @@ def test_design_result(): def test_floating_length_calculations(): - base = deepcopy(config) base["site"]["depth"] = 250 base["export_system_design"]["touchdown_distance"] = 0 @@ -277,7 +276,6 @@ def test_floating_length_calculations(): def test_HVDC_cable(): - base = deepcopy(config) base["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} @@ -296,7 +294,6 @@ def test_HVDC_cable(): def test_num_crossing(): - base_sim = ElectricalDesign(config) base_sim.run() @@ -310,7 +307,6 @@ def test_num_crossing(): def test_cost_crossing(): - base_sim = ElectricalDesign(config) base_sim.run() From c8600cfe685126459c3f87f889289e74db86d2b8 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 13 Dec 2023 08:17:05 -0700 Subject: [PATCH 092/240] reverted name of electrical_design.py to electrical_export to match other branches --- ORBIT/phases/design/__init__.py | 1 - ORBIT/phases/design/electrical_export.py | 40 ++++++++++++++++-------- 2 files changed, 27 insertions(+), 14 deletions(-) diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 120d1e83..8ef543e0 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -16,4 +16,3 @@ from .mooring_system_design import MooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign -from .electrical_export import ElectricalDesign diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index bd7c63d5..e722302c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -31,7 +31,7 @@ class ElectricalDesign(CableSystem): }, }, "substation_design": { - "mpt_cost_rate": "USD/MW (optional)", + "mpt_cost": "USD (optional)", "topside_fab_cost_rate": "USD/t (optional)", "topside_design_cost": "USD (optional)", "shunt_cost_rate": "USD/MW (optional)", @@ -315,7 +315,14 @@ def substation_cost(self): ) / self.num_substations def calc_mpt_cost(self): - """Computes transformer cost""" + """Computes transformer cost + + Parameters + ---------- + mpt_cost : int | float + """ + + mpt_cost = self._design.get("mpt_cost", 2.87e6) self.num_mpt = self.num_cables @@ -327,9 +334,7 @@ def calc_mpt_cost(self): self.mpt_rating = 0 else: - self.mpt_cost = self.num_cables * self._design.get( - "mpt_cost", 2.87e6 - ) + self.mpt_cost = self.num_mpt * mpt_cost self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) @@ -337,9 +342,15 @@ def calc_mpt_cost(self): ) def calc_shunt_reactor_cost(self): - """Computes shunt reactor cost""" + """Computes shunt reactor cost + + Parameters + ---------- + shunt_cost_rate : int | float + """ touchdown = self.config["site"]["distance_to_landfall"] + shunt_cost_rate = self._design.get("shunt_cost_rate", 1e4) if ( self.cable.cable_type == "HVDC-monopole" @@ -350,9 +361,7 @@ def calc_shunt_reactor_cost(self): for _, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - compensation - * self._design.get("shunt_cost_rate", 1e4) - * self.num_cables + compensation * shunt_cost_rate * self.num_cables ) def calc_switchgear_costs(self): @@ -371,7 +380,14 @@ def calc_switchgear_costs(self): ) def calc_dc_breaker_cost(self): - """Computes HVDC circuit breaker cost""" + """Computes HVDC circuit breaker cost + + Parameters + ---------- + dc_breaker_cost : int | float + """ + + dc_breaker_cost = self._design.get("dc_breaker_cost", 10.5e6) if ( self.cable.cable_type == "HVDC-monopole" @@ -381,9 +397,7 @@ def calc_dc_breaker_cost(self): else: num_dc_breakers = 0 - self.dc_breaker_cost = num_dc_breakers * self._design.get( - "breaker_cost", 10.5e6 - ) + self.dc_breaker_cost = num_dc_breakers * dc_breaker_cost def calc_ancillary_system_cost(self): """ From 15dee4cbf2b2592e95f2bf468795f9ea89f8e02f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Dec 2023 10:38:41 -0700 Subject: [PATCH 093/240] Renamed XLPE 1000mm cable config files. Cleaned up comments in cable config files. Removed outdated _DC file. --- .../{XLPE_1000m_220kV.yaml => XLPE_1000mm_220kV.yaml} | 4 ++-- ...0kV_dynamic.yaml => XLPE_1000mm_220kV_dynamic.yaml} | 4 ++-- library/cables/XLPE_1200m_300kV_DC.yaml | 10 ---------- 3 files changed, 4 insertions(+), 14 deletions(-) rename library/cables/{XLPE_1000m_220kV.yaml => XLPE_1000mm_220kV.yaml} (81%) rename library/cables/{XLPE_1000m_220kV_dynamic.yaml => XLPE_1000mm_220kV_dynamic.yaml} (77%) delete mode 100644 library/cables/XLPE_1200m_300kV_DC.yaml diff --git a/library/cables/XLPE_1000m_220kV.yaml b/library/cables/XLPE_1000mm_220kV.yaml similarity index 81% rename from library/cables/XLPE_1000m_220kV.yaml rename to library/cables/XLPE_1000mm_220kV.yaml index df8ac888..8e4e794a 100644 --- a/library/cables/XLPE_1000m_220kV.yaml +++ b/library/cables/XLPE_1000mm_220kV.yaml @@ -1,10 +1,10 @@ ac_resistance: 0.16 # ohm/km capacitance: 190 # nF/km conductor_size: 1000 # mm^2 -cost_per_km: 1420000 # $ 850k +cost_per_km: 1420000 # $ current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km +rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_1000m_220kV -rated_voltage: 220 diff --git a/library/cables/XLPE_1000m_220kV_dynamic.yaml b/library/cables/XLPE_1000mm_220kV_dynamic.yaml similarity index 77% rename from library/cables/XLPE_1000m_220kV_dynamic.yaml rename to library/cables/XLPE_1000mm_220kV_dynamic.yaml index e6d88e3e..26f5ed8c 100644 --- a/library/cables/XLPE_1000m_220kV_dynamic.yaml +++ b/library/cables/XLPE_1000mm_220kV_dynamic.yaml @@ -1,10 +1,10 @@ ac_resistance: 0.16 # ohm/km capacitance: 190 # nF/km conductor_size: 1000 # mm^2 -cost_per_km: 1700000 # $ +cost_per_km: 1700000 # $ 20% cost increase current_capacity: 825 # A inductance: 0.38 # mH/km linear_density: 115 # t/km +rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_1000m_220kV_dynamic -rated_voltage: 220 diff --git a/library/cables/XLPE_1200m_300kV_DC.yaml b/library/cables/XLPE_1200m_300kV_DC.yaml deleted file mode 100644 index 54dd1064..00000000 --- a/library/cables/XLPE_1200m_300kV_DC.yaml +++ /dev/null @@ -1,10 +0,0 @@ -ac_resistance: 0 # ohm/km -capacitance: 0 # nF/km -conductor_size: 1200 # mm^2 -cost_per_km: 835000 # $ -current_capacity: 1458 # A -inductance: 0 # mH/km -linear_density: 44 # t/km -cable_type: HVDC-monopole # HVDC vs HVAC -name: XLPE_1200m_300kV -rated_voltage: 300 From 1fe347a1eca68f730d8759e6517d7f8f84082962 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Dec 2023 10:42:24 -0700 Subject: [PATCH 094/240] Cleaned up comments in cable config files. --- library/cables/HVDC_2000mm_320kV.yaml | 5 ++--- library/cables/HVDC_2000mm_320kV_dynamic.yaml | 5 ++--- library/cables/HVDC_2000mm_400kV.yaml | 2 +- library/cables/HVDC_2500mm_525kV.yaml | 5 ++--- library/cables/XLPE_1200mm_275kV.yaml | 3 +-- library/cables/XLPE_1600mm_275kV.yaml | 3 +-- library/cables/XLPE_1900mm_275kV.yaml | 5 ++--- library/cables/XLPE_500mm_220kV.yaml | 2 +- library/cables/XLPE_630mm_220kV.yaml | 2 +- library/cables/XLPE_800mm_220kV.yaml | 2 +- 10 files changed, 14 insertions(+), 20 deletions(-) diff --git a/library/cables/HVDC_2000mm_320kV.yaml b/library/cables/HVDC_2000mm_320kV.yaml index 615de0e0..b33e25b3 100644 --- a/library/cables/HVDC_2000mm_320kV.yaml +++ b/library/cables/HVDC_2000mm_320kV.yaml @@ -1,11 +1,10 @@ -# Copper from Prysmian ac_resistance: 0 # ohm/km capacitance: 295000 # nF/km conductor_size: 2000 # mm^2 -cost_per_km: 828000 # $ 500k +cost_per_km: 828000 # $ current_capacity: 1900 # A # ESTIMATE inductance: 0.127 # mH/km linear_density: 53 # t/km +rated_voltage: 320 # kV cable_type: HVDC-monopole # HVDC vs HVAC name: HVDC_2000mm_320kV -rated_voltage: 320 diff --git a/library/cables/HVDC_2000mm_320kV_dynamic.yaml b/library/cables/HVDC_2000mm_320kV_dynamic.yaml index bceee48c..3c8ec76b 100644 --- a/library/cables/HVDC_2000mm_320kV_dynamic.yaml +++ b/library/cables/HVDC_2000mm_320kV_dynamic.yaml @@ -1,11 +1,10 @@ -# Copper from Prysmian ac_resistance: 0 # ohm/km capacitance: 295000 # nF/km conductor_size: 2000 # mm^2 -cost_per_km: 993600 # $ +cost_per_km: 993600 # $ 20% cost increase current_capacity: 1900 # A # ESTIMATE inductance: 0.127 # mH/km linear_density: 53 # t/km +rated_voltage: 320 # kV cable_type: HVDC-monopole # HVDC vs HVAC name: HVDC_2000mm_320kV_dynamic -rated_voltage: 320 diff --git a/library/cables/HVDC_2000mm_400kV.yaml b/library/cables/HVDC_2000mm_400kV.yaml index 986c387a..0719ac59 100644 --- a/library/cables/HVDC_2000mm_400kV.yaml +++ b/library/cables/HVDC_2000mm_400kV.yaml @@ -5,6 +5,6 @@ cost_per_km: 620000 # $ current_capacity: 1900 # A inductance: 0.141 # mH/km linear_density: 59 # t/km +rated_voltage: 400 # kV cable_type: HVDC-monopole # HVDC vs HVAC name: HVDC_2000mm_400kV -rated_voltage: 400 diff --git a/library/cables/HVDC_2500mm_525kV.yaml b/library/cables/HVDC_2500mm_525kV.yaml index f5f9c60c..ffeb6330 100644 --- a/library/cables/HVDC_2500mm_525kV.yaml +++ b/library/cables/HVDC_2500mm_525kV.yaml @@ -1,11 +1,10 @@ -# Copper from Prysmian ac_resistance: 0 # ohm/km capacitance: 227000 # nF/km conductor_size: 2500 # mm^2 -cost_per_km: 1420000 # $ 825k +cost_per_km: 1420000 # $ current_capacity: 1905 # A inductance: 0.149 # mH/km linear_density: 74 # t/km +rated_voltage: 525 # kV cable_type: HVDC-bipole # HVDC vs HVAC name: HVDC_2500mm_525kV -rated_voltage: 525 diff --git a/library/cables/XLPE_1200mm_275kV.yaml b/library/cables/XLPE_1200mm_275kV.yaml index 3ec31c86..9fcbceab 100644 --- a/library/cables/XLPE_1200mm_275kV.yaml +++ b/library/cables/XLPE_1200mm_275kV.yaml @@ -1,4 +1,3 @@ -# from Prysmian ac_resistance: 0.026 # ohm/km capacitance: 196 # nF/km conductor_size: 1200 # mm^2 @@ -6,6 +5,6 @@ cost_per_km: 1300000 # $ current_capacity: 547 # A # ESTIMATE inductance: 0.37 # mH/km linear_density: 148 # t/km +rated_voltage: 275 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_1200mm_275kV -rated_voltage: 275 diff --git a/library/cables/XLPE_1600mm_275kV.yaml b/library/cables/XLPE_1600mm_275kV.yaml index 6a28b149..2276c988 100644 --- a/library/cables/XLPE_1600mm_275kV.yaml +++ b/library/cables/XLPE_1600mm_275kV.yaml @@ -1,4 +1,3 @@ -# from Prysmian ac_resistance: 0.022 # ohm/km capacitance: 221 # nF/km conductor_size: 1600 # mm^2 @@ -6,6 +5,6 @@ cost_per_km: 1500000 # $ current_capacity: 730 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 176 # t/km +rated_voltage: 275 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_1600mm_275kV -rated_voltage: 275 diff --git a/library/cables/XLPE_1900mm_275kV.yaml b/library/cables/XLPE_1900mm_275kV.yaml index 9ec49a9e..1e8fac7d 100644 --- a/library/cables/XLPE_1900mm_275kV.yaml +++ b/library/cables/XLPE_1900mm_275kV.yaml @@ -1,11 +1,10 @@ -# from Prysmian ac_resistance: 0.020 # ohm/km capacitance: 224 # nF/km conductor_size: 1900 # mm^2 -cost_per_km: 1280000 # $ 170k +cost_per_km: 1280000 # $ current_capacity: 910 # A # ESTIMATE inductance: 0.35 # mH/km linear_density: 185 # t/km +rated_voltage: 275 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_1900mm_275kV -rated_voltage: 275 diff --git a/library/cables/XLPE_500mm_220kV.yaml b/library/cables/XLPE_500mm_220kV.yaml index c602bbf4..c0939a21 100644 --- a/library/cables/XLPE_500mm_220kV.yaml +++ b/library/cables/XLPE_500mm_220kV.yaml @@ -5,6 +5,6 @@ cost_per_km: 665000 # $ current_capacity: 655 # A inductance: 0.43 # mH/km linear_density: 90 # t/km +rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_500mm_220kV -rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_630mm_220kV.yaml b/library/cables/XLPE_630mm_220kV.yaml index ff5e4820..10825289 100644 --- a/library/cables/XLPE_630mm_220kV.yaml +++ b/library/cables/XLPE_630mm_220kV.yaml @@ -5,6 +5,6 @@ cost_per_km: 710000 # $ current_capacity: 715 # A inductance: 0.41 # mH/km linear_density: 96 # t/km +rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_630mm_220kV -rated_voltage: 220 \ No newline at end of file diff --git a/library/cables/XLPE_800mm_220kV.yaml b/library/cables/XLPE_800mm_220kV.yaml index 18ed6b96..151748d0 100644 --- a/library/cables/XLPE_800mm_220kV.yaml +++ b/library/cables/XLPE_800mm_220kV.yaml @@ -5,6 +5,6 @@ cost_per_km: 776000 # $ current_capacity: 775 # A inductance: 0.40 # mH/km linear_density: 105 # t/km +rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC name: XLPE_800mm_220kV -rated_voltage: 220 \ No newline at end of file From fedecdd0f50232fff014219d203fb791946176f8 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Dec 2023 10:43:32 -0700 Subject: [PATCH 095/240] adjusted test_electrical_design to call correct kwargs. --- tests/phases/design/test_electrical_design.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index be186739..1d0101de 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -60,7 +60,7 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_ac_oss_kwargs(): test_kwargs = { - # "mpt_cost_rate": 13500, # breaks + "mpt_cost": 13500, # "topside_fab_cost_rate": 17000, # breaks "topside_design_cost": 7e6, "shunt_cost_rate": 40000, @@ -91,10 +91,7 @@ def test_ac_oss_kwargs(): def test_dc_oss_kwargs(): - test_kwargs = { - "converter_cost": 300e6, - # "dc_breaker_cost": 300e6 # breaks here - } + test_kwargs = {"converter_cost": 300e6, "dc_breaker_cost": 300e6} dc_base = deepcopy(base) dc_base["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" From 290e74cf2ef20d6151229d180d80197467a34704 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Dec 2023 15:43:10 -0700 Subject: [PATCH 096/240] Updated docs for intro and manager modules --- docs/source/doc_ParametricManager.rst | 11 +++++++++++ docs/source/doc_ProjectManager.rst | 11 +++++++++++ docs/source/intro/bos.rst | 9 +++++++++ docs/source/methods.rst | 2 ++ 4 files changed, 33 insertions(+) create mode 100644 docs/source/doc_ParametricManager.rst create mode 100644 docs/source/doc_ProjectManager.rst diff --git a/docs/source/doc_ParametricManager.rst b/docs/source/doc_ParametricManager.rst new file mode 100644 index 00000000..ec825223 --- /dev/null +++ b/docs/source/doc_ParametricManager.rst @@ -0,0 +1,11 @@ +.. _managertoc: + +Parametric Manager +============= + +The following pages cover the methodology behind the parametric manager. For +more details of the code implementation, please see :doc:`Parametric Manager API `. + +.. note:: + + Page currently under construction. diff --git a/docs/source/doc_ProjectManager.rst b/docs/source/doc_ProjectManager.rst new file mode 100644 index 00000000..c40b90e3 --- /dev/null +++ b/docs/source/doc_ProjectManager.rst @@ -0,0 +1,11 @@ +.. _managertoc: + +Project Manager +============= + +The following pages cover the methodology behind the project manager. For +more details of the code implementation, please see :doc:`Project Manager API `. + +.. note:: + + Page currently under construction. diff --git a/docs/source/intro/bos.rst b/docs/source/intro/bos.rst index 30b672ca..44806dbd 100644 --- a/docs/source/intro/bos.rst +++ b/docs/source/intro/bos.rst @@ -10,6 +10,15 @@ The balance-of-system (BOS) costs of an offshore wind plant include: - Onshore construction costs required to connect the turbine to the grid - Port fees and commissioning costs +.. note:: + + ORBIT does not specify a dollar-year when calculating BOS cost and it does + not account for inflation. To provide a flexible and adaptable simulation + model, components of the wind plant may incorporate `default` cost values. + Please advise that these values are approximated using avaiable information + or best-guess. To improve the fidelity of this tool, users should consider + replacing the `default` values with better informed costs. + Evaluating BOS costs is complicated by the large number of design choices for each component, the impact of weather delays on the installation processes, the challenge of transporting and hoisting large components at sea, the variation diff --git a/docs/source/methods.rst b/docs/source/methods.rst index db3db7da..24ea96ed 100644 --- a/docs/source/methods.rst +++ b/docs/source/methods.rst @@ -6,5 +6,7 @@ Methodology .. toctree:: :maxdepth: 2 + doc_ProjectManager + doc_ParametricManager doc_DesignPhase doc_InstallPhase From d3cb96cae54959e734b8b625e14f96070330aeaa Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 15 Dec 2023 12:58:34 -0700 Subject: [PATCH 097/240] Cleaning up comments in electrical_export and updating ProjectManager doc --- ORBIT/phases/design/electrical_export.py | 48 ++++++++++++++++++++---- docs/source/doc_ProjectManager.rst | 42 ++++++++++++++++++++- 2 files changed, 81 insertions(+), 9 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index e722302c..c722b882 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -14,8 +14,30 @@ class ElectricalDesign(CableSystem): """ Design phase for export cabling and offshore substation systems. + Attributes + ---------- + num_cables : int + Total number of cables required for transmitting power. + length : float + Length of a single cable connecting the OSS to the interconnection + in km. + mass : float + Mass of `length` in tonnes. + cable : `Cable` + Instance of `ORBIT.phases.design.Cable`. An export system will + only require a single type of cable. + total_length : float + Total length of cable required to trasmit power. + total_mass : float + Total mass of cable required to transmit power. + sections_cables : np.ndarray, shape: (`num_cables, ) + An array of `cable`. + sections_lengths : np.ndarray, shape: (`num_cables, ) + An array of `length`. + """ + #: expected_config = { "site": {"distance_to_landfall": "km", "depth": "m"}, "landfall": {"interconnection_distance": "km (optional)"}, @@ -189,7 +211,14 @@ def compute_number_cables(self): """ Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. + + Parameters + ---------- + num_redundant : int """ + + _num_redundant = self._design.get("num_redundant", 0) + if ( self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole" @@ -197,12 +226,12 @@ def compute_number_cables(self): num_required = 2 * np.ceil( self._plant_capacity / self.cable.cable_power ) - num_redundant = 2 * self._design.get("num_redundant", 0) + num_redundant = 2 * _num_redundant else: num_required = np.ceil( self._plant_capacity / self.cable.cable_power ) - num_redundant = self._design.get("num_redundant", 0) + num_redundant = _num_redundant self.num_cables = int(num_required + num_redundant) @@ -331,7 +360,7 @@ def calc_mpt_cost(self): or self.cable.cable_type == "HVDC-bipole" ): self.mpt_cost = 0 - self.mpt_rating = 0 + self.mpt_rating = 0 # added by NSR else: self.mpt_cost = self.num_mpt * mpt_cost @@ -365,7 +394,14 @@ def calc_shunt_reactor_cost(self): ) def calc_switchgear_costs(self): - """Computes switchgear cost""" + """Computes switchgear cost + + Parameters + ---------- + switchgear_cost : int | float + """ + + switchgear_cost = self._design.get("switchgear_cost", 4e6) if ( self.cable.cable_type == "HVDC-monopole" @@ -375,9 +411,7 @@ def calc_switchgear_costs(self): else: num_switchgear = self.num_cables - self.switchgear_cost = num_switchgear * self._design.get( - "switchgear_cost", 4e6 - ) + self.switchgear_cost = num_switchgear * switchgear_cost def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost diff --git a/docs/source/doc_ProjectManager.rst b/docs/source/doc_ProjectManager.rst index c40b90e3..6bf81e32 100644 --- a/docs/source/doc_ProjectManager.rst +++ b/docs/source/doc_ProjectManager.rst @@ -3,9 +3,47 @@ Project Manager ============= -The following pages cover the methodology behind the project manager. For -more details of the code implementation, please see :doc:`Project Manager API `. +The following pages cover the methodology behind the project manager. .. note:: Page currently under construction. + +Overview +-------- +The ``ProjectManager`` is the primary system for interacting with ORBIT to simulate +a wind project. Users can customize their project by specifying a a wide variety of +parameters as a dictionary (see tutorial: :ref:`Project Manager Tutorial `). +For more details of the code implementation, please see :doc:`Project Manager API `. + +It instantiates a class aggregates project parameters, specifies a start date, and interprets a weather +profile, and it employs a collection of decorators, `methods`, and `classmethods` to run the simulation. +Among these methods are `design_phases` and `install_phases` that serve as components to the simulation. +Additionally, some methods search and catch key errors to avoid simulation issues, export progress logs, +and save the outputs. + +Run +--- +This method checks to see if a design or install phase is instatiated prior to running them. Depending on +which design phases are specified, each phase is run in no particular order and the results are added to +`.design_results` dictionary. Conversely, the install phases can be run sequentially or as overlapped +processes (see example: :ref:`Overlapping install `). It is worth noting, that ORBIT +has built in logic to determine any dependency between install phases. + +Properties +---------- +The `@property` decorators allow the ``ProjectManager`` to access and manipulate the attributes of certain classes. Of the +several properties some important ones are: + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + +- capex_categories: CapEx Categories +- npv: Net Present Value + +Finally, these attributes are collected in an `output` dictionary. + +References +---------- +Stehly, Tyler, and Philipp Beiter. 2019. “2018 Cost of Wind Energy Review.” Renewable Energy. https://www.nrel.gov/docs/fy20osti/74598.pdf. From e21302ab0a787f8fffe7fcdc5c172d571ae5c554 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Fri, 22 Dec 2023 14:46:26 -0500 Subject: [PATCH 098/240] onshore test added, onshore_cost debug --- ORBIT/phases/design/electrical_export.py | 4 ++-- tests/phases/design/test_electrical_design.py | 18 +++++++++++++++++- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index d485a50f..700a7396 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -518,7 +518,7 @@ def calc_onshore_cost(self): * self._design.get("onshore_converter_cost", 157e6) ) self.ais_cost = 0 - self.onshore_construction = 87.3e6 + self.onshore_construction = 87.3e6 * self.num_substations self.onshore_compensation = 0 elif self.cable.cable_type == "HVDC-bipole": self.onshore_converter_cost = ( @@ -526,7 +526,7 @@ def calc_onshore_cost(self): * self._design.get("onshore_converter_cost", 350e6) ) self.ais_cost = 0 - self.onshore_construction = 100e6 + self.onshore_construction = 100e6 * self.num_substations self.onshore_compensation = 0 else: self.onshore_converter_cost = 0 diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 605ea434..aac027be 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -116,7 +116,7 @@ def test_dc_oss_kwargs(): def test_hvdc_substation(): config = deepcopy(base) - config["export_system_design"] = {"cables": "XLPE_1200m_300kV_DC"} + config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} o = ElectricalDesign(config) o.run() assert o.converter_cost != 0 @@ -133,6 +133,22 @@ def test_hvdc_substation(): assert o.num_converters == o.num_cables +def test_onshore_substation(): + config = deepcopy(base) + o = ElectricalDesign(config) + o.run() + assert o.onshore_cost == 448.61e6 + + config_mono = {"cables": "HVDC_2000mm_320kV"} + o_mono = ElectricalDesign(config_mono) + o_mono.run() + assert o_mono.onshore_cost == 244.3e6 + + config_bi = {"cables": "HVDC_2500mm_525kV"} + o_bi = ElectricalDesign(config_bi) + o_bi.run() + assert o_bi.onshore_cost == 450e6 + # EXPORT CABLE TESTING From 1345f68754bdd6a8e014883b9757eb79e24062d7 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Fri, 22 Dec 2023 14:46:43 -0500 Subject: [PATCH 099/240] onshore test added, onshore_cost debug --- ORBIT/phases/design/electrical_export.py | 27 +++++++------------ tests/phases/design/test_electrical_design.py | 5 ++-- 2 files changed, 13 insertions(+), 19 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 700a7396..b0b87c36 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -436,22 +436,21 @@ def calc_substructure_mass_and_cost(self): oss_substructure_cost_rate : int | float oss_pile_cost_rate : int | float """ - + _design = self.config.get("substation_design", {}) substructure_mass = 0.4 * self.topside_mass oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) oss_substructure_cost_rate = _design.get( "oss_substructure_cost_rate", 3000 ) - + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( - substructure_mass * oss_substructure_cost_rate - + substructure_pile_mass * oss_pile_cost_rate + substructure_mass * oss_substructure_cost_rate + + substructure_pile_mass * oss_pile_cost_rate ) - - self.substructure_mass = substructure_mass + substructure_pile_mass + self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): """ @@ -489,25 +488,19 @@ def calc_topside_mass_and_cost(self): """ _design = self.config.get("substation_design", {}) - #topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) - #topside_design_cost = _design.get("topside_design_cost", 4.5e6) + # topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) + # topside_design_cost = _design.get("topside_design_cost", 4.5e6) self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 ) if self.cable.cable_type == "HVDC-monopole": - self.topside_cost = _design.get( - "topside_design_cost", 294e6 - ) + self.topside_cost = _design.get("topside_design_cost", 294e6) elif self.cable.cable_type == "HVDC-bipole": - self.topside_cost = _design.get( - "topside_design_cost", 476e6 - ) + self.topside_cost = _design.get("topside_design_cost", 476e6) else: - self.topside_cost = _design.get( - "topside_design_cost", 107.3e6 - ) + self.topside_cost = _design.get("topside_design_cost", 107.3e6) def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index aac027be..cd33380e 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -133,17 +133,18 @@ def test_hvdc_substation(): assert o.num_converters == o.num_cables + def test_onshore_substation(): config = deepcopy(base) o = ElectricalDesign(config) o.run() assert o.onshore_cost == 448.61e6 - + config_mono = {"cables": "HVDC_2000mm_320kV"} o_mono = ElectricalDesign(config_mono) o_mono.run() assert o_mono.onshore_cost == 244.3e6 - + config_bi = {"cables": "HVDC_2500mm_525kV"} o_bi = ElectricalDesign(config_bi) o_bi.run() From c33851b341868fe5b6c68ea6aacfc4b9ac32eb64 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 28 Dec 2023 13:02:00 -0700 Subject: [PATCH 100/240] removed mpt = 0 for hvdc condition --- ORBIT/phases/design/electrical_export.py | 1 - 1 file changed, 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 5d26137b..992f27b3 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -360,7 +360,6 @@ def calc_mpt_cost(self): or self.cable.cable_type == "HVDC-bipole" ): self.mpt_cost = 0 - self.mpt_rating = 0 # added by NSR else: self.mpt_cost = self.num_mpt * mpt_cost From 2f30803dbcde4557c33217d9387b3a3751dabb96 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 4 Jan 2024 17:22:56 -0700 Subject: [PATCH 101/240] Updated test_electrical_design to use non-test hvdc cable --- tests/phases/design/test_electrical_design.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 7c697435..782234db 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -29,7 +29,7 @@ range(10, 201, 50), range(10, 51, 10), range(100, 2001, 500), - ["XLPE_630mm_220kV", "XLPE_800mm_220kV", "XLPE_1000m_220kV"], + ["XLPE_630mm_220kV", "XLPE_800mm_220kV", "XLPE_1000mm_220kV"], ), ) def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): @@ -94,14 +94,14 @@ def test_dc_oss_kwargs(): test_kwargs = {"converter_cost": 300e6, "dc_breaker_cost": 300e6} dc_base = deepcopy(base) - dc_base["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" + dc_base["export_system_design"]["cables"] = "HVDC_2000mm_320kV" o = ElectricalDesign(dc_base) o.run() base_cost = o.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): config = deepcopy(base) - config["export_system_design"]["cables"] = "XLPE_1200m_300kV_DC" + config["export_system_design"]["cables"] = "HVDC_2000mm_320kV" config["substation_design"] = {} config["substation_design"][k] = v From 986a87dd1e8c56f4a5849c3bc486703053abf4da Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 4 Jan 2024 18:37:31 -0700 Subject: [PATCH 102/240] Adjusted mpt rating bug for hvdc config. Adjusted onshore test --- ORBIT/phases/design/electrical_export.py | 7 +++---- tests/phases/design/test_electrical_design.py | 8 +++++--- 2 files changed, 8 insertions(+), 7 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 992f27b3..5c011f3c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -364,10 +364,9 @@ def calc_mpt_cost(self): else: self.mpt_cost = self.num_mpt * mpt_cost - self.mpt_rating = ( - round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) - * 10.0 - ) + self.mpt_rating = ( + round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 + ) def calc_shunt_reactor_cost(self): """Computes shunt reactor cost diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 782234db..f7e9db16 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -137,14 +137,16 @@ def test_onshore_substation(): config = deepcopy(base) o = ElectricalDesign(config) o.run() - assert o.onshore_cost == 448.61e6 + assert o.onshore_cost == 109.32e6 - config_mono = {"cables": "HVDC_2000mm_320kV"} + config_mono = deepcopy(config) + config_mono["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} o_mono = ElectricalDesign(config_mono) o_mono.run() assert o_mono.onshore_cost == 244.3e6 - config_bi = {"cables": "HVDC_2500mm_525kV"} + config_bi = deepcopy(config) + config_bi["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} o_bi = ElectricalDesign(config_bi) o_bi.run() assert o_bi.onshore_cost == 450e6 From 63800aa96280125572c32e7a4fb5042b66fabba3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 16 Jan 2024 13:13:21 -0700 Subject: [PATCH 103/240] Updating .github workflow file actions to use v4 instead of v2. --- .github/workflows/gh_pages.yml | 4 ++-- .github/workflows/publish-to-pypi.yml | 4 ++-- .github/workflows/tests.yml | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index 96e087f6..cd0f8c1f 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -8,9 +8,9 @@ jobs: make-pages: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: select python version - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: '3.8' - name: install dependencies diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index ee92f5f4..30b1b9e2 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -6,9 +6,9 @@ jobs: deploy: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: Set up Python 3.7 - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: 3.7 - name: Install dependencies diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index bf1b9868..35dce012 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -15,12 +15,12 @@ jobs: python-version: [3.7, 3.8] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 with: ref: ${{ github.event.pull_request.head.ref }} fetch-depth: 1 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Install dependencies From d025d9cc1e997708450264c14268913c37be7a3b Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 16 Jan 2024 13:31:22 -0700 Subject: [PATCH 104/240] Adjusted gh_pages workflow --- .github/workflows/gh_pages.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index cd0f8c1f..215fb4be 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -8,7 +8,7 @@ jobs: make-pages: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v2 - name: select python version uses: actions/setup-python@v4 with: From 7cf27761d1eb430055524c438c6a292b9104b56b Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 16 Jan 2024 13:37:09 -0700 Subject: [PATCH 105/240] Adjusting gh pages workflow again. --- .github/workflows/gh_pages.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index 215fb4be..cd0f8c1f 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -8,7 +8,7 @@ jobs: make-pages: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: select python version uses: actions/setup-python@v4 with: From ba22ca36b428f1f2a66dfc4e9f4da38e7ef91b07 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jan 2024 09:57:37 -0700 Subject: [PATCH 106/240] Updated the checkout and setup-python versions from 2 to 4. Replaced psf/black rev field to latest version. --- .github/workflows/gh_pages.yml | 4 ++-- .github/workflows/publish-to-pypi.yml | 4 ++-- .github/workflows/tests.yml | 4 ++-- .pre-commit-config.yaml | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index 96e087f6..cd0f8c1f 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -8,9 +8,9 @@ jobs: make-pages: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: select python version - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: '3.8' - name: install dependencies diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index ee92f5f4..30b1b9e2 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -6,9 +6,9 @@ jobs: deploy: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: Set up Python 3.7 - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: 3.7 - name: Install dependencies diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index bf1b9868..35dce012 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -15,12 +15,12 @@ jobs: python-version: [3.7, 3.8] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 with: ref: ${{ github.event.pull_request.head.ref }} fetch-depth: 1 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Install dependencies diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 84ca9757..d103462c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -10,7 +10,7 @@ repos: stages: [commit] - repo: https://github.com/psf/black - rev: stable + rev: 22.3.0 hooks: - id: black name: black From 021bd48e234ee3f5e507d05b8aed3293263b4c42 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jan 2024 10:53:06 -0700 Subject: [PATCH 107/240] Removed git ref in the checkout steps --- .github/workflows/tests.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 35dce012..f29cdfb6 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -16,9 +16,6 @@ jobs: steps: - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.ref }} - fetch-depth: 1 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From 863041c7ac38f00e0c04071879177604c9c94de6 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jan 2024 11:06:29 -0700 Subject: [PATCH 108/240] Updated the default cable name in wisdem api --- ORBIT/api/wisdem.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 8320e99c..e3ef787b 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -12,6 +12,8 @@ class Orbit(om.Group): + """Orbit class for WISDEM API""" + def initialize(self): self.options.declare("floating", default=False) self.options.declare("jacket", default=False) @@ -25,7 +27,8 @@ def setup(self): self.set_input_defaults("num_feeders", 1) self.set_input_defaults("num_towing", 1) self.set_input_defaults("num_station_keeping", 3) - self.set_input_defaults("oss_install_vessel", "example_heavy_lift_vessel") + self.set_input_defaults("oss_install_vessel", + "example_heavy_lift_vessel") self.set_input_defaults("site_distance", 40.0, units="km") self.set_input_defaults("site_distance_to_landfall", 40.0, units="km") self.set_input_defaults("interconnection_distance", 40.0, units="km") @@ -41,7 +44,8 @@ def setup(self): self.set_input_defaults("site_auction_price", 100e6, units="USD") self.set_input_defaults("site_assessment_plan_cost", 1e6, units="USD") self.set_input_defaults("site_assessment_cost", 25e6, units="USD") - self.set_input_defaults("construction_operations_plan_cost", 2.5e6, units="USD") + self.set_input_defaults("construction_operations_plan_cost", + 2.5e6, units="USD") self.set_input_defaults("design_install_plan_cost", 2.5e6, units="USD") self.set_input_defaults("boem_review_cost", 0.0, units="USD") @@ -290,7 +294,7 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o "cables": ["XLPE_630mm_66kV", "XLPE_185mm_66kV"], }, "export_system_design": { - "cables": "XLPE_1000m_220kV", + "cables": "XLPE_1000mm_220kV", "interconnection_distance": float(inputs["interconnection_distance"]), "percent_added_length": 0.1, }, From a9263f556dfdf4591db35b7ef4ba6c849e76b758 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jan 2024 11:17:24 -0700 Subject: [PATCH 109/240] Removed git ref step as part of automated tests. --- .github/workflows/tests.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 35dce012..f29cdfb6 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -16,9 +16,6 @@ jobs: steps: - uses: actions/checkout@v4 - with: - ref: ${{ github.event.pull_request.head.ref }} - fetch-depth: 1 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: From a646dfd401f0f2e6863d5c8b108eb53f4f5fe8c4 Mon Sep 17 00:00:00 2001 From: Bredenkamp Date: Tue, 20 Feb 2024 16:42:05 -0500 Subject: [PATCH 110/240] adjust onshore shunt reactor cost calc --- ORBIT/phases/design/electrical_export.py | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 5c011f3c..1caedc11 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -383,12 +383,12 @@ def calc_shunt_reactor_cost(self): self.cable.cable_type == "HVDC-monopole" or self.cable.cable_type == "HVDC-bipole" ): - compensation = 0 + self.compensation = 0 else: for _, cable in self.cables.items(): - compensation = touchdown * cable.compensation_factor # MW + self.compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - compensation * shunt_cost_rate * self.num_cables + self.compensation * shunt_cost_rate * self.num_cables ) def calc_switchgear_costs(self): @@ -560,6 +560,12 @@ def calc_topside_mass_and_cost(self): def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection""" + self.onshore_shunt_reactor_cost = ( + self.compensation + * self._design.get("shunt_cost_rate", 1.3e4) + * self.num_cables + ) + if self.cable.cable_type == "HVDC-monopole": self.onshore_converter_cost = ( self.num_substations @@ -579,7 +585,7 @@ def calc_onshore_cost(self): else: self.onshore_converter_cost = 0 self.ais_cost = self.num_cables * 9.33e6 - self.onshore_compensation = self.num_cables * (31.3e6 + 8.66e6) + self.onshore_compensation = self.num_cables * 31.3e6 + self.onshore_shunt_reactor_cost self.onshore_construction = 5e6 * self.num_substations self.onshore_cost = ( From 52fef86c48fa796c2c6d508a4a32fb8d7bc28276 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 29 Feb 2024 15:37:39 -0700 Subject: [PATCH 111/240] Added HVAC/DC example to Example - Parametric Manager --- examples/Example - Parametric Manager.ipynb | 1583 +++++++++++++------ 1 file changed, 1092 insertions(+), 491 deletions(-) diff --git a/examples/Example - Parametric Manager.ipynb b/examples/Example - Parametric Manager.ipynb index 2a17e0ff..e9f8f938 100644 --- a/examples/Example - Parametric Manager.ipynb +++ b/examples/Example - Parametric Manager.ipynb @@ -1,510 +1,1111 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ORBIT Example - ParametricManager\n", - "\n", - "ParametricManager provides a similar interface into ORBIT as ProjectManager but allows for some (or all) inputs to be parameterized. This class is useful for quickly exploring how a module or project scales with certain inputs." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT.phases.design import MonopileDesign\n", - "\n", - "from ORBIT import ParametricManager, ProjectManager" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "text/plain": [ - "{'site': {'depth': 'm', 'mean_windspeed': 'm/s'},\n", - " 'plant': {'num_turbines': 'int'},\n", - " 'turbine': {'rotor_diameter': 'm',\n", - " 'hub_height': 'm',\n", - " 'rated_windspeed': 'm/s'},\n", - " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", - " 'load_factor': 'float (optional)',\n", - " 'material_factor': 'float (optional)',\n", - " 'monopile_density': 'kg/m3 (optional)',\n", - " 'monopile_modulus': 'Pa (optional)',\n", - " 'monopile_tp_connection_thickness': 'm (optional)',\n", - " 'transition_piece_density': 'kg/m3 (optional)',\n", - " 'transition_piece_thickness': 'm (optional)',\n", - " 'transition_piece_length': 'm (optional)',\n", - " 'soil_coefficient': 'N/m3 (optional)',\n", - " 'air_density': 'kg/m3 (optional)',\n", - " 'weibull_scale_factor': 'float (optional)',\n", - " 'weibull_shape_factor': 'float (optional)',\n", - " 'turb_length_scale': 'm (optional)',\n", - " 'monopile_steel_cost': 'USD/t (optional)',\n", - " 'tp_steel_cost': 'USD/t (optional)'}}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ORBIT Example - ParametricManager\n", + "\n", + "ParametricManager provides a similar interface into ORBIT as ProjectManager but allows for some (or all) inputs to be parameterized. This class is useful for quickly exploring how a module or project scales with certain inputs." ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# For this example we will look at the MonopileDesign module.\n", - "MonopileDesign.expected_config" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# The following inputs are the only \"required\" inputs for the MonopileDesign module.\n", - "# Thee 'site' inputs are commented out as they will be defined as parametric inputs below.\n", - "\n", - "base_config = {\n", - "# \"site\": {\n", - "# \"depth\": 20,\n", - "# \"mean_windspeed\": 8\n", - "# }\n", - " \"turbine\": \"12MW_generic\",\n", - " \"plant\": {\n", - " \"num_turbines\": 50\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Parametric inputs:\n", - "\n", - "parameters = {\n", - " \"site.depth\": [20, 40, 60], # The dot-notation allows you to access nested dictionaries\n", - " \"site.mean_windspeed\": [8, 9, 10] # These inputs correspond to the 'depth' and 'mean_windspeed' inputs above, which are nested\n", - "} # in the 'site' dictionary. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Desired results:\n", - "# Since there are so many available results in ORBIT, you have to tell ParametricManager which ones\n", - "# you are interested in for this parametric run. The syntax for this always follows the \n", - "# 'lambda run: run.{output}' format. The {output} can be any output available for the configured module\n", - "\n", - "results = {\n", - " \"capex\": lambda run: run.total_cost\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import MonopileDesign, ElectricalDesign\n", + "\n", + "from ORBIT import ParametricManager, ProjectManager\n", + "\n", + "import numpy as np" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1. Monopile Design Example\n", + "Perform a parametric sweep of site depth and mean wind speed to see the effects on monopile capex." + ] }, { - "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", - "
site.depthsite.mean_windspeedcapex
02082.388521e+08
14093.261239e+08
260104.289900e+08
\n", - "
" + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'site': {'depth': 'm', 'mean_windspeed': 'm/s'},\n", + " 'plant': {'num_turbines': 'int'},\n", + " 'turbine': {'rotor_diameter': 'm',\n", + " 'hub_height': 'm',\n", + " 'rated_windspeed': 'm/s'},\n", + " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", + " 'load_factor': 'float (optional)',\n", + " 'material_factor': 'float (optional)',\n", + " 'monopile_density': 'kg/m3 (optional)',\n", + " 'monopile_modulus': 'Pa (optional)',\n", + " 'monopile_tp_connection_thickness': 'm (optional)',\n", + " 'transition_piece_density': 'kg/m3 (optional)',\n", + " 'transition_piece_thickness': 'm (optional)',\n", + " 'transition_piece_length': 'm (optional)',\n", + " 'soil_coefficient': 'N/m3 (optional)',\n", + " 'air_density': 'kg/m3 (optional)',\n", + " 'weibull_scale_factor': 'float (optional)',\n", + " 'weibull_shape_factor': 'float (optional)',\n", + " 'turb_length_scale': 'm (optional)',\n", + " 'monopile_steel_cost': 'USD/t (optional)',\n", + " 'tp_steel_cost': 'USD/t (optional)'}}" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " site.depth site.mean_windspeed capex\n", - "0 20 8 2.388521e+08\n", - "1 40 9 3.261239e+08\n", - "2 60 10 4.289900e+08" + "source": [ + "# For this example we will look at the MonopileDesign module.\n", + "MonopileDesign.expected_config" ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Pass the above definitions into ParametricManager like this:\n", - "# Note: I only want to run MonopileDesign so I passed it into module directily.\n", - "# If you want to run an entire project (with multiple modules), leave module blank and it will\n", - "# automatically run ProjectManager\n", - "\n", - "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign)\n", - "parametric.run()\n", - "\n", - "\n", - "# By default, ParametricManager doesn't run the product of all parameters and just\n", - "# runs the first set of inputs, then the second set of inputs, etc.\n", - "# In this case, there will only be 3 results\n", - "parametric.results" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "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", - "
site.depthsite.mean_windspeedcapex
02082.388521e+08
12092.545394e+08
220102.705817e+08
34083.062888e+08
44093.261239e+08
540103.463884e+08
66083.798072e+08
76094.041444e+08
860104.289900e+08
\n", - "
" + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# The following inputs are the only \"required\" inputs for the MonopileDesign module.\n", + "# Thee 'site' inputs are commented out as they will be defined as parametric inputs below.\n", + "\n", + "base_config = {\n", + "# \"site\": {\n", + "# \"depth\": 20,\n", + "# \"mean_windspeed\": 8\n", + "# }\n", + " \"turbine\": \"12MW_generic\",\n", + " \"plant\": {\n", + " \"num_turbines\": 50\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# Parametric inputs:\n", + "\n", + "parameters = {\n", + " \"site.depth\": [20, 40, 60], # The dot-notation allows you to access nested dictionaries\n", + " \"site.mean_windspeed\": [8, 9, 10] # These inputs correspond to the 'depth' and 'mean_windspeed' inputs above, which are nested\n", + "} # in the 'site' dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Desired results:\n", + "# Since there are so many available results in ORBIT, you have to tell ParametricManager which ones\n", + "# you are interested in for this parametric run. The syntax for this always follows the\n", + "# 'lambda run: run.{output}' format. The {output} can be any output available for the configured module\n", + "\n", + "results = {\n", + " \"capex\": lambda run: run.total_cost\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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", + "
site.depthsite.mean_windspeedcapex
02082.388521e+08
14093.261239e+08
260104.289900e+08
\n", + "
" + ], + "text/plain": [ + " site.depth site.mean_windspeed capex\n", + "0 20 8 2.388521e+08\n", + "1 40 9 3.261239e+08\n", + "2 60 10 4.289900e+08" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " site.depth site.mean_windspeed capex\n", - "0 20 8 2.388521e+08\n", - "1 20 9 2.545394e+08\n", - "2 20 10 2.705817e+08\n", - "3 40 8 3.062888e+08\n", - "4 40 9 3.261239e+08\n", - "5 40 10 3.463884e+08\n", - "6 60 8 3.798072e+08\n", - "7 60 9 4.041444e+08\n", - "8 60 10 4.289900e+08" + "source": [ + "# Pass the above definitions into ParametricManager like this:\n", + "# Note: I only want to run MonopileDesign so I passed it into module directily.\n", + "# If you want to run an entire project (with multiple modules), leave module blank and it will\n", + "# automatically run ProjectManager\n", + "\n", + "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign)\n", + "parametric.run()\n", + "\n", + "\n", + "# By default, ParametricManager doesn't run the product of all parameters and just\n", + "# runs the first set of inputs, then the second set of inputs, etc.\n", + "# In this case, there will only be 3 results\n", + "parametric.results" ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# To configure ParametricManager to run the product of all inputs, pass 'product=True'\n", - "# This will result in 3x3 results as each combination is ran\n", - "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign, product=True)\n", - "parametric.run()\n", - "\n", - "parametric.results" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "code", + "execution_count": 18, + "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", + "
site.depthsite.mean_windspeedcapex
02082.388521e+08
12092.545394e+08
220102.705817e+08
34083.062888e+08
44093.261239e+08
540103.463884e+08
66083.798072e+08
76094.041444e+08
860104.289900e+08
\n", + "
" + ], + "text/plain": [ + " site.depth site.mean_windspeed capex\n", + "0 20 8 2.388521e+08\n", + "1 20 9 2.545394e+08\n", + "2 20 10 2.705817e+08\n", + "3 40 8 3.062888e+08\n", + "4 40 9 3.261239e+08\n", + "5 40 10 3.463884e+08\n", + "6 60 8 3.798072e+08\n", + "7 60 9 4.041444e+08\n", + "8 60 10 4.289900e+08" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# To configure ParametricManager to run the product of all inputs, pass 'product=True'\n", + "# This will result in 3x3 results as each combination is ran\n", + "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign, product=True)\n", + "parametric.run()\n", + "\n", + "parametric.results" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 runs elapsed time: 0.02s\n", + "27 runs estimated time: 0.06s\n" + ] + }, + { + "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", + "
site.depthsite.mean_windspeedmonopile_design.soil_coefficientcapex
040940000003.261239e+08
160940000004.041444e+08
260840000003.798072e+08
320845000002.371472e+08
420945000002.526935e+08
560850000003.758376e+08
6401050000003.421996e+08
740850000003.027043e+08
840840000003.062888e+08
960950000003.998461e+08
\n", + "
" + ], + "text/plain": [ + " site.depth site.mean_windspeed monopile_design.soil_coefficient \\\n", + "0 40 9 4000000 \n", + "1 60 9 4000000 \n", + "2 60 8 4000000 \n", + "3 20 8 4500000 \n", + "4 20 9 4500000 \n", + "5 60 8 5000000 \n", + "6 40 10 5000000 \n", + "7 40 8 5000000 \n", + "8 40 8 4000000 \n", + "9 60 9 5000000 \n", + "\n", + " capex \n", + "0 3.261239e+08 \n", + "1 4.041444e+08 \n", + "2 3.798072e+08 \n", + "3 2.371472e+08 \n", + "4 2.526935e+08 \n", + "5 3.758376e+08 \n", + "6 3.421996e+08 \n", + "7 3.027043e+08 \n", + "8 3.062888e+08 \n", + "9 3.998461e+08 " + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# If you are configuring many parameters it can take a long time to run, especially if weather is turned on.\n", + "# To get an idea of how long it'll take, you can run the .preview() method:\n", + "\n", + "parameters = {\n", + " \"site.depth\": [20, 40, 60],\n", + " \"site.mean_windspeed\": [8, 9, 10],\n", + " \"monopile_design.soil_coefficient\": [4000000, 4500000, 5000000]\n", + "}\n", + "\n", + "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign, product=True)\n", + "parametric.preview()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Electrical Export Design\n", + "\n", + "Perform a parametric sweep of export cable technology (HVDC or HVAC) and how plant capacity impacts the cable capex." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'site': {'distance_to_landfall': 'km', 'depth': 'm'},\n", + " 'landfall': {'interconnection_distance': 'km (optional)'},\n", + " 'plant': {'capacity': 'MW'},\n", + " 'export_system_design': {'cables': 'str',\n", + " 'num_redundant': 'int (optional)',\n", + " 'touchdown_distance': 'm (optional, default: 0)',\n", + " 'percent_added_length': 'float (optional)',\n", + " 'cable_crossings': {'crossing_number': 'int (optional)',\n", + " 'crossing_unit_cost': 'float (optional)'}},\n", + " 'substation_design': {'mpt_cost': 'USD (optional)',\n", + " 'topside_fab_cost_rate': 'USD/t (optional)',\n", + " 'topside_design_cost': 'USD (optional)',\n", + " 'shunt_cost_rate': 'USD/MW (optional)',\n", + " 'switchgear_cost': 'USD (optional)',\n", + " 'dc_breaker_cost': 'USD (optional)',\n", + " 'backup_gen_cost': 'USD (optional)',\n", + " 'workspace_cost': 'USD (optional)',\n", + " 'other_ancillary_cost': 'USD (optional)',\n", + " 'converter_cost': 'USD (optional)',\n", + " 'onshore_converter_cost': 'USD (optional)',\n", + " 'topside_assembly_factor': 'float (optional)',\n", + " 'oss_substructure_cost_rate': 'USD/t (optional)',\n", + " 'oss_pile_cost_rate': 'USD/t (optional)',\n", + " 'num_substations': 'int (optional)'}}" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ElectricalDesign.expected_config" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "10 runs elapsed time: 0.06s\n", - "27 runs estimated time: 0.15s\n" - ] + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100,\n", + " 'depth': 20,\n", + " 'distance_to_landfall': 50\n", + " },\n", + " 'plant': {\n", + " 'turbine_rating': 10\n", + "# 'capacity': 500\n", + " },\n", + " 'turbine': {'turbine_rating': 10},\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + "# 'export_system_design': {\n", + "# 'cables': 'XLPE_500mm_220kV',\n", + "# }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters\n", + "parameters = {\n", + " 'export_system_design.cables': ['XLPE_1000mm_220kV', 'HVDC_2000mm_320kV'],\n", + " 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] }, { - "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", - "
site.depthsite.mean_windspeedmonopile_design.soil_coefficientcapex
060840000003.798072e+08
140945000003.240537e+08
240940000003.261239e+08
340840000003.062888e+08
4201045000002.685895e+08
520940000002.545394e+08
6601050000004.243511e+08
760940000004.041444e+08
840850000003.027043e+08
920850000002.356558e+08
\n", - "
" + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "# Desired results\n", + "\n", + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + " 'num_cables': lambda run: run.num_cables,\n", + " 'num_substations': lambda run: run.num_substations,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
export_system_design.cablesplant.capacitycable_costoss_costnum_cablesnum_substations
0XLPE_1000mm_220kV10075288400.01.532619e+0711
1XLPE_1000mm_220kV20075288400.01.532619e+0711
2XLPE_1000mm_220kV30075288400.01.532619e+0711
3XLPE_1000mm_220kV400150576800.02.420237e+0721
4XLPE_1000mm_220kV500150576800.02.420237e+0721
5XLPE_1000mm_220kV600150576800.02.420237e+0721
6XLPE_1000mm_220kV700225865200.03.307856e+0731
7XLPE_1000mm_220kV800225865200.03.307856e+0731
8XLPE_1000mm_220kV900225865200.03.307856e+0731
9XLPE_1000mm_220kV1000301153600.04.195474e+0741
10XLPE_1000mm_220kV1100301153600.04.195474e+0741
11XLPE_1000mm_220kV1200301153600.04.195474e+0741
12XLPE_1000mm_220kV1300376442000.02.864046e+0752
13XLPE_1000mm_220kV1400376442000.02.864046e+0752
14XLPE_1000mm_220kV1500376442000.02.864046e+0752
15XLPE_1000mm_220kV1600451730400.03.307856e+0762
16XLPE_1000mm_220kV1700451730400.03.307856e+0762
17XLPE_1000mm_220kV1800451730400.03.307856e+0762
18XLPE_1000mm_220kV1900527018800.03.751665e+0772
19XLPE_1000mm_220kV2000527018800.03.751665e+0772
20HVDC_2000mm_320kV10087801120.01.544500e+0821
21HVDC_2000mm_320kV20087801120.01.544500e+0821
22HVDC_2000mm_320kV30087801120.01.544500e+0821
23HVDC_2000mm_320kV40087801120.01.544500e+0821
24HVDC_2000mm_320kV50087801120.01.544500e+0821
25HVDC_2000mm_320kV60087801120.01.544500e+0821
26HVDC_2000mm_320kV70087801120.01.544500e+0821
27HVDC_2000mm_320kV80087801120.01.544500e+0821
28HVDC_2000mm_320kV90087801120.01.544500e+0821
29HVDC_2000mm_320kV100087801120.01.544500e+0821
30HVDC_2000mm_320kV110087801120.01.544500e+0821
31HVDC_2000mm_320kV120087801120.01.544500e+0821
32HVDC_2000mm_320kV1300175602240.01.544500e+0842
33HVDC_2000mm_320kV1400175602240.01.544500e+0842
34HVDC_2000mm_320kV1500175602240.01.544500e+0842
35HVDC_2000mm_320kV1600175602240.01.544500e+0842
36HVDC_2000mm_320kV1700175602240.01.544500e+0842
37HVDC_2000mm_320kV1800175602240.01.544500e+0842
38HVDC_2000mm_320kV1900175602240.01.544500e+0842
39HVDC_2000mm_320kV2000175602240.01.544500e+0842
\n", + "
" + ], + "text/plain": [ + " export_system_design.cables plant.capacity cable_cost oss_cost \\\n", + "0 XLPE_1000mm_220kV 100 75288400.0 1.532619e+07 \n", + "1 XLPE_1000mm_220kV 200 75288400.0 1.532619e+07 \n", + "2 XLPE_1000mm_220kV 300 75288400.0 1.532619e+07 \n", + "3 XLPE_1000mm_220kV 400 150576800.0 2.420237e+07 \n", + "4 XLPE_1000mm_220kV 500 150576800.0 2.420237e+07 \n", + "5 XLPE_1000mm_220kV 600 150576800.0 2.420237e+07 \n", + "6 XLPE_1000mm_220kV 700 225865200.0 3.307856e+07 \n", + "7 XLPE_1000mm_220kV 800 225865200.0 3.307856e+07 \n", + "8 XLPE_1000mm_220kV 900 225865200.0 3.307856e+07 \n", + "9 XLPE_1000mm_220kV 1000 301153600.0 4.195474e+07 \n", + "10 XLPE_1000mm_220kV 1100 301153600.0 4.195474e+07 \n", + "11 XLPE_1000mm_220kV 1200 301153600.0 4.195474e+07 \n", + "12 XLPE_1000mm_220kV 1300 376442000.0 2.864046e+07 \n", + "13 XLPE_1000mm_220kV 1400 376442000.0 2.864046e+07 \n", + "14 XLPE_1000mm_220kV 1500 376442000.0 2.864046e+07 \n", + "15 XLPE_1000mm_220kV 1600 451730400.0 3.307856e+07 \n", + "16 XLPE_1000mm_220kV 1700 451730400.0 3.307856e+07 \n", + "17 XLPE_1000mm_220kV 1800 451730400.0 3.307856e+07 \n", + "18 XLPE_1000mm_220kV 1900 527018800.0 3.751665e+07 \n", + "19 XLPE_1000mm_220kV 2000 527018800.0 3.751665e+07 \n", + "20 HVDC_2000mm_320kV 100 87801120.0 1.544500e+08 \n", + "21 HVDC_2000mm_320kV 200 87801120.0 1.544500e+08 \n", + "22 HVDC_2000mm_320kV 300 87801120.0 1.544500e+08 \n", + "23 HVDC_2000mm_320kV 400 87801120.0 1.544500e+08 \n", + "24 HVDC_2000mm_320kV 500 87801120.0 1.544500e+08 \n", + "25 HVDC_2000mm_320kV 600 87801120.0 1.544500e+08 \n", + "26 HVDC_2000mm_320kV 700 87801120.0 1.544500e+08 \n", + "27 HVDC_2000mm_320kV 800 87801120.0 1.544500e+08 \n", + "28 HVDC_2000mm_320kV 900 87801120.0 1.544500e+08 \n", + "29 HVDC_2000mm_320kV 1000 87801120.0 1.544500e+08 \n", + "30 HVDC_2000mm_320kV 1100 87801120.0 1.544500e+08 \n", + "31 HVDC_2000mm_320kV 1200 87801120.0 1.544500e+08 \n", + "32 HVDC_2000mm_320kV 1300 175602240.0 1.544500e+08 \n", + "33 HVDC_2000mm_320kV 1400 175602240.0 1.544500e+08 \n", + "34 HVDC_2000mm_320kV 1500 175602240.0 1.544500e+08 \n", + "35 HVDC_2000mm_320kV 1600 175602240.0 1.544500e+08 \n", + "36 HVDC_2000mm_320kV 1700 175602240.0 1.544500e+08 \n", + "37 HVDC_2000mm_320kV 1800 175602240.0 1.544500e+08 \n", + "38 HVDC_2000mm_320kV 1900 175602240.0 1.544500e+08 \n", + "39 HVDC_2000mm_320kV 2000 175602240.0 1.544500e+08 \n", + "\n", + " num_cables num_substations \n", + "0 1 1 \n", + "1 1 1 \n", + "2 1 1 \n", + "3 2 1 \n", + "4 2 1 \n", + "5 2 1 \n", + "6 3 1 \n", + "7 3 1 \n", + "8 3 1 \n", + "9 4 1 \n", + "10 4 1 \n", + "11 4 1 \n", + "12 5 2 \n", + "13 5 2 \n", + "14 5 2 \n", + "15 6 2 \n", + "16 6 2 \n", + "17 6 2 \n", + "18 7 2 \n", + "19 7 2 \n", + "20 2 1 \n", + "21 2 1 \n", + "22 2 1 \n", + "23 2 1 \n", + "24 2 1 \n", + "25 2 1 \n", + "26 2 1 \n", + "27 2 1 \n", + "28 2 1 \n", + "29 2 1 \n", + "30 2 1 \n", + "31 2 1 \n", + "32 4 2 \n", + "33 4 2 \n", + "34 4 2 \n", + "35 4 2 \n", + "36 4 2 \n", + "37 4 2 \n", + "38 4 2 \n", + "39 4 2 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " site.depth site.mean_windspeed monopile_design.soil_coefficient \\\n", - "0 60 8 4000000 \n", - "1 40 9 4500000 \n", - "2 40 9 4000000 \n", - "3 40 8 4000000 \n", - "4 20 10 4500000 \n", - "5 20 9 4000000 \n", - "6 60 10 5000000 \n", - "7 60 9 4000000 \n", - "8 40 8 5000000 \n", - "9 20 8 5000000 \n", - "\n", - " capex \n", - "0 3.798072e+08 \n", - "1 3.240537e+08 \n", - "2 3.261239e+08 \n", - "3 3.062888e+08 \n", - "4 2.685895e+08 \n", - "5 2.545394e+08 \n", - "6 4.243511e+08 \n", - "7 4.041444e+08 \n", - "8 3.027043e+08 \n", - "9 2.356558e+08 " + "source": [ + "# Follow the same steps as show in Example 1\n", + "\n", + "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric.run()\n", + "parametric.results" ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" } - ], - "source": [ - "# If you are configuring many parameters it can take a long time to run, especially if weather is turned on.\n", - "# To get an idea of how long it'll take, you can run the .preview() method:\n", - "\n", - "parameters = {\n", - " \"site.depth\": [20, 40, 60],\n", - " \"site.mean_windspeed\": [8, 9, 10],\n", - " \"monopile_design.soil_coefficient\": [4000000, 4500000, 5000000]\n", - "} \n", - "\n", - "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign, product=True)\n", - "parametric.preview()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.18" + } }, - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } From d303b37752230ce878872ca11481b58bcd1a54b0 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 29 Feb 2024 16:10:36 -0700 Subject: [PATCH 112/240] Added exploring outputs example to 3. ProjectManager Introduction --- examples/3. ProjectManager Introduction.ipynb | 448 ++++++++++-------- 1 file changed, 255 insertions(+), 193 deletions(-) diff --git a/examples/3. ProjectManager Introduction.ipynb b/examples/3. ProjectManager Introduction.ipynb index 5998460f..ea5ed34e 100644 --- a/examples/3. ProjectManager Introduction.ipynb +++ b/examples/3. ProjectManager Introduction.ipynb @@ -1,201 +1,263 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ProjectManager\n", - "\n", - "ProjectManager is used to interact with multiple modules within ORBIT. This class allows any combination of modules to be configured and ran together to represent an entire project in ORBIT. It handles the configuration of each module and maps outputs of design modules into installation modules where necessary. This tutorial goes through how to build up a project level configuration using ProjectManager." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from ORBIT import ProjectManager" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "text/plain": [ - "{'wtiv': 'dict | str',\n", - " 'feeder': 'dict | str (optional)',\n", - " 'num_feeders': 'int (optional)',\n", - " 'site': {'depth': 'm', 'distance': 'km', 'mean_windspeed': 'm/s'},\n", - " 'plant': {'num_turbines': 'int'},\n", - " 'turbine': {'hub_height': 'm',\n", - " 'rotor_diameter': 'm',\n", - " 'rated_windspeed': 'm/s'},\n", - " 'port': {'num_cranes': 'int (optional, default: 1)',\n", - " 'monthly_rate': 'USD/mo (optional)',\n", - " 'name': 'str (optional)'},\n", - " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", - " 'load_factor': 'float (optional)',\n", - " 'material_factor': 'float (optional)',\n", - " 'monopile_density': 'kg/m3 (optional)',\n", - " 'monopile_modulus': 'Pa (optional)',\n", - " 'monopile_tp_connection_thickness': 'm (optional)',\n", - " 'transition_piece_density': 'kg/m3 (optional)',\n", - " 'transition_piece_thickness': 'm (optional)',\n", - " 'transition_piece_length': 'm (optional)',\n", - " 'soil_coefficient': 'N/m3 (optional)',\n", - " 'air_density': 'kg/m3 (optional)',\n", - " 'weibull_scale_factor': 'float (optional)',\n", - " 'weibull_shape_factor': 'float (optional)',\n", - " 'turb_length_scale': 'm (optional)',\n", - " 'monopile_steel_cost': 'USD/t (optional)',\n", - " 'tp_steel_cost': 'USD/t (optional)'},\n", - " 'project_parameters': {'turbine_capex': '$/kW (optional, default: 1300)',\n", - " 'ncf': 'float (optional, default: 0.4)',\n", - " 'offtake_price': '$/MWh (optional, default: 80)',\n", - " 'project_lifetime': 'yrs (optional, default: 25)',\n", - " 'discount_rate': 'yearly (optional, default: .025)',\n", - " 'opex_rate': '$/kW/year (optional, default: 150)',\n", - " 'construction_insurance': '$/kW (optional, default: 44)',\n", - " 'construction_financing': '$/kW (optional, default: 183)',\n", - " 'contingency': '$/kW (optional, default: 316)',\n", - " 'commissioning': '$/kW (optional, default: 44)',\n", - " 'decommissioning': '$/kW (optional, default: 58)',\n", - " 'site_auction_price': '$ (optional, default: 100e6)',\n", - " 'site_assessment_cost': '$ (optional, default: 50e6)',\n", - " 'construction_plan_cost': '$ (optional, default: 1e6)',\n", - " 'installation_plan_cost': '$ (optional, default: 0.25e6)'},\n", - " 'design_phases': ['MonopileDesign'],\n", - " 'install_phases': ['MonopileInstallation'],\n", - " 'orbit_version': 'v1.0.4+19.g2ac3a73.dirty'}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ProjectManager\n", + "\n", + "ProjectManager is used to interact with multiple modules within ORBIT. This class allows any combination of modules to be configured and ran together to represent an entire project in ORBIT. It handles the configuration of each module and maps outputs of design modules into installation modules where necessary. This tutorial goes through how to build up a project level configuration using ProjectManager." ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The compile expected configs for multiple modules within ProjectManager, use the 'compile_input_dict' method:\n", - "# In this example, we'll configure ProjectManager to run the MonopileDesign and MonopileInstallation modules.\n", - "\n", - "ProjectManager.compile_input_dict([\"MonopileDesign\", \"MonopileInstallation\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total Substructure Cost: 258.67 M\n", - "Total Installation Cost: 21.88 M\n" - ] - } - ], - "source": [ - "# For simplicity, we are going to ignore the optional 'monopile_design' and 'project_parameters' subdicts.\n", - "\n", - "config = {\n", - " 'wtiv': 'example_wtiv',\n", - " 'site': { # The inputs required for the design module and\n", - " 'depth': 20, # the installation module are combined into the 'site' subdict\n", - " 'distance': 50,\n", - " 'mean_windspeed': 9.5\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 50\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'rotor_diameter': 220,\n", - " 'hub_height': 120,\n", - " 'rated_windspeed': 13\n", - " },\n", - " \n", - " # Sizing information for the substructure are not required as they will\n", - " # be calculated by 'MonopileDesign' and passed into 'MonopileInstallation'\n", - " # automatically by 'ProjecManager'.\n", - " \n", - " # --- Module Definitions ---\n", - " 'design_phases': ['MonopileDesign'],\n", - " 'install_phases': ['MonopileInstallation'],\n", - "}\n", - "\n", - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "print(f\"Total Substructure Cost: {project.system_capex/1e6:.2f} M\")\n", - "print(f\"Total Installation Cost: {project.installation_capex/1e6:.2f} M\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Weather" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT import ProjectManager" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'wtiv': 'dict | str',\n", + " 'feeder': 'dict | str (optional)',\n", + " 'num_feeders': 'int (optional)',\n", + " 'site': {'depth': 'm', 'distance': 'km', 'mean_windspeed': 'm/s'},\n", + " 'plant': {'num_turbines': 'int'},\n", + " 'turbine': {'hub_height': 'm',\n", + " 'rotor_diameter': 'm',\n", + " 'rated_windspeed': 'm/s'},\n", + " 'port': {'num_cranes': 'int (optional, default: 1)',\n", + " 'monthly_rate': 'USD/mo (optional)',\n", + " 'name': 'str (optional)'},\n", + " 'monopile_supply_chain': {'enabled': '(optional, default: False)',\n", + " 'substructure_delivery_time': 'h (optional, default: 168)',\n", + " 'num_substructures_delivered': 'int (optional: default: 1)',\n", + " 'substructure_storage': 'int (optional, default: inf)'},\n", + " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", + " 'load_factor': 'float (optional)',\n", + " 'material_factor': 'float (optional)',\n", + " 'monopile_density': 'kg/m3 (optional)',\n", + " 'monopile_modulus': 'Pa (optional)',\n", + " 'monopile_tp_connection_thickness': 'm (optional)',\n", + " 'transition_piece_density': 'kg/m3 (optional)',\n", + " 'transition_piece_thickness': 'm (optional)',\n", + " 'transition_piece_length': 'm (optional)',\n", + " 'soil_coefficient': 'N/m3 (optional)',\n", + " 'air_density': 'kg/m3 (optional)',\n", + " 'weibull_scale_factor': 'float (optional)',\n", + " 'weibull_shape_factor': 'float (optional)',\n", + " 'turb_length_scale': 'm (optional)',\n", + " 'monopile_steel_cost': 'USD/t (optional)',\n", + " 'tp_steel_cost': 'USD/t (optional)'},\n", + " 'project_parameters': {'turbine_capex': '$/kW (optional, default: 1300)',\n", + " 'ncf': 'float (optional, default: 0.4)',\n", + " 'offtake_price': '$/MWh (optional, default: 80)',\n", + " 'project_lifetime': 'yrs (optional, default: 25)',\n", + " 'discount_rate': 'yearly (optional, default: .025)',\n", + " 'opex_rate': '$/kW/year (optional, default: 150)',\n", + " 'construction_insurance': '$/kW (optional, default: 44)',\n", + " 'construction_financing': '$/kW (optional, default: 183)',\n", + " 'contingency': '$/kW (optional, default: 316)',\n", + " 'commissioning': '$/kW (optional, default: 44)',\n", + " 'decommissioning': '$/kW (optional, default: 58)',\n", + " 'site_auction_price': '$ (optional, default: 100e6)',\n", + " 'site_assessment_cost': '$ (optional, default: 50e6)',\n", + " 'construction_plan_cost': '$ (optional, default: 1e6)',\n", + " 'installation_plan_cost': '$ (optional, default: 0.25e6)'},\n", + " 'design_phases': ['MonopileDesign'],\n", + " 'install_phases': ['MonopileInstallation'],\n", + " 'orbit_version': 'v1.0.7+112.g52fef86'}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The compile expected configs for multiple modules within ProjectManager, use the 'compile_input_dict' method:\n", + "# In this example, we'll configure ProjectManager to run the MonopileDesign and MonopileInstallation modules.\n", + "\n", + "ProjectManager.compile_input_dict([\"MonopileDesign\", \"MonopileInstallation\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/nriccobo/GitHub/ORBIT/library'\n", + "Total Substructure Cost: 258.67 M\n", + "Total Installation Cost: 25.67 M\n" + ] + } + ], + "source": [ + "# For simplicity, we are going to ignore the optional 'monopile_design' and 'project_parameters' subdicts.\n", + "\n", + "config = {\n", + " 'wtiv': 'example_wtiv',\n", + " 'site': { # The inputs required for the design module and\n", + " 'depth': 20, # the installation module are combined into the 'site' subdict\n", + " 'distance': 50,\n", + " 'mean_windspeed': 9.5\n", + " },\n", + "\n", + " 'plant': {\n", + " 'num_turbines': 50\n", + " },\n", + "\n", + " 'turbine': {\n", + " 'rotor_diameter': 220,\n", + " 'hub_height': 120,\n", + " 'rated_windspeed': 13\n", + " },\n", + "\n", + " # Sizing information for the substructure are not required as they will\n", + " # be calculated by 'MonopileDesign' and passed into 'MonopileInstallation'\n", + " # automatically by 'ProjecManager'.\n", + "\n", + " # --- Module Definitions ---\n", + " 'design_phases': ['MonopileDesign'],\n", + " 'install_phases': ['MonopileInstallation'],\n", + "}\n", + "\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "print(f\"Total Substructure Cost: {project.system_capex/1e6:.2f} M\")\n", + "print(f\"Total Installation Cost: {project.installation_capex/1e6:.2f} M\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total Substructure Cost: 258.67 M\n", - "Total Installation Cost: 27.95 M\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Weather" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_14087/1181267332.py:3\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." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Substructure Cost: 258.67 M\n", + "Total Installation Cost: 31.62 M\n" + ] + } + ], + "source": [ + "# Weather can be included in the same way as an individual module:\n", + "import pandas as pd\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=['datetime']).set_index(\"datetime\")\n", + "\n", + "project = ProjectManager(config, weather=weather)\n", + "project.run()\n", + "\n", + "print(f\"Total Substructure Cost: {project.system_capex/1e6:.2f} M\")\n", + "print(f\"Total Installation Cost: {project.installation_capex/1e6:.2f} M\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Looking inside a module\n", + "Look at intermediate variables within a module in two ways.\n", + "1. Call the phase of the ProjectManager\n", + "2. Run the module on its own and call the variables\n", + "\n", + "These should yield the same results" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Monopile Cost: $258.67 M\n" + ] + } + ], + "source": [ + "# 1. Call through ProjectManager\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "print(f\"Total Monopile Cost: ${project.phases['MonopileDesign'].total_cost/1e6:.2f} M\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Monopile Cost: $258.67 M\n" + ] + } + ], + "source": [ + "# 2. Call through the module\n", + "from ORBIT.phases.design import MonopileDesign\n", + "\n", + "design = MonopileDesign(config)\n", + "design.run()\n", + "\n", + "print(f\"Total Monopile Cost: ${design.total_cost/1e6:.2f} M\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.18" } - ], - "source": [ - "# Weather can be included in the same way as an individual module:\n", - "import pandas as pd\n", - "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=['datetime']).set_index(\"datetime\")\n", - "\n", - "project = ProjectManager(config, weather=weather)\n", - "project.run()\n", - "\n", - "print(f\"Total Substructure Cost: {project.system_capex/1e6:.2f} M\")\n", - "print(f\"Total Installation Cost: {project.installation_capex/1e6:.2f} M\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } From 8ff4554c2a429e0812a9d4e458adcb2ad414485f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 29 Feb 2024 16:54:15 -0700 Subject: [PATCH 113/240] Cleaned up some hdvc conditionals --- ORBIT/phases/design/electrical_export.py | 34 +++++++----------------- 1 file changed, 9 insertions(+), 25 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 1caedc11..f596fc7b 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -219,10 +219,7 @@ def compute_number_cables(self): _num_redundant = self._design.get("num_redundant", 0) - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: num_required = 2 * np.ceil( self._plant_capacity / self.cable.cable_power ) @@ -316,10 +313,7 @@ def calc_num_substations(self): hvac_substation_capacity = 1200 # MW - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: self.num_substations = self._design.get( "num_substations", int(self.num_cables / 2) ) @@ -355,10 +349,7 @@ def calc_mpt_cost(self): self.num_mpt = self.num_cables - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: self.mpt_cost = 0 else: @@ -379,10 +370,7 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] shunt_cost_rate = self._design.get("shunt_cost_rate", 1e4) - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: self.compensation = 0 else: for _, cable in self.cables.items(): @@ -401,10 +389,7 @@ def calc_switchgear_costs(self): switchgear_cost = self._design.get("switchgear_cost", 4e6) - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: num_switchgear = 0 else: num_switchgear = self.num_cables @@ -421,10 +406,7 @@ def calc_dc_breaker_cost(self): dc_breaker_cost = self._design.get("dc_breaker_cost", 10.5e6) - if ( - self.cable.cable_type == "HVDC-monopole" - or self.cable.cable_type == "HVDC-bipole" - ): + if "HVDC" in self.cable.cable_type: num_dc_breakers = self.num_cables else: num_dc_breakers = 0 @@ -585,7 +567,9 @@ def calc_onshore_cost(self): else: self.onshore_converter_cost = 0 self.ais_cost = self.num_cables * 9.33e6 - self.onshore_compensation = self.num_cables * 31.3e6 + self.onshore_shunt_reactor_cost + self.onshore_compensation = ( + self.num_cables * 31.3e6 + self.onshore_shunt_reactor_cost + ) self.onshore_construction = 5e6 * self.num_substations self.onshore_cost = ( From 0455343e329d9ae7589535dec5d3d66997c3878b Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 4 Mar 2024 14:47:02 -0700 Subject: [PATCH 114/240] updated the cable names in 1000mm hvac cables --- library/cables/XLPE_1000mm_220kV.yaml | 2 +- library/cables/XLPE_1000mm_220kV_dynamic.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/cables/XLPE_1000mm_220kV.yaml b/library/cables/XLPE_1000mm_220kV.yaml index 8e4e794a..3d199571 100644 --- a/library/cables/XLPE_1000mm_220kV.yaml +++ b/library/cables/XLPE_1000mm_220kV.yaml @@ -7,4 +7,4 @@ inductance: 0.38 # mH/km linear_density: 115 # t/km rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC -name: XLPE_1000m_220kV +name: XLPE_1000mm_220kV diff --git a/library/cables/XLPE_1000mm_220kV_dynamic.yaml b/library/cables/XLPE_1000mm_220kV_dynamic.yaml index 26f5ed8c..b378759b 100644 --- a/library/cables/XLPE_1000mm_220kV_dynamic.yaml +++ b/library/cables/XLPE_1000mm_220kV_dynamic.yaml @@ -7,4 +7,4 @@ inductance: 0.38 # mH/km linear_density: 115 # t/km rated_voltage: 220 # kV cable_type: HVAC # HVDC vs HVAC -name: XLPE_1000m_220kV_dynamic +name: XLPE_1000mm_220kV_dynamic From 2da4dcad4956f9eba82c158512bd53da265c7410 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 13:22:44 -0700 Subject: [PATCH 115/240] Adjusted onshore costs to be a separate dictionary input. Renamed some variables to be more consist with original oss_design module. Updated test_electrical_design --- ORBIT/phases/design/electrical_export.py | 117 ++++++++++++------ tests/phases/design/test_electrical_design.py | 2 +- 2 files changed, 83 insertions(+), 36 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index f596fc7b..67bb9247 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -53,10 +53,12 @@ class ElectricalDesign(CableSystem): }, }, "substation_design": { - "mpt_cost": "USD (optional)", + "substation_capacity": "MW (optional)", + "num_substations": "int (optional)", + "mpt_cost": "USD/cable (optional)", "topside_fab_cost_rate": "USD/t (optional)", "topside_design_cost": "USD (optional)", - "shunt_cost_rate": "USD/MW (optional)", + "shunt_cost_rate": "USD/cable (optional)", "switchgear_cost": "USD (optional)", "dc_breaker_cost": "USD (optional)", "backup_gen_cost": "USD (optional)", @@ -67,7 +69,10 @@ class ElectricalDesign(CableSystem): "topside_assembly_factor": "float (optional)", "oss_substructure_cost_rate": "USD/t (optional)", "oss_pile_cost_rate": "USD/t (optional)", - "num_substations": "int (optional)", + }, + "onshore_substation_design": { + "shunt_cost_rate": "USD/cable (optional)", + "onshore_converter_cost": "USD (optional)", }, } @@ -118,7 +123,10 @@ def run(self): self.export_system_design = self.config["export_system_design"] self.offshore_substation_design = self.config.get( - "offshore_substation_design", {} + "substation_design", {} + ) + self.onshore_substation_design = self.config.get( + "onshore_substation_design", {} ) # CABLES @@ -131,6 +139,7 @@ def run(self): self.calc_crossing_cost() self._outputs["export_system"] = {"system_cost": self.total_cable_cost} + for _, cable in self.cables.items(): self._outputs["export_system"]["cable"] = { "linear_density": cable.linear_density, @@ -172,6 +181,7 @@ def run(self): } self._outputs["num_substations"] = self.num_substations + self._outputs["total_substation_cost"] = self.total_substation_cost @property def detailed_output(self): @@ -190,6 +200,12 @@ def detailed_output(self): "substation_substructure_mass": self.substructure_mass, "substation_substructure_cost": self.substructure_cost, "total_substation_cost": self.total_substation_cost, + "onshore_shunt_cost": self.onshore_shunt_reactor_cost, + "onshore_converter_cost": self.onshore_converter_cost, + "onshore_switchgear_cost": self.onshore_switchgear_cost, + "onshore_construction_cost": self.onshore_construction, + "onshore_compensation_cost": self.onshore_compensation_cost, + "onshore_mpt_cost": self.mpt_cost, } return _output @@ -307,11 +323,19 @@ def total_substation_cost(self): ) def calc_num_substations(self): - """Computes number of substations""" + """Computes number of substations based on HVDC or HVAC + export cables. + Parameters + ---------- + substation_capacity : int | float + """ self._design = self.config.get("substation_design", {}) - hvac_substation_capacity = 1200 # MW + # HVAC substation capacity + _substation_capacity = self._design.get( + "substation_capacity", 1200 + ) # MW if "HVDC" in self.cable.cable_type: self.num_substations = self._design.get( @@ -320,7 +344,7 @@ def calc_num_substations(self): else: self.num_substations = self._design.get( "num_substations", - int(np.ceil(self._plant_capacity / hvac_substation_capacity)), + int(np.ceil(self._plant_capacity / _substation_capacity)), ) @property @@ -333,19 +357,19 @@ def substation_cost(self): + self.switchgear_cost + self.converter_cost + self.dc_breaker_cost - + self.ancillary_system_cost + + self.ancillary_system_costs + self.land_assembly_cost ) / self.num_substations def calc_mpt_cost(self): - """Computes transformer cost + """Computes HVAC main power transformer (MPT). MPT cost is 0 for HVDC. Parameters ---------- mpt_cost : int | float """ - mpt_cost = self._design.get("mpt_cost", 2.87e6) + _mpt_cost = self._design.get("mpt_cost", 2.87e6) self.num_mpt = self.num_cables @@ -353,14 +377,14 @@ def calc_mpt_cost(self): self.mpt_cost = 0 else: - self.mpt_cost = self.num_mpt * mpt_cost + self.mpt_cost = self.num_mpt * _mpt_cost self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 ) def calc_shunt_reactor_cost(self): - """Computes shunt reactor cost + """Computes HVAC shunt reactor cost. Shunt reactor cost is 0 for HVDC. Parameters ---------- @@ -370,17 +394,19 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] shunt_cost_rate = self._design.get("shunt_cost_rate", 1e4) + _num_shunts = self.num_cables + if "HVDC" in self.cable.cable_type: self.compensation = 0 else: for _, cable in self.cables.items(): self.compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - self.compensation * shunt_cost_rate * self.num_cables + self.compensation * shunt_cost_rate * _num_shunts ) def calc_switchgear_costs(self): - """Computes switchgear cost + """Computes HVAC switchgear cost. Switchgear cost is 0 for HVDC. Parameters ---------- @@ -397,7 +423,7 @@ def calc_switchgear_costs(self): self.switchgear_cost = num_switchgear * switchgear_cost def calc_dc_breaker_cost(self): - """Computes HVDC circuit breaker cost + """Computes HVDC circuit breaker cost. Breaker cost is 0 for HVAC. Parameters ---------- @@ -428,7 +454,7 @@ def calc_ancillary_system_cost(self): workspace_cost = self._design.get("workspace_cost", 2e6) other_ancillary_cost = self._design.get("other_ancillary_cost", 3e6) - self.ancillary_system_cost = ( + self.ancillary_system_costs = ( backup_gen_cost + workspace_cost + other_ancillary_cost ) * self.num_substations @@ -461,7 +487,7 @@ def calc_assembly_cost(self): self.land_assembly_cost = ( self.switchgear_cost + self.shunt_reactor_cost - + self.ancillary_system_cost + + self.ancillary_system_costs ) * topside_assembly_factor def calc_substructure_mass_and_cost(self): @@ -520,7 +546,6 @@ def calc_topside_mass_and_cost(self): Parameters ---------- - topside_fab_cost_rate : int | float topside_design_cost: int | float """ @@ -540,12 +565,25 @@ def calc_topside_mass_and_cost(self): self.topside_cost = _design.get("topside_design_cost", 107.3e6) def calc_onshore_cost(self): - """Minimum Cost of Onshore Substation Connection""" + """Minimum Cost of Onshore Substation Connection + + Parameters + ---------- + shunt_cost_rate : int | float + onshore_converter_cost: int | float + switchgear_cost: int | float + """ + + _design = self.config.get("onshore_substation_design", {}) + + _shunt_cost_rate = _design.get("shunt_cost_rate", 1.3e4) # per cable + _switchgear_cost = _design.get("switchgear_cost", 9.33e6) # per cable + _compensation_rate = _design.get( + "compensation_rate", 31.3e6 + ) # per cable self.onshore_shunt_reactor_cost = ( - self.compensation - * self._design.get("shunt_cost_rate", 1.3e4) - * self.num_cables + self.compensation * self.num_cables * _shunt_cost_rate ) if self.cable.cable_type == "HVDC-monopole": @@ -553,33 +591,42 @@ def calc_onshore_cost(self): self.num_substations * self._design.get("onshore_converter_cost", 157e6) ) - self.ais_cost = 0 - self.onshore_construction = 87.3e6 * self.num_substations - self.onshore_compensation = 0 + self.onshore_switchgear_cost = 0 + self.onshore_construction = self.num_substations * _design.get( + "onshore_construction_rate", 87.3e6 + ) + self.onshore_compensation_cost = 0 + elif self.cable.cable_type == "HVDC-bipole": self.onshore_converter_cost = ( self.num_substations * self._design.get("onshore_converter_cost", 350e6) ) - self.ais_cost = 0 - self.onshore_construction = 100e6 * self.num_substations - self.onshore_compensation = 0 + self.onshore_switchgear_cost = 0 + self.onshore_construction = self.num_substations * _design.get( + "onshore_construction_rate", 100e6 + ) + self.onshore_compensation_cost = 0 + else: self.onshore_converter_cost = 0 - self.ais_cost = self.num_cables * 9.33e6 - self.onshore_compensation = ( - self.num_cables * 31.3e6 + self.onshore_shunt_reactor_cost + self.onshore_switchgear_cost = self.num_cables * _switchgear_cost + self.onshore_construction = self.num_substations * _design.get( + "onshore_construction_rate", 5e6 + ) + self.onshore_compensation_cost = ( + self.num_cables * _compensation_rate + + self.onshore_shunt_reactor_cost ) - self.onshore_construction = 5e6 * self.num_substations self.onshore_cost = ( self.onshore_converter_cost + + self.onshore_switchgear_cost + self.onshore_construction - + self.onshore_compensation + + self.onshore_compensation_cost + self.mpt_cost - + self.ais_cost ) self._outputs["export_system"][ - "onshore_construction_cost" + "onshore_substation_costs" ] = self.onshore_cost diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index f7e9db16..13521559 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -137,7 +137,7 @@ def test_onshore_substation(): config = deepcopy(base) o = ElectricalDesign(config) o.run() - assert o.onshore_cost == 109.32e6 + assert o.onshore_cost == pytest.approx(95.487e6, abs=1e2) # 109.32e6 config_mono = deepcopy(config) config_mono["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} From 07e8dbbb5c5e7d16ec49608ca84aeabed73712a3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 13:55:24 -0700 Subject: [PATCH 116/240] Updated test_electrical_design to compare new and old oss_design. Temporary until ElectricalDesign is merged into release --- ORBIT/phases/design/oss_design.py | 9 +++--- tests/phases/design/test_electrical_design.py | 31 ++++++++++++++++++- 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index e762eab5..37f55ee4 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -136,7 +136,8 @@ def calc_topside_deck_space(self): def calc_num_mpt_and_rating(self): """ - Calculates the number of main power transformers (MPTs) and their rating. + Calculates the number of main power transformers (MPTs) + and their rating. Parameters ---------- @@ -151,7 +152,7 @@ def calc_num_mpt_and_rating(self): capacity = num_turbines * turbine_rating self.num_substations = _design.get( - "num_substations", int(np.ceil(capacity / 800)) + "num_substations", int(np.ceil(capacity / 1200)) ) self.num_mpt = np.ceil( num_turbines * turbine_rating / (250 * self.num_substations) @@ -226,7 +227,7 @@ def calc_switchgear_cost(self): """ _design = self.config.get("substation_design", {}) - switchgear_cost = _design.get("switchgear_cost", 14.5e5) + switchgear_cost = _design.get("switchgear_cost", 4e6) self.switchgear_costs = self.num_mpt * switchgear_cost @@ -284,7 +285,7 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - substructure_pile_mass = 8 * substructure_mass ** 0.5574 + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 13521559..4b82d144 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -10,7 +10,7 @@ import pytest from ORBIT.core.library import extract_library_specs -from ORBIT.phases.design import ElectricalDesign +from ORBIT.phases.design import ElectricalDesign, OffshoreSubstationDesign # OSS TESTING @@ -112,6 +112,35 @@ def test_dc_oss_kwargs(): assert cost != base_cost +def test_new_old_hvac_substation(): + """Temporary test until ElectricalDesign is merged with new release""" + config = deepcopy(base) + config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} + config["plant"]["capacity"] = 1000 # MW + config["plant"]["num_turbines"] = 200 + config["turbine"] = {"turbine_rating": 5} + + new = ElectricalDesign(config) + new.run() + + old = OffshoreSubstationDesign(config) + old.run() + + # same values + assert new.num_substations == old.num_substations + assert new.topside_mass == old.topside_mass + assert new.ancillary_system_costs == old.ancillary_system_costs + assert new.substructure_mass == old.substructure_mass + + # different values + assert new.substation_cost != old.substation_cost + assert new.mpt_rating != old.mpt_rating + assert new.num_mpt != old.num_mpt + assert new.mpt_cost != old.mpt_cost + assert new.topside_cost != old.topside_cost + assert new.shunt_reactor_cost != old.shunt_reactor_cost + + def test_hvdc_substation(): config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} From ef00a020a184c8bbb10b465e575f431a6dfa851e Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 14:00:25 -0700 Subject: [PATCH 117/240] Forgot to add file after format change. --- tests/phases/design/test_electrical_design.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 4b82d144..99d9b3b0 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -114,6 +114,7 @@ def test_dc_oss_kwargs(): def test_new_old_hvac_substation(): """Temporary test until ElectricalDesign is merged with new release""" + config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} config["plant"]["capacity"] = 1000 # MW From d7a0f366e7ffb4c87af5a7bbfd1708104c1da1f3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 15:22:57 -0700 Subject: [PATCH 118/240] "Moved HVDC HVAC parametric manager to its own example" --- examples/Example - Parametric Manager.ipynb | 607 +------------------- 1 file changed, 1 insertion(+), 606 deletions(-) diff --git a/examples/Example - Parametric Manager.ipynb b/examples/Example - Parametric Manager.ipynb index e9f8f938..dbbc4d1f 100644 --- a/examples/Example - Parametric Manager.ipynb +++ b/examples/Example - Parametric Manager.ipynb @@ -26,7 +26,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 1. Monopile Design Example\n", + "### Monopile Design Example\n", "Perform a parametric sweep of site depth and mean wind speed to see the effects on monopile capex." ] }, @@ -480,611 +480,6 @@ "parametric = ParametricManager(base_config, parameters, results, module=MonopileDesign, product=True)\n", "parametric.preview()" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 2. Electrical Export Design\n", - "\n", - "Perform a parametric sweep of export cable technology (HVDC or HVAC) and how plant capacity impacts the cable capex." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'site': {'distance_to_landfall': 'km', 'depth': 'm'},\n", - " 'landfall': {'interconnection_distance': 'km (optional)'},\n", - " 'plant': {'capacity': 'MW'},\n", - " 'export_system_design': {'cables': 'str',\n", - " 'num_redundant': 'int (optional)',\n", - " 'touchdown_distance': 'm (optional, default: 0)',\n", - " 'percent_added_length': 'float (optional)',\n", - " 'cable_crossings': {'crossing_number': 'int (optional)',\n", - " 'crossing_unit_cost': 'float (optional)'}},\n", - " 'substation_design': {'mpt_cost': 'USD (optional)',\n", - " 'topside_fab_cost_rate': 'USD/t (optional)',\n", - " 'topside_design_cost': 'USD (optional)',\n", - " 'shunt_cost_rate': 'USD/MW (optional)',\n", - " 'switchgear_cost': 'USD (optional)',\n", - " 'dc_breaker_cost': 'USD (optional)',\n", - " 'backup_gen_cost': 'USD (optional)',\n", - " 'workspace_cost': 'USD (optional)',\n", - " 'other_ancillary_cost': 'USD (optional)',\n", - " 'converter_cost': 'USD (optional)',\n", - " 'onshore_converter_cost': 'USD (optional)',\n", - " 'topside_assembly_factor': 'float (optional)',\n", - " 'oss_substructure_cost_rate': 'USD/t (optional)',\n", - " 'oss_pile_cost_rate': 'USD/t (optional)',\n", - " 'num_substations': 'int (optional)'}}" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ElectricalDesign.expected_config" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "base_config = {\n", - " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'site': {\n", - " 'distance': 100,\n", - " 'depth': 20,\n", - " 'distance_to_landfall': 50\n", - " },\n", - " 'plant': {\n", - " 'turbine_rating': 10\n", - "# 'capacity': 500\n", - " },\n", - " 'turbine': {'turbine_rating': 10},\n", - " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", - " 'feeder': 'future_feeder',\n", - "# 'export_system_design': {\n", - "# 'cables': 'XLPE_500mm_220kV',\n", - "# }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "# Parameters\n", - "parameters = {\n", - " 'export_system_design.cables': ['XLPE_1000mm_220kV', 'HVDC_2000mm_320kV'],\n", - " 'plant.capacity': np.arange(100,2100,100)\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# Desired results\n", - "\n", - "results = {\n", - " 'cable_cost': lambda run: run.total_cable_cost,\n", - " 'oss_cost': lambda run: run.substation_cost,\n", - " 'num_cables': lambda run: run.num_cables,\n", - " 'num_substations': lambda run: run.num_substations,\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
export_system_design.cablesplant.capacitycable_costoss_costnum_cablesnum_substations
0XLPE_1000mm_220kV10075288400.01.532619e+0711
1XLPE_1000mm_220kV20075288400.01.532619e+0711
2XLPE_1000mm_220kV30075288400.01.532619e+0711
3XLPE_1000mm_220kV400150576800.02.420237e+0721
4XLPE_1000mm_220kV500150576800.02.420237e+0721
5XLPE_1000mm_220kV600150576800.02.420237e+0721
6XLPE_1000mm_220kV700225865200.03.307856e+0731
7XLPE_1000mm_220kV800225865200.03.307856e+0731
8XLPE_1000mm_220kV900225865200.03.307856e+0731
9XLPE_1000mm_220kV1000301153600.04.195474e+0741
10XLPE_1000mm_220kV1100301153600.04.195474e+0741
11XLPE_1000mm_220kV1200301153600.04.195474e+0741
12XLPE_1000mm_220kV1300376442000.02.864046e+0752
13XLPE_1000mm_220kV1400376442000.02.864046e+0752
14XLPE_1000mm_220kV1500376442000.02.864046e+0752
15XLPE_1000mm_220kV1600451730400.03.307856e+0762
16XLPE_1000mm_220kV1700451730400.03.307856e+0762
17XLPE_1000mm_220kV1800451730400.03.307856e+0762
18XLPE_1000mm_220kV1900527018800.03.751665e+0772
19XLPE_1000mm_220kV2000527018800.03.751665e+0772
20HVDC_2000mm_320kV10087801120.01.544500e+0821
21HVDC_2000mm_320kV20087801120.01.544500e+0821
22HVDC_2000mm_320kV30087801120.01.544500e+0821
23HVDC_2000mm_320kV40087801120.01.544500e+0821
24HVDC_2000mm_320kV50087801120.01.544500e+0821
25HVDC_2000mm_320kV60087801120.01.544500e+0821
26HVDC_2000mm_320kV70087801120.01.544500e+0821
27HVDC_2000mm_320kV80087801120.01.544500e+0821
28HVDC_2000mm_320kV90087801120.01.544500e+0821
29HVDC_2000mm_320kV100087801120.01.544500e+0821
30HVDC_2000mm_320kV110087801120.01.544500e+0821
31HVDC_2000mm_320kV120087801120.01.544500e+0821
32HVDC_2000mm_320kV1300175602240.01.544500e+0842
33HVDC_2000mm_320kV1400175602240.01.544500e+0842
34HVDC_2000mm_320kV1500175602240.01.544500e+0842
35HVDC_2000mm_320kV1600175602240.01.544500e+0842
36HVDC_2000mm_320kV1700175602240.01.544500e+0842
37HVDC_2000mm_320kV1800175602240.01.544500e+0842
38HVDC_2000mm_320kV1900175602240.01.544500e+0842
39HVDC_2000mm_320kV2000175602240.01.544500e+0842
\n", - "
" - ], - "text/plain": [ - " export_system_design.cables plant.capacity cable_cost oss_cost \\\n", - "0 XLPE_1000mm_220kV 100 75288400.0 1.532619e+07 \n", - "1 XLPE_1000mm_220kV 200 75288400.0 1.532619e+07 \n", - "2 XLPE_1000mm_220kV 300 75288400.0 1.532619e+07 \n", - "3 XLPE_1000mm_220kV 400 150576800.0 2.420237e+07 \n", - "4 XLPE_1000mm_220kV 500 150576800.0 2.420237e+07 \n", - "5 XLPE_1000mm_220kV 600 150576800.0 2.420237e+07 \n", - "6 XLPE_1000mm_220kV 700 225865200.0 3.307856e+07 \n", - "7 XLPE_1000mm_220kV 800 225865200.0 3.307856e+07 \n", - "8 XLPE_1000mm_220kV 900 225865200.0 3.307856e+07 \n", - "9 XLPE_1000mm_220kV 1000 301153600.0 4.195474e+07 \n", - "10 XLPE_1000mm_220kV 1100 301153600.0 4.195474e+07 \n", - "11 XLPE_1000mm_220kV 1200 301153600.0 4.195474e+07 \n", - "12 XLPE_1000mm_220kV 1300 376442000.0 2.864046e+07 \n", - "13 XLPE_1000mm_220kV 1400 376442000.0 2.864046e+07 \n", - "14 XLPE_1000mm_220kV 1500 376442000.0 2.864046e+07 \n", - "15 XLPE_1000mm_220kV 1600 451730400.0 3.307856e+07 \n", - "16 XLPE_1000mm_220kV 1700 451730400.0 3.307856e+07 \n", - "17 XLPE_1000mm_220kV 1800 451730400.0 3.307856e+07 \n", - "18 XLPE_1000mm_220kV 1900 527018800.0 3.751665e+07 \n", - "19 XLPE_1000mm_220kV 2000 527018800.0 3.751665e+07 \n", - "20 HVDC_2000mm_320kV 100 87801120.0 1.544500e+08 \n", - "21 HVDC_2000mm_320kV 200 87801120.0 1.544500e+08 \n", - "22 HVDC_2000mm_320kV 300 87801120.0 1.544500e+08 \n", - "23 HVDC_2000mm_320kV 400 87801120.0 1.544500e+08 \n", - "24 HVDC_2000mm_320kV 500 87801120.0 1.544500e+08 \n", - "25 HVDC_2000mm_320kV 600 87801120.0 1.544500e+08 \n", - "26 HVDC_2000mm_320kV 700 87801120.0 1.544500e+08 \n", - "27 HVDC_2000mm_320kV 800 87801120.0 1.544500e+08 \n", - "28 HVDC_2000mm_320kV 900 87801120.0 1.544500e+08 \n", - "29 HVDC_2000mm_320kV 1000 87801120.0 1.544500e+08 \n", - "30 HVDC_2000mm_320kV 1100 87801120.0 1.544500e+08 \n", - "31 HVDC_2000mm_320kV 1200 87801120.0 1.544500e+08 \n", - "32 HVDC_2000mm_320kV 1300 175602240.0 1.544500e+08 \n", - "33 HVDC_2000mm_320kV 1400 175602240.0 1.544500e+08 \n", - "34 HVDC_2000mm_320kV 1500 175602240.0 1.544500e+08 \n", - "35 HVDC_2000mm_320kV 1600 175602240.0 1.544500e+08 \n", - "36 HVDC_2000mm_320kV 1700 175602240.0 1.544500e+08 \n", - "37 HVDC_2000mm_320kV 1800 175602240.0 1.544500e+08 \n", - "38 HVDC_2000mm_320kV 1900 175602240.0 1.544500e+08 \n", - "39 HVDC_2000mm_320kV 2000 175602240.0 1.544500e+08 \n", - "\n", - " num_cables num_substations \n", - "0 1 1 \n", - "1 1 1 \n", - "2 1 1 \n", - "3 2 1 \n", - "4 2 1 \n", - "5 2 1 \n", - "6 3 1 \n", - "7 3 1 \n", - "8 3 1 \n", - "9 4 1 \n", - "10 4 1 \n", - "11 4 1 \n", - "12 5 2 \n", - "13 5 2 \n", - "14 5 2 \n", - "15 6 2 \n", - "16 6 2 \n", - "17 6 2 \n", - "18 7 2 \n", - "19 7 2 \n", - "20 2 1 \n", - "21 2 1 \n", - "22 2 1 \n", - "23 2 1 \n", - "24 2 1 \n", - "25 2 1 \n", - "26 2 1 \n", - "27 2 1 \n", - "28 2 1 \n", - "29 2 1 \n", - "30 2 1 \n", - "31 2 1 \n", - "32 4 2 \n", - "33 4 2 \n", - "34 4 2 \n", - "35 4 2 \n", - "36 4 2 \n", - "37 4 2 \n", - "38 4 2 \n", - "39 4 2 " - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Follow the same steps as show in Example 1\n", - "\n", - "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", - "parametric.run()\n", - "parametric.results" - ] } ], "metadata": { From 36ebb0f3e06b271e681adc9cf9c308bfd5e2432e Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 16:05:22 -0700 Subject: [PATCH 119/240] Created an example dedicated to HVAC and HVDC comparison --- examples/Example - Using HVDC or HVAC.ipynb | 359 ++++++++++++++++++++ 1 file changed, 359 insertions(+) create mode 100644 examples/Example - Using HVDC or HVAC.ipynb diff --git a/examples/Example - Using HVDC or HVAC.ipynb b/examples/Example - Using HVDC or HVAC.ipynb new file mode 100644 index 00000000..4618d10e --- /dev/null +++ b/examples/Example - Using HVDC or HVAC.ipynb @@ -0,0 +1,359 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f5c53391-7926-4fbe-bbd2-53c4d1bf1dd5", + "metadata": {}, + "source": [ + "### ORBIT Example - Using HVDC or HVAC Example" + ] + }, + { + "cell_type": "markdown", + "id": "e77f95a5-e7bb-4367-8969-c3f179b862a4", + "metadata": {}, + "source": [ + "Component or technology decisions have an impact on a wind project's CapEx. This example will provide a basic setup to compare how different project sizes, export cable types (HVDC or HVDC), distances to shore, etc. effect project costs, this is a very useful tool.\n", + "\n", + "*NOTE: This example uses a test module: `ElectricalDesign` and therefore you must set your branch to dev*" + ] + }, + { + "cell_type": "markdown", + "id": "f472fe73-2ebd-4754-b693-81e2f1d14a77", + "metadata": {}, + "source": [ + "### Import Dependencies" + ] + }, + { + "cell_type": "markdown", + "id": "9ffde11c-6f22-4c15-8b60-3f06e0c2c00e", + "metadata": {}, + "source": [ + "Include path to ORBIT repo and import parametric manager and any modules used for analysis. For this example, we will be running the `ElectricalDesign` module." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "a906c1f3-c0a7-4285-abf5-882d4d5f89e7", + "metadata": {}, + "outputs": [], + "source": [ + "from ORBIT.phases.design import ElectricalDesign\n", + "\n", + "from ORBIT import ProjectManager, ParametricManager\n", + "\n", + "import numpy as np\n", + "from copy import deepcopy\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "b6e56587-72fc-445c-b289-d4d6b19a3079", + "metadata": {}, + "source": [ + "### Create Config" + ] + }, + { + "cell_type": "markdown", + "id": "3792651c-c192-4b1a-ac76-8452dd155b63", + "metadata": {}, + "source": [ + "Config must include all required variables except those you plan to vary. In this example, we will be manually vary the cable type and then use the `ParametricManager` to vary cable type and plant capacity." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "2cc12a2f-6192-40a3-9876-346495655bc9", + "metadata": {}, + "outputs": [], + "source": [ + "base_config = {\n", + " 'export_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'site': {\n", + " 'distance': 100,\n", + " 'depth': 20,\n", + " 'distance_to_landfall': 50\n", + " },\n", + " 'plant': {\n", + " 'capacity': 1000\n", + " },\n", + " 'turbine': \"12MW_generic\",\n", + " 'oss_install_vessel': 'example_heavy_lift_vessel',\n", + " 'feeder': 'future_feeder',\n", + " 'design_phases': [\n", + " 'ElectricalDesign',\n", + " ],\n", + " 'install_phases': [\n", + " 'ExportCableInstallation',\n", + " 'OffshoreSubstationInstallation'\n", + " ],\n", + "\n", + "# Commented out because we will vary these manually\n", + "# 'export_system_design': {\n", + "# 'cables': 'XLPE_500mm_220kV',\n", + "# }\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### HVAC Export Cables\n", + "\n", + "Add HVAC export cables to the config " + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "Total CapEx per kW: $2507.12 \n" + ] + }, + { + "data": { + "text/plain": [ + "{'Export System': 301153600.0,\n", + " 'Offshore Substation': 47655941.13840648,\n", + " 'Export System Installation': 48563809.98096469,\n", + " 'Offshore Substation Installation': 3098929.2998477924,\n", + " 'Turbine': 1310400000,\n", + " 'Soft': 645000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hvac_config = deepcopy(base_config)\n", + "\n", + "hvac_config[\"export_system_design\"] = {\n", + " 'cables': 'XLPE_1000mm_220kV',\n", + " }\n", + "\n", + "hvac_project = ProjectManager(hvac_config)\n", + "hvac_project.run()\n", + "\n", + "print(f\"Total CapEx per kW: ${hvac_project.total_capex_per_kw:.2f} \")\n", + "\n", + "hvac_project.capex_breakdown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### HVDC Export Cables\n", + "\n", + "Add HVDC export cables to the config" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OffshoreSubstationInstallation:\n", + "\t Warning: 'Feeder 0' Cargo Mass Capacity Exceeded\n", + "Total CapEx per kW: $2370.48 \n" + ] + }, + { + "data": { + "text/plain": [ + "{'Export System': 87801120.0,\n", + " 'Offshore Substation': 160151200.0,\n", + " 'Export System Installation': 12778131.303180292,\n", + " 'Offshore Substation Installation': 3098929.2998477924,\n", + " 'Turbine': 1310400000,\n", + " 'Soft': 645000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hvdc_config = deepcopy(base_config)\n", + "\n", + "hvdc_config[\"export_system_design\"] = {\n", + " 'cables': 'HVDC_2000mm_320kV',\n", + " }\n", + "\n", + "hvdc_project = ProjectManager(hvdc_config)\n", + "hvdc_project.run()\n", + "\n", + "print(f\"Total CapEx per kW: ${hvdc_project.total_capex_per_kw:.2f} \")\n", + "\n", + "hvdc_project.capex_breakdown" + ] + }, + { + "cell_type": "markdown", + "id": "47a9f8f7-b725-4857-8277-a38d5470cedd", + "metadata": {}, + "source": [ + "## Use Parametric Manager to compare HVDC and HVAC\n", + "From the two examples above, we see that HVDC is more cost effective than HVAC. Note that the HVDC export system (cables) costs nearly 30% of the HVAC cables. However, the Offshore Substation (OSS) is over 3x the cost of an HVAC OSS. To compare this sensitivity and see if there is an point that these technologies cross we'll use `ParametricManager` and sweep each cable for a range of plant capacities. " + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "5cc31e1a-f39b-44ad-97ce-3ebf96486fa4", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = {\n", + " 'export_system_design.cables': ['XLPE_1000mm_220kV', 'HVDC_2000mm_320kV'],\n", + " 'plant.capacity': np.arange(100,2100,100)\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "7775629d-afd8-4ce2-bfd4-a70c7f5149a4", + "metadata": {}, + "source": [ + "### Define Outputs of Interest" + ] + }, + { + "cell_type": "markdown", + "id": "786d8e8f-a748-4286-87a6-922c47e4f902", + "metadata": {}, + "source": [ + "Here in the results dictionary, define which variables you would like reported in the output data frame. " + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "0d3536a9-0cc9-4351-a0ac-b25e244fcb26", + "metadata": {}, + "outputs": [], + "source": [ + "results = {\n", + " 'cable_cost': lambda run: run.total_cable_cost,\n", + " 'oss_cost': lambda run: run.substation_cost,\n", + " 'num_cables': lambda run: run.num_cables,\n", + " 'num_substations': lambda run: run.num_substations,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "23688759-8861-42a5-b749-3650d64a6215", + "metadata": {}, + "source": [ + "### Run ParametricManager and See Results" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "9d32906d-d907-4bd6-9714-33f994aa0061", + "metadata": {}, + "outputs": [], + "source": [ + "parametric = ParametricManager(base_config, parameters, results, module = ElectricalDesign, product=True)\n", + "parametric.run()\n", + "parametric.results" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Put results into a Dataframe\n", + "df = pd.DataFrame(parametric.results)\n", + "\n", + "# Plot results\n", + "fig = plt.figure(figsize=(6,4), dpi=200)\n", + "ax = fig.subplots(1)\n", + "\n", + "hvac_df = df[df['export_system_design.cables'] == 'XLPE_1000mm_220kV']\n", + "hvdc_df = df[df['export_system_design.cables'] == 'HVDC_2000mm_320kV']\n", + "\n", + "ax.plot(hvac_df[\"plant.capacity\"],\n", + " (hvac_df[\"cable_cost\"] + hvac_df[\"oss_cost\"])/1e6,\n", + " label='HVAC')\n", + "\n", + "ax.plot(hvdc_df[\"plant.capacity\"],\n", + " (hvdc_df[\"cable_cost\"] + hvdc_df[\"oss_cost\"])/1e6,\n", + " label='HVDC')\n", + "\n", + "ax.set_ylabel(\"CapEx [$M]\")\n", + "ax.set_xlabel(\"Capacity [MW]\")\n", + "ax.legend()\n", + "ax.grid()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This plot shows that for a project that has less than 700MW of capacity you should use HVAC. But for projects greater than 700MW should use HVDC, if only considering the CapEx." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From df2044ba6e3e00b06b5c8196ebd74b16a3a4146c Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 5 Mar 2024 16:49:07 -0700 Subject: [PATCH 120/240] had to freeze python-benedict<0.33.2. Latest version breaks parametric manager tests. --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 6ce002c7..c7d875e3 100644 --- a/setup.py +++ b/setup.py @@ -35,7 +35,7 @@ "pandas", "pyyaml", "openmdao>=3.2", - "python-benedict", + "python-benedict<0.33.2", "statsmodels", ], extras_require={ From 6134359904c75eec964c27b11693037a2a975768 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Mar 2024 15:31:55 -0600 Subject: [PATCH 121/240] Had to freeze benedict version. See issue #148. Autoupdated pre-commit file too --- .pre-commit-config.yaml | 6 +++--- setup.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 84ca9757..11d5dee0 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -3,14 +3,14 @@ ci: repos: - repo: https://github.com/timothycrosley/isort - rev: 4.3.21 + rev: 5.13.2 hooks: - id: isort name: isort stages: [commit] - repo: https://github.com/psf/black - rev: stable + rev: 24.2.0 hooks: - id: black name: black @@ -34,7 +34,7 @@ repos: args: [--autofix] - repo: https://github.com/pre-commit/mirrors-pylint - rev: v2.1.1 + rev: v3.0.0a5 hooks: - id: pylint exclude: ^tests/ diff --git a/setup.py b/setup.py index 6ce002c7..c7d875e3 100644 --- a/setup.py +++ b/setup.py @@ -35,7 +35,7 @@ "pandas", "pyyaml", "openmdao>=3.2", - "python-benedict", + "python-benedict<0.33.2", "statsmodels", ], extras_require={ From 69e12ee5ec1eec719b08ac0c31d21a2799667a09 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Mar 2024 15:39:19 -0600 Subject: [PATCH 122/240] moved interconnection distance from landfall dict to export_system_design sub dict. Formatted export system and electrical export files. --- ORBIT/phases/design/electrical_export.py | 32 ++++++++++++++------- ORBIT/phases/design/export_system_design.py | 9 +++--- 2 files changed, 26 insertions(+), 15 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 5f7dfc92..d02054ff 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -1,9 +1,12 @@ +"""Provides the `ElectricalDesign` class.""" + __author__ = ["Sophie Bredenkamp"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "" __email__ = [] import numpy as np + from ORBIT.phases.design._cables import CableSystem @@ -15,13 +18,13 @@ class ElectricalDesign(CableSystem): expected_config = { "site": {"distance_to_landfall": "km", "depth": "m"}, - "landfall": {"interconnection_distance": "km (optional)"}, "plant": {"capacity": "MW"}, "export_system_design": { "cables": "str", "num_redundant": "int (optional)", "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", + "interconnection_distance": "km (optional)", "cable_crossings": { "crossing_number": "int (optional)", "crossing_unit_cost": "float (optional)", @@ -78,7 +81,7 @@ def __init__(self, config, **kwargs): self._get_touchdown_distance() try: - self._distance_to_interconnection = config["landfall"][ + self._distance_to_interconnection = config["export_system_design"][ "interconnection_distance" ] except KeyError: @@ -104,8 +107,12 @@ def run(self): self.compute_total_cable() self.calc_crossing_cost() - self._outputs["export_system"] = {"system_cost": self.total_cable_cost} - for name, cable in self.cables.items(): + self._outputs["export_system"] = { + "interconnection_distance": self._distance_to_interconnection, + "system_cost": self.total_cable_cost, + } + + for _, cable in self.cables.items(): self._outputs["export_system"]["cable"] = { "linear_density": cable.linear_density, "sections": [self.length], @@ -175,7 +182,7 @@ def design_result(self): """ return self._outputs - #################### CABLES ######################## + # CABLES @property def total_cable_cost(self): @@ -270,13 +277,14 @@ def calc_crossing_cost(self): "crossing_unit_cost", 500000 ) * self._crossing_design.get("crossing_number", 0) - #################### SUBSTATION #################### + """SUBSTATION""" @property def total_substation_cost(self): - return (self.topside_cost - + self.substructure_cost - + self.substation_cost) + """Computes total substation cost""" + return ( + self.topside_cost + self.substructure_cost + self.substation_cost + ) def calc_num_substations(self): """Computes number of substations""" @@ -331,7 +339,7 @@ def calc_shunt_reactor_cost(self): ): compensation = 0 else: - for name, cable in self.cables.items(): + for _, cable in self.cables.items(): compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( compensation @@ -496,4 +504,6 @@ def calc_onshore_cost(self): + self.switchgear_cost ) - self._outputs["export_system"]["onshore_construction_cost"] = self.onshore_cost + self._outputs["export_system"][ + "onshore_construction_cost" + ] = self.onshore_cost diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 6c6ae0a0..c717e08a 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -19,7 +19,8 @@ class ExportSystemDesign(CableSystem): num_cables : int Total number of cables required for transmitting power. length : float - Length of a single cable connecting the OSS to the interconnection in km. + Length of a single cable connecting the OSS to the + interconnection in km. mass : float Mass of `length` in tonnes. cable : `Cable` @@ -37,13 +38,13 @@ class ExportSystemDesign(CableSystem): expected_config = { "site": {"distance_to_landfall": "km", "depth": "m"}, - "landfall": {"interconnection_distance": "km (optional)"}, "plant": {"capacity": "MW"}, "export_system_design": { "cables": "str", "num_redundant": "int (optional)", "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", + "interconnection_distance": "km (optional)", }, } @@ -81,7 +82,7 @@ def __init__(self, config, **kwargs): self._distance_to_landfall = config["site"]["distance_to_landfall"] self._get_touchdown_distance() try: - self._distance_to_interconnection = config["landfall"][ + self._distance_to_interconnection = config["export_system_design"][ "interconnection_distance" ] except KeyError: @@ -212,7 +213,7 @@ def design_result(self): } } - for name, cable in self.cables.items(): + for _, cable in self.cables.items(): output["export_system"]["cable"] = { "linear_density": cable.linear_density, From c91578ca1e0249c08dbe0d1b52a632f075480a4e Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 11 Mar 2024 15:40:27 -0600 Subject: [PATCH 123/240] added interconnection distance to kwargs test. --- tests/phases/design/test_electrical_design.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 605ea434..f8d04e9f 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -8,6 +8,7 @@ from itertools import product import pytest + from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ElectricalDesign @@ -143,6 +144,7 @@ def test_export_kwargs(): "num_redundant": 2, "touchdown_distance": 50, "percent_added_length": 0.15, + "interconnection_distance": 6, } o = ElectricalDesign(base) From 5c49b129b20b667406b9e3ebe0726fca1de44358 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 12 Mar 2024 10:41:29 -0600 Subject: [PATCH 124/240] Removed unused packages from Example - Parametric Manager --- examples/Example - Parametric Manager.ipynb | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/examples/Example - Parametric Manager.ipynb b/examples/Example - Parametric Manager.ipynb index dbbc4d1f..ed8220db 100644 --- a/examples/Example - Parametric Manager.ipynb +++ b/examples/Example - Parametric Manager.ipynb @@ -15,11 +15,9 @@ "metadata": {}, "outputs": [], "source": [ - "from ORBIT.phases.design import MonopileDesign, ElectricalDesign\n", + "from ORBIT.phases.design import MonopileDesign\n", "\n", - "from ORBIT import ParametricManager, ProjectManager\n", - "\n", - "import numpy as np" + "from ORBIT import ParametricManager\n" ] }, { From 7aeae5c6e11f1a312b8daabca187b762fa71b9c7 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 11:33:10 -0600 Subject: [PATCH 125/240] Added landfall sub dict to export_system dict. Added deprecation warnings. --- ORBIT/phases/install/cable_install/export.py | 56 ++++++++++++++++---- 1 file changed, 46 insertions(+), 10 deletions(-) diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index 87d96537..c6881d3a 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -8,8 +8,10 @@ from copy import deepcopy from math import ceil +from warnings import warn from marmot import process + from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase from ORBIT.core.exceptions import InsufficientCable @@ -49,11 +51,15 @@ class ExportCableInstallation(InstallPhase): "sections": [("length, km", "speed, km/h (optional)")], "number": "int (optional)", "cable_type": "str(optional, defualt: 'HVAC')", + "landfall": { + "trench_length": "km (optional)", + "interconnection_distance": "km (optional); default: 3km", + }, }, "interconnection_distance": "km (optional); default: 3km", "interconnection_voltage": "kV (optional); default: 345kV", "onshore_construction_cost": "$, (optional)", - "onshore_construction_time": "h, (optional)" + "onshore_construction_time": "h, (optional)", }, } @@ -133,6 +139,20 @@ def extract_distances(self): site = self.config["site"]["distance"] try: trench = self.config["landfall"]["trench_length"] + warn( + "landfall dictionary will be deprecated and moved \ + into [export_system][landfall].", + DeprecationWarning, + stacklevel=2, + ) + + except KeyError: + trench = 1 + + try: + trench = self.config["export_system_design"]["landfall"][ + "trench_length" + ] except KeyError: trench = 1 @@ -154,10 +174,16 @@ def onshore_construction(self, **kwargs): Default: 50000 USD/day """ - construction_time = self.config["export_system"].get("onshore_construction_time", 0.0) - construction_cost = self.config["export_system"].get("onshore_construction_cost", None) + construction_time = self.config["export_system"].get( + "onshore_construction_time", 0.0 + ) + construction_cost = self.config["export_system"].get( + "onshore_construction_cost", None + ) if construction_cost is None: - construction_cost = self.calculate_onshore_transmission_cost(**kwargs) + construction_cost = self.calculate_onshore_transmission_cost( + **kwargs + ) if construction_time: _ = self.env.timeout(construction_time) @@ -182,12 +208,22 @@ def calculate_onshore_transmission_cost(self, **kwargs): capacity = self.config["plant"]["capacity"] - voltage = self.config["export_system"].get( - "interconnection_voltage", 345 - ) - distance = self.config["export_system"].get( - "interconnection_distance", 3 - ) + system = self.config["export_system"] + + voltage = system.get("interconnection_voltage", 345) + + try: + distance = system["interconnection_distance"] + warn( + "[export_system][interconnection] will be deprecated and \ + moved into [export_system][landfall][interconnection].", + DeprecationWarning, + stacklevel=2, + ) + + except KeyError: + distance = 3 + # distance = system.get("interconnection_distance", 3) switchyard_cost = 18115 * voltage + 165944 onshore_substation_cost = ( From 31a5f3f2bf042270b18d602ffb0b645e877c1986 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 11:34:19 -0600 Subject: [PATCH 126/240] updated test to include a temporary check for deprecated warnings. --- .../cable_install/test_export_install.py | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 12f0c1dc..dc0392b0 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -9,6 +9,7 @@ from copy import deepcopy +from warnings import catch_warnings import pandas as pd import pytest @@ -245,3 +246,42 @@ def test_kwargs_for_export_install_in_ProjectManager(): else: assert True + + +def test_deprecated_values(): + """Temporary test for deprecated values""" + + base = deepcopy(base_config) + deprecated = deepcopy(base_config) + + deprecated["landfall"] = {"trench_length": 4} + new_export_system = { + "cable": {"linear_density": 50.0, "sections": [1000], "number": 1}, + "system_cost": 200e6, + "interconnection_distance": 5, + } + + deprecated["export_system"] = new_export_system + + with catch_warnings(record=True) as w: + + sim = ExportCableInstallation(base) + sim.run() + + assert len(w) == 0 + + sim = ExportCableInstallation(deprecated) + sim.run() + + assert len(w) == 2 + assert issubclass(w[0].category, DeprecationWarning) + assert ( + str(w[0].message) + == "landfall dictionary will be deprecated and moved into [export_system][landfall]." + ) + + assert issubclass(w[1].category, DeprecationWarning) + assert ( + str(w[1].message) + == "[export_system][interconnection] will be deprecated and moved into [export_system][landfall][interconnection]." + ) From 8b611a6c145b5e1fac10ead44e517af5fa5c4f21 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 13:36:42 -0600 Subject: [PATCH 127/240] Added landfall sub dict to export system design. Added deprecation warnings --- ORBIT/phases/design/export_system_design.py | 31 ++++++++++++++++++--- 1 file changed, 27 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index c717e08a..008ff970 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -5,6 +5,8 @@ __maintainer__ = "Rob Hammond" __email__ = "robert.hammond@nrel.gov" +from warnings import warn + import numpy as np from ORBIT.phases.design._cables import CableSystem @@ -38,13 +40,14 @@ class ExportSystemDesign(CableSystem): expected_config = { "site": {"distance_to_landfall": "km", "depth": "m"}, + "landfall": {"interconnection_distance": "km (optional)"}, "plant": {"capacity": "MW"}, "export_system_design": { "cables": "str", "num_redundant": "int (optional)", "touchdown_distance": "m (optional, default: 0)", "percent_added_length": "float (optional)", - "interconnection_distance": "km (optional)", + "landfall": {"interconnection_distance": "km (optional)"}, }, } @@ -55,7 +58,8 @@ class ExportSystemDesign(CableSystem): "number": "int", "sections": "list", "cable_power": "MW", - } + }, + "landfall": {"interconnection_distance": "km"}, } } @@ -82,9 +86,24 @@ def __init__(self, config, **kwargs): self._distance_to_landfall = config["site"]["distance_to_landfall"] self._get_touchdown_distance() try: - self._distance_to_interconnection = config["export_system_design"][ + self._distance_to_interconnection = config["landfall"][ "interconnection_distance" ] + warn( + "landfall dictionary will be deprecated and moved \ + into [export_system][landfall].", + DeprecationWarning, + stacklevel=2, + ) + + except KeyError: + self._distance_to_interconnection = 3 + + try: + self._distance_to_interconnection = config["export_system_design"][ + "landfall" + ]["interconnection_distance"] + except KeyError: self._distance_to_interconnection = 3 @@ -208,7 +227,11 @@ def design_result(self): output = { "export_system": { - "interconnection_distance": self._distance_to_interconnection, + "landfall": { + "interconnection_distance": ( + self._distance_to_interconnection + ) + }, "system_cost": self.total_cost, } } From 4574c1467e82fd6781b89fc353cfa87d94b7ed82 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 13:40:09 -0600 Subject: [PATCH 128/240] Removed landfall from test yaml config. Adjusted results test and added a deprecation test. --- .../library/project/config/export_design.yaml | 4 +-- .../design/test_export_system_design.py | 30 +++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/tests/data/library/project/config/export_design.yaml b/tests/data/library/project/config/export_design.yaml index 4cab54c7..c8a0b1e5 100644 --- a/tests/data/library/project/config/export_design.yaml +++ b/tests/data/library/project/config/export_design.yaml @@ -2,10 +2,10 @@ export_system_design: cables: XLPE_630mm_33kV percent_added_length: 0.01 percent_redundant: 0.0 + landfall: + interconnection_distance: 3 plant: capacity: 350 site: depth: 20 distance_to_landfall: 30 -landfall: - interconnection_distance: 3 diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 7039bb5b..e9ce1315 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -6,8 +6,10 @@ __email__ = "robert.hammond@nrel.gov" from copy import deepcopy +from warnings import catch_warnings import pytest + from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import ExportSystemDesign @@ -97,10 +99,12 @@ def test_design_result(): _ = export.cable.name cables = export.design_result["export_system"]["cable"] + # landfall = export.design_results["export_system"]["landfall"] assert cables["sections"] == [export.length] assert cables["number"] == 9 assert cables["linear_density"] == export.cable.linear_density + # assert landfall["interconnection_distance"] == 3 def test_floating_length_calculations(): @@ -121,3 +125,29 @@ def test_floating_length_calculations(): new.run() assert new.total_length < base_length + + +def test_deprecated_landfall(): + + base = deepcopy(config) + deprecated = deepcopy(config) + + deprecated["landfall"] = {"interconnection_distance": 4} + + with catch_warnings(record=True) as w: + + sim = ExportSystemDesign(base) + sim.run() + + assert len(w) == 0 + + sim = ExportSystemDesign(deprecated) + sim.run() + + assert len(w) == 1 + assert issubclass(w[0].category, DeprecationWarning) + assert ( + str(w[0].message) + == "landfall dictionary will be deprecated and moved \ + into [export_system][landfall]." + ) From 5195741efe5dad8a2399a21bc9d71e7183f40402 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 13:50:08 -0600 Subject: [PATCH 129/240] Same updates for electrical design as export system design. Added deprecation warnings. --- ORBIT/phases/design/electrical_export.py | 24 +++++++++++++++++++-- ORBIT/phases/design/export_system_design.py | 2 +- 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index d02054ff..e7b2c7ef 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -5,6 +5,8 @@ __maintainer__ = "" __email__ = [] +from warnings import warn + import numpy as np from ORBIT.phases.design._cables import CableSystem @@ -18,6 +20,7 @@ class ElectricalDesign(CableSystem): expected_config = { "site": {"distance_to_landfall": "km", "depth": "m"}, + "landfall": {"interconnection_distance": "km (optional)"}, "plant": {"capacity": "MW"}, "export_system_design": { "cables": "str", @@ -81,9 +84,24 @@ def __init__(self, config, **kwargs): self._get_touchdown_distance() try: - self._distance_to_interconnection = config["export_system_design"][ + self._distance_to_interconnection = config["landfall"][ "interconnection_distance" ] + warn( + "landfall dictionary will be deprecated and moved \ + into [export_system_design][landfall].", + DeprecationWarning, + stacklevel=2, + ) + + except KeyError: + self._distance_to_interconnection = 3 + + try: + self._distance_to_interconnection = config["export_system_design"][ + "landfall" + ]["interconnection_distance"] + except KeyError: self._distance_to_interconnection = 3 @@ -108,7 +126,9 @@ def run(self): self.calc_crossing_cost() self._outputs["export_system"] = { - "interconnection_distance": self._distance_to_interconnection, + "landfall": { + "interconnection_distance": (self._distance_to_interconnection) + }, "system_cost": self.total_cable_cost, } diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 008ff970..d4212bbb 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -91,7 +91,7 @@ def __init__(self, config, **kwargs): ] warn( "landfall dictionary will be deprecated and moved \ - into [export_system][landfall].", + into [export_system_design][landfall].", DeprecationWarning, stacklevel=2, ) From 7999548e3adbda593774696c54f9f2c77c5adc78 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 13:51:05 -0600 Subject: [PATCH 130/240] Adjusted electrical design base config and added deprecation test. --- tests/phases/design/test_electrical_design.py | 31 +++++++++++++++++-- .../design/test_export_system_design.py | 2 +- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index f8d04e9f..0957352f 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -5,6 +5,7 @@ from copy import deepcopy +from warnings import catch_warnings from itertools import product import pytest @@ -16,9 +17,9 @@ base = { "site": {"distance_to_landfall": 50, "depth": 30}, - "landfall": {}, "plant": {"capacity": 500}, "export_system_design": {"cables": "XLPE_630mm_220kV"}, + "landfall": {}, "substation_design": {}, } @@ -144,7 +145,7 @@ def test_export_kwargs(): "num_redundant": 2, "touchdown_distance": 50, "percent_added_length": 0.15, - "interconnection_distance": 6, + # "interconnection_distance": 6, } o = ElectricalDesign(base) @@ -326,3 +327,29 @@ def test_cost_crossing(): cross_sim.run() assert cross_sim.crossing_cost != base_sim.crossing_cost + + +def test_deprecated_landfall(): + + base = deepcopy(config) + deprecated = deepcopy(config) + + deprecated["landfall"] = {"interconnection_distance": 4} + + with catch_warnings(record=True) as w: + + sim = ElectricalDesign(base) + sim.run() + + assert len(w) == 0 + + sim = ElectricalDesign(deprecated) + sim.run() + + assert len(w) == 1 + assert issubclass(w[0].category, DeprecationWarning) + assert ( + str(w[0].message) + == "landfall dictionary will be deprecated and moved \ + into [export_system_design][landfall]." + ) diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index e9ce1315..77919a13 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -149,5 +149,5 @@ def test_deprecated_landfall(): assert ( str(w[0].message) == "landfall dictionary will be deprecated and moved \ - into [export_system][landfall]." + into [export_system_design][landfall]." ) From c67c205e3eb8a443143a3ca1cc7632bcd3c904b9 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 14 Mar 2024 14:10:11 -0600 Subject: [PATCH 131/240] Updated wisdem api to have deprecation warnings and new dictionaries. Fixed formatted test strings --- ORBIT/api/wisdem.py | 9 +++++++++ .../phases/install/cable_install/test_export_install.py | 6 ++++-- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 8320e99c..04ef9b88 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -6,6 +6,8 @@ __email__ = "jake.nunemaker@nrel.gov" +from warnings import warn + import openmdao.api as om from ORBIT import ProjectManager @@ -291,6 +293,7 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o }, "export_system_design": { "cables": "XLPE_1000m_220kV", + "landfall":{"interconnection_distance": float(inputs["interconnection_distance"])}, "interconnection_distance": float(inputs["interconnection_distance"]), "percent_added_length": 0.1, }, @@ -326,6 +329,12 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o ], } + if config["landfall"]["interconnection_distance"]: + warn("landfall dictionary will be deprecated and moved into [export_system][landfall].", DeprecationWarning, stacklevel=2) + + if config["export_system_design"]["interconnection_distance"]: + warn("[export_system_design][interconnection_distance] will be deprecated and moved to [export_system_design][landfall][interconnection_distance].", DeprecationWarning, stacklevel=2) + # Unique design phases if floating_flag: config["install_phases"] = { diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index dc0392b0..3deea28a 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -277,11 +277,13 @@ def test_deprecated_values(): assert issubclass(w[0].category, DeprecationWarning) assert ( str(w[0].message) - == "landfall dictionary will be deprecated and moved into [export_system][landfall]." + == "landfall dictionary will be deprecated and moved \ + into [export_system][landfall]." ) assert issubclass(w[1].category, DeprecationWarning) assert ( str(w[1].message) - == "[export_system][interconnection] will be deprecated and moved into [export_system][landfall][interconnection]." + == "[export_system][interconnection] will be deprecated and \ + moved into [export_system][landfall][interconnection]." ) From 0ce12628375425baa5ac721f024074bd8a8d68e6 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 15 Mar 2024 11:50:39 -0600 Subject: [PATCH 132/240] Updated electricl export deprecated warning conditions and tests. --- ORBIT/phases/design/electrical_export.py | 24 +++++++------------ tests/phases/design/test_electrical_design.py | 21 +++++----------- 2 files changed, 15 insertions(+), 30 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index e7b2c7ef..dc91fad8 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -83,27 +83,21 @@ def __init__(self, config, **kwargs): self._plant_capacity = self.config["plant"]["capacity"] self._get_touchdown_distance() - try: - self._distance_to_interconnection = config["landfall"][ - "interconnection_distance" - ] + _landfall = self.config.get("landfall", {}) + if _landfall: warn( - "landfall dictionary will be deprecated and moved \ - into [export_system_design][landfall].", + "landfall dictionary will be deprecated and moved" + " into [export_system_design][landfall].", DeprecationWarning, stacklevel=2, ) - except KeyError: - self._distance_to_interconnection = 3 - - try: - self._distance_to_interconnection = config["export_system_design"][ - "landfall" - ]["interconnection_distance"] + else: + _landfall = self.config["export_system_design"].get("landfall", {}) - except KeyError: - self._distance_to_interconnection = 3 + self._distance_to_interconnection = _landfall.get( + "interconnection_distance", 3 + ) # SUBSTATION self._outputs = {} diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 0957352f..45dd2fbf 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -4,8 +4,8 @@ __email__ = "Jake.Nunemaker@nrel.gov" +import warnings from copy import deepcopy -from warnings import catch_warnings from itertools import product import pytest @@ -332,24 +332,15 @@ def test_cost_crossing(): def test_deprecated_landfall(): base = deepcopy(config) - deprecated = deepcopy(config) - - deprecated["landfall"] = {"interconnection_distance": 4} - - with catch_warnings(record=True) as w: + with warnings.catch_warnings(): + warnings.simplefilter("error") sim = ElectricalDesign(base) sim.run() - assert len(w) == 0 + deprecated = deepcopy(base) + deprecated["landfall"] = {"interconnection_distance": 4} + with pytest.deprecated_call(): sim = ElectricalDesign(deprecated) sim.run() - - assert len(w) == 1 - assert issubclass(w[0].category, DeprecationWarning) - assert ( - str(w[0].message) - == "landfall dictionary will be deprecated and moved \ - into [export_system_design][landfall]." - ) From 55941cc23079336e4bb2bdff64fea2605ce4b276 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 15 Mar 2024 11:51:32 -0600 Subject: [PATCH 133/240] Updated export system deprecated warning conditions and tests. --- ORBIT/phases/design/export_system_design.py | 25 ++++++++----------- .../design/test_export_system_design.py | 21 +++++----------- 2 files changed, 16 insertions(+), 30 deletions(-) diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index d4212bbb..a5ba8180 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -85,27 +85,22 @@ def __init__(self, config, **kwargs): self._plant_capacity = self.config["plant"]["capacity"] self._distance_to_landfall = config["site"]["distance_to_landfall"] self._get_touchdown_distance() - try: - self._distance_to_interconnection = config["landfall"][ - "interconnection_distance" - ] + + _landfall = self.config.get("landfall", {}) + if _landfall: warn( - "landfall dictionary will be deprecated and moved \ - into [export_system_design][landfall].", + "landfall dictionary will be deprecated and moved" + " into [export_system_design][landfall].", DeprecationWarning, stacklevel=2, ) - except KeyError: - self._distance_to_interconnection = 3 - - try: - self._distance_to_interconnection = config["export_system_design"][ - "landfall" - ]["interconnection_distance"] + else: + _landfall = self.config["export_system_design"].get("landfall", {}) - except KeyError: - self._distance_to_interconnection = 3 + self._distance_to_interconnection = _landfall.get( + "interconnection_distance", 3 + ) def run(self): """ diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 77919a13..1acfb9d8 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -5,8 +5,8 @@ __maintainer__ = "Rob Hammond" __email__ = "robert.hammond@nrel.gov" +import warnings from copy import deepcopy -from warnings import catch_warnings import pytest @@ -130,24 +130,15 @@ def test_floating_length_calculations(): def test_deprecated_landfall(): base = deepcopy(config) - deprecated = deepcopy(config) - - deprecated["landfall"] = {"interconnection_distance": 4} - - with catch_warnings(record=True) as w: + with warnings.catch_warnings(): + warnings.simplefilter("error") sim = ExportSystemDesign(base) sim.run() - assert len(w) == 0 + deprecated = deepcopy(base) + deprecated["landfall"] = {"interconnection_distance": 4} + with pytest.deprecated_call(): sim = ExportSystemDesign(deprecated) sim.run() - - assert len(w) == 1 - assert issubclass(w[0].category, DeprecationWarning) - assert ( - str(w[0].message) - == "landfall dictionary will be deprecated and moved \ - into [export_system_design][landfall]." - ) From 2bf7f284da3f16559754ec0c6a4fcbec5e7bb13a Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 15 Mar 2024 11:53:36 -0600 Subject: [PATCH 134/240] Updated export install deprecated conditions and tests. --- ORBIT/phases/install/cable_install/export.py | 40 ++++++++--------- .../cable_install/test_export_install.py | 44 ++++++++++--------- 2 files changed, 42 insertions(+), 42 deletions(-) diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index c6881d3a..b214af4f 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -56,7 +56,7 @@ class ExportCableInstallation(InstallPhase): "interconnection_distance": "km (optional); default: 3km", }, }, - "interconnection_distance": "km (optional); default: 3km", + "interconnection_distance": "km (optional)", "interconnection_voltage": "kV (optional); default: 345kV", "onshore_construction_cost": "$, (optional)", "onshore_construction_time": "h, (optional)", @@ -137,25 +137,19 @@ def extract_distances(self): """Extracts distances from input configuration or default values.""" site = self.config["site"]["distance"] - try: - trench = self.config["landfall"]["trench_length"] + + _landfall = self.config.get("landfall", {}) + if _landfall: warn( - "landfall dictionary will be deprecated and moved \ - into [export_system][landfall].", + "landfall dictionary will be deprecated and moved" + " into [export_system][landfall].", DeprecationWarning, stacklevel=2, ) + else: + _landfall = self.config["export_system"].get("landfall", {}) - except KeyError: - trench = 1 - - try: - trench = self.config["export_system_design"]["landfall"][ - "trench_length" - ] - - except KeyError: - trench = 1 + trench = _landfall.get("trench_length", 1) self.distances = {"site": site, "trench": trench} @@ -212,18 +206,20 @@ def calculate_onshore_transmission_cost(self, **kwargs): voltage = system.get("interconnection_voltage", 345) - try: - distance = system["interconnection_distance"] + distance = system.get("interconnection_distance", None) + + if distance: warn( - "[export_system][interconnection] will be deprecated and \ - moved into [export_system][landfall][interconnection].", + "[export_system][interconnection_distance] will be deprecated" + " and moved to" + " [export_system][landfall][interconnection_distance].", DeprecationWarning, stacklevel=2, ) - except KeyError: - distance = 3 - # distance = system.get("interconnection_distance", 3) + landfall = system.get("landfall", {}) + + distance = landfall.get("interconnection_distance", 3) switchyard_cost = 18115 * voltage + 165944 onshore_substation_cost = ( diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index 3deea28a..36f2dd8e 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -8,8 +8,8 @@ __email__ = "Jake.Nunemaker@nrel.gov" +import warnings from copy import deepcopy -from warnings import catch_warnings import pandas as pd import pytest @@ -252,6 +252,12 @@ def test_deprecated_values(): """Temporary test for deprecated values""" base = deepcopy(base_config) + + with warnings.catch_warnings(): + warnings.simplefilter("error") + sim = ExportCableInstallation(base) + sim.run() + deprecated = deepcopy(base_config) deprecated["landfall"] = {"trench_length": 4} @@ -263,27 +269,25 @@ def test_deprecated_values(): deprecated["export_system"] = new_export_system - with catch_warnings(record=True) as w: - - sim = ExportCableInstallation(base) - sim.run() + with pytest.deprecated_call(): - assert len(w) == 0 + # sim = ExportCableInstallation(base) + # sim.run() sim = ExportCableInstallation(deprecated) sim.run() - assert len(w) == 2 - assert issubclass(w[0].category, DeprecationWarning) - assert ( - str(w[0].message) - == "landfall dictionary will be deprecated and moved \ - into [export_system][landfall]." - ) - - assert issubclass(w[1].category, DeprecationWarning) - assert ( - str(w[1].message) - == "[export_system][interconnection] will be deprecated and \ - moved into [export_system][landfall][interconnection]." - ) + # assert len(w) == 2 + # assert issubclass(w[0].category, DeprecationWarning) + # assert ( + # str(w[0].message) + # == "landfall dictionary will be deprecated and moved \ + # into [export_system][landfall]." + # ) + + # assert issubclass(w[1].category, DeprecationWarning) + # assert ( + # str(w[1].message) + # == "[export_system][interconnection] will be deprecated and \ + # moved into [export_system][landfall][interconnection]." + # ) From bb50f91450f0629a325d24759c8a5cce3be96173 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 15 Mar 2024 11:53:59 -0600 Subject: [PATCH 135/240] Updated wisdem api deprecated warning messages. --- ORBIT/api/wisdem.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 04ef9b88..f0524928 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -330,10 +330,19 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o } if config["landfall"]["interconnection_distance"]: - warn("landfall dictionary will be deprecated and moved into [export_system][landfall].", DeprecationWarning, stacklevel=2) + warn("landfall dictionary will be deprecated and moved" + " into [export_system_design][landfall].", + DeprecationWarning, + stacklevel=2 + ) if config["export_system_design"]["interconnection_distance"]: - warn("[export_system_design][interconnection_distance] will be deprecated and moved to [export_system_design][landfall][interconnection_distance].", DeprecationWarning, stacklevel=2) + warn( + "[export_system][interconnection_distance] will be deprecated and" + " moved to [export_system_design][landfall][interconnection_distance].", + DeprecationWarning, + stacklevel=2, + ) # Unique design phases if floating_flag: From ad8920eebba574c946f68b6f3eecdefb8f376ba5 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 25 Mar 2024 20:24:12 -0600 Subject: [PATCH 136/240] cleaned up electrical_export per comments. --- ORBIT/phases/design/electrical_export.py | 34 +++++++++--------------- 1 file changed, 12 insertions(+), 22 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 55897c84..8ebd239a 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -254,16 +254,12 @@ def compute_number_cables(self): _num_redundant = self._design.get("num_redundant", 0) + num_required = np.ceil(self._plant_capacity / self.cable.cable_power) + num_redundant = self._design.get("num_redundant", 0) + if "HVDC" in self.cable.cable_type: - num_required = 2 * np.ceil( - self._plant_capacity / self.cable.cable_power - ) - num_redundant = 2 * _num_redundant - else: - num_required = np.ceil( - self._plant_capacity / self.cable.cable_power - ) - num_redundant = _num_redundant + num_required *= 2 + num_redundant *= 2 self.num_cables = int(num_required + num_redundant) @@ -415,15 +411,13 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] shunt_cost_rate = self._design.get("shunt_cost_rate", 1e4) - _num_shunts = self.num_cables - if "HVDC" in self.cable.cable_type: self.compensation = 0 else: for _, cable in self.cables.items(): self.compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - self.compensation * shunt_cost_rate * _num_shunts + self.compensation * shunt_cost_rate * self.num_cables ) def calc_switchgear_costs(self): @@ -436,10 +430,9 @@ def calc_switchgear_costs(self): switchgear_cost = self._design.get("switchgear_cost", 4e6) - if "HVDC" in self.cable.cable_type: - num_switchgear = 0 - else: - num_switchgear = self.num_cables + num_switchgear = ( + 0 if "HVDC" in self.cable.cable_type else self.num_cables + ) self.switchgear_cost = num_switchgear * switchgear_cost @@ -453,10 +446,9 @@ def calc_dc_breaker_cost(self): dc_breaker_cost = self._design.get("dc_breaker_cost", 10.5e6) - if "HVDC" in self.cable.cable_type: - num_dc_breakers = self.num_cables - else: - num_dc_breakers = 0 + num_dc_breakers = ( + self.num_cables if "HVDC" in self.cable.cable_type else 0 + ) self.dc_breaker_cost = num_dc_breakers * dc_breaker_cost @@ -571,8 +563,6 @@ def calc_topside_mass_and_cost(self): """ _design = self.config.get("substation_design", {}) - # topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) - # topside_design_cost = _design.get("topside_design_cost", 4.5e6) self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations From 48a2523825074414ed7b96b52c8c3446309cc04f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 26 Mar 2024 14:30:25 -0600 Subject: [PATCH 137/240] Updated changelog and ElectricalDesign doc. --- docs/source/changelog.rst | 9 ++ .../phases/design/doc_ElectricalDesign.rst | 92 +++++++++++++------ 2 files changed, 75 insertions(+), 26 deletions(-) diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 07ab75f2..2f262434 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -3,6 +3,15 @@ ORBIT Changelog =============== +Unreleased (TBD) +---------------- + +- Added ``ElectricalDesign`` module. It includes HVDC options and substitutes ``ExportSystemDesign`` and ``OffshoreSubstationDesign``. +- Updated documentation for `ElectricalDesign`, `ParametricManager`, and `ProjectManager`. +- Added an example notebook: `Example - Using HVDC or HVAC` +- Variables ``mpt_cost`` and ``shut_cost_rate`` now have units of USD/cable (previous USD/MW) +- Expanded tests to demonstrate new features in ``ElectricalDesign``. + 1.0.8 ----- diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index 7607b7d8..14519f88 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -10,8 +10,9 @@ Overview Below is an overview of the process used to design an export cable system and offshore substation in ORBIT using the ElectricalDesign module. This module is to be used in place of both the ExportSystemDesign module and the OffshoreSubstationDesign -module as it codesigns the export cables and offshore substation. For more detail on the -helper classes used to support this design please see :doc:`Cabling Helper Classes +module as it codesigns the export cables and offshore substation. Depending on whether +HVAC or HVDC cables are selected, different components will contribute to the final BOS. +For more detail on the helper classes used to support this design please see :doc:`Cabling Helper Classes `, specifically :class:`Cable` and :class:`CableSystem`. @@ -39,49 +40,88 @@ impractical. :math:`length = (d + distance_\text{landfall} + distance_\text{interconnection}) * (1 + length_\text{percent_added})` +Cable Crossing Cost +--------- +Optional inputs for both number of cable crossings and unit cost per cable +crossing. The default number of cable crossings is 0 and cost per cable +crossing is $500,000. This cost includes materials, installation, etc. Crossing +cost is calculated as product of number of crossings and unit cost. -Number of Required Power Transformer and Tranformer Rating +Number of Required Power Transformer, Tranformer Rating, and Cost --------- -The number of power transformers required is assumed to be equal to the number +The number of main power transformers (MPT) required is assumed to be equal to the number of required export cables. The transformer rating is calculated by dividing the -windfarm's capacity by the number of power transformers. - - -Shunt Reactors and Reactive Power Compensation +windfarm's capacity by the number of MPTs. MPTs are only required if the +export cables are HVAC. The default cost of the MPT is $2.87m per HVAC cable. Therefore, the total MPT cost is +proportional to the number of cables. Note: Previous versions may have used curve-fits to +calculate total MPT cost based on the windfarm's capacity. The MPT unit cost ($/cable) can +be ovewritten by the user by setting (``mpt_cost``) to the desired cost. If the export cables +are HVDC, then the cost of power transformers will be $0. + +Number of Shunt Reactors, Reactive Power Compensation, and Cost --------- The shunt reactor cost is dependent on the amount of reactive power compensation -required based on the distance of the substation to shore. There is assumed to be -one shunt reactor for each HVAC export cable. HVDC export systems do not require -reactive power compensation, thus the shunt reactor cost is zero for HVDC systems. - - -Number of Required Switchgears +required based on the distance of the substation to shore. This model assumes +one shunt reactor for each HVAC export cable. An HVDC export systems do not require +reactive power compensation. The default cost rate of the shunt reactors is $10k per HVAC cable. The total cost is proportional +to the number of cables multipled by a cable-specific compensation factor. The default cost rate +can be overwritten by the user by setting (``shunt_reactor_rate``) to the desired cost. The shunt +reactor cost is $0 for HVDC systems. + +Number of Required Switchgears and Cost --------- -The number of shunt reactors required is assumed to be equal to the number of -required export cables. +The number of switchgear relays required is assumed to be equal to the number of +required export cables. Switchgear cost is only necessary if HVAC export cables +are chosen. The default cost is $4m per cable for HVAC. The default cost can be overwritten by the user by +setting (``switchgear_cost``) to the desired cost. Switchgear cost is equal to $0 for HVDC export +cables. +Number of Circuit Breakers and Cost +--------- +The number of circuit breakers required is assumed to be equal to the number of required +export cables. Breakers are only necssary if HVDC export cables are chosen. The default cost is +$10.6m per HVDC cable. The default cost can be overwritten by the user by setting (``dc_breaker_cost``) +to the desired cost. Breaker cost is $0 for HVAC cables. -Number of Required AC\DC Converters +Number of Required AC\DC Converters and Cost --------- AC\DC converters are only required for HVDC export cables. The number of converters is assumed to be equal to the number of HVDC export cables. - -Cable Crossing Cost +Ancillary System Cost --------- -Optional inputs for both number of cable crossings and unit cost per cable -crossing. The default number of cable crossings is 0 and cost per cable -crossing is $500,000. This cost includes materials, installation, etc. Crossing -cost is calculated as product of number of crossings and unit cost. - +Costs are included such as a backup generator, workspace cost, and miscellous to +capture any additional features outside the main components. The user can define each +variable by setting (``backup_gen_cost``), (``workspace_cost``), and (``other_ancillary_cost``). + +Assembly Cost (On Land) +---------- +The majority of the electrical components are located on the offshore substation platform, but +they must be assembled on land. Therefore, an assembly factor of 7.5% is added to the components cost. +Those components include switchgear, shut reactors, and ancillary costs. The user can change the +factor by setting (``topside_assembly_factor``) to the desired percentage. + +Substation Topside Mass and Cost +---------- +We assume that the topside design cost is a fixed amount based on the export cables (either HVDC or HVAC). +The user can specify the topside cost by setting (``topside_design_cost``). The mass of the topside is +determined by a curve fit. + +Substation Substructure Mass and Cost +---------- +The mass and cost associated with the substructure of the offshore substation are based on +curve fits. The topside mass will drive the mass/size of the substructure. Then, the cost of the +substructure is determined by its mass. The substructure has a default cost rate of $3000 per ton of +steel. The value can be overwritten by setting (``oss_substructure_cost_rate``) to the desired cost rate. Onshore Cost --------- The onshore cost is considered to be the minimum cost of interconnection. This includes the major required hardware for a cable connection onshore. For HVDC cables, it includes the converter cost, DC breaker cost, and transformer cost. For HVAC, it includes the -transformer cost and switchgear cost. - +transformer cost and switchgear cost. The onshore costs may or may not be included in the BOS +of the wind farm. Therefore, this cost is not included in the total ``system_capex`` +calculated by ProjectManager. Design Result --------- From f415508898987d4da79edfe23126f652e081d447 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 1 Apr 2024 14:51:08 -0600 Subject: [PATCH 138/240] Fixed mpt and shunt costs to be _unit_cost, rather than cost_rate so as not to confilct. Updated tests --- ORBIT/phases/design/electrical_export.py | 23 +++++++++---------- tests/phases/design/test_electrical_design.py | 4 ++-- 2 files changed, 13 insertions(+), 14 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 8ebd239a..daf83ed0 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -58,10 +58,9 @@ class ElectricalDesign(CableSystem): "substation_design": { "substation_capacity": "MW (optional)", "num_substations": "int (optional)", - "mpt_cost": "USD/cable (optional)", - "topside_fab_cost_rate": "USD/t (optional)", + "mpt_unit_cost": "USD/cable (optional)", "topside_design_cost": "USD (optional)", - "shunt_cost_rate": "USD/cable (optional)", + "shunt_unit_cost": "USD/cable (optional)", "switchgear_cost": "USD (optional)", "dc_breaker_cost": "USD (optional)", "backup_gen_cost": "USD (optional)", @@ -74,7 +73,7 @@ class ElectricalDesign(CableSystem): "oss_pile_cost_rate": "USD/t (optional)", }, "onshore_substation_design": { - "shunt_cost_rate": "USD/cable (optional)", + "shunt_unit_cost": "USD/cable (optional)", "onshore_converter_cost": "USD (optional)", }, } @@ -383,10 +382,10 @@ def calc_mpt_cost(self): Parameters ---------- - mpt_cost : int | float + mpt_unit_cost : int | float """ - _mpt_cost = self._design.get("mpt_cost", 2.87e6) + _mpt_cost = self._design.get("mpt_unit_cost", 2.87e6) self.num_mpt = self.num_cables @@ -405,11 +404,11 @@ def calc_shunt_reactor_cost(self): Parameters ---------- - shunt_cost_rate : int | float + shunt_unit_cost : int | float """ touchdown = self.config["site"]["distance_to_landfall"] - shunt_cost_rate = self._design.get("shunt_cost_rate", 1e4) + shunt_unit_cost = self._design.get("shunt_unit_cost", 1e4) if "HVDC" in self.cable.cable_type: self.compensation = 0 @@ -417,7 +416,7 @@ def calc_shunt_reactor_cost(self): for _, cable in self.cables.items(): self.compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( - self.compensation * shunt_cost_rate * self.num_cables + self.compensation * shunt_unit_cost * self.num_cables ) def calc_switchgear_costs(self): @@ -580,21 +579,21 @@ def calc_onshore_cost(self): Parameters ---------- - shunt_cost_rate : int | float + shunt_unit_cost : int | float onshore_converter_cost: int | float switchgear_cost: int | float """ _design = self.config.get("onshore_substation_design", {}) - _shunt_cost_rate = _design.get("shunt_cost_rate", 1.3e4) # per cable + _shunt_unit_cost = _design.get("shunt_unit_cost", 1.3e4) # per cable _switchgear_cost = _design.get("switchgear_cost", 9.33e6) # per cable _compensation_rate = _design.get( "compensation_rate", 31.3e6 ) # per cable self.onshore_shunt_reactor_cost = ( - self.compensation * self.num_cables * _shunt_cost_rate + self.compensation * self.num_cables * _shunt_unit_cost ) if self.cable.cable_type == "HVDC-monopole": diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index ea34734f..2ca93e26 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -61,10 +61,10 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_ac_oss_kwargs(): test_kwargs = { - "mpt_cost": 13500, + "mpt_unit_cost": 13500, # "topside_fab_cost_rate": 17000, # breaks "topside_design_cost": 7e6, - "shunt_cost_rate": 40000, + "shunt_unit_cost": 40000, "switchgear_cost": 15e5, "backup_gen_cost": 2e6, "workspace_cost": 3e6, From 5c262df2b7f9dc193b5b32fc4f6fba80efb08f9c Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 1 Apr 2024 15:11:37 -0600 Subject: [PATCH 139/240] Updated changelog to include some release notes. --- docs/source/changelog.rst | 22 +++++++++++++++--- docs/source/images/ElectricalDesignConfig.png | Bin 0 -> 285137 bytes 2 files changed, 19 insertions(+), 3 deletions(-) create mode 100644 docs/source/images/ElectricalDesignConfig.png diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 2f262434..0b8e1003 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -6,10 +6,26 @@ ORBIT Changelog Unreleased (TBD) ---------------- -- Added ``ElectricalDesign`` module. It includes HVDC options and substitutes ``ExportSystemDesign`` and ``OffshoreSubstationDesign``. -- Updated documentation for `ElectricalDesign`, `ParametricManager`, and `ProjectManager`. +- Updated ``ElectricalDesign`` module. +This class combines the elements of ``ExportSystemDesign`` and the ``OffshoreSubstationDesign`` modules. Its purpose is to represent the export system more accurately +by linking the type of cable (AC versus DC) and substation’s components (i.e. transformers versus converters).Figure 1 shows how to add ElectricalDesign() to a yaml +configuration file. Most export and substation component costs were updated to include a per-unit cost rather than a per-MW cost rate and they can be added to the +yaml file as arguments too. Otherwise, those per-unit costs use default and were determined with the help of a subcontractor. + - This module’s components’ cost scales with number of cables and substations rather than plant capacity. + - The offshore substation cost is calculated based on the cable type and number of cables, rather than scaling function based on plant capacity. + - The mass of an HVDC and HVAC substation are assumed to be the same. Without any new information the substructure mass and cost functions did not change. + - An experimental onshore cost function was also added to account for the duplicated interconnection components. Costs will vary depending on the cable type. + +.. image:: ./images/ElectricalDesignConfig.png + +Figure 1: Adding the new ElectricalDesign class to design phase in the yaml configuration file (left) versus using the original ExportDesignSystem and +OffshoreSubstationDesign classes (right). Note: ORBIT will not override output values from a design phase, so it will use the first instance and ignore +any subsequent designs that produce the same outputs. + - Added an example notebook: `Example - Using HVDC or HVAC` -- Variables ``mpt_cost`` and ``shut_cost_rate`` now have units of USD/cable (previous USD/MW) +This new example showcases the capabilities of the ``ElectricalDesign`` class. It demonstrates how to create projects using HVAC or HVDC cables and +how to use ParametricManager to compare the two design decisions. + - Expanded tests to demonstrate new features in ``ElectricalDesign``. 1.0.8 diff --git a/docs/source/images/ElectricalDesignConfig.png b/docs/source/images/ElectricalDesignConfig.png new file mode 100644 index 0000000000000000000000000000000000000000..5721c962933a7b63b350b19fb6e733a66c21d91d GIT binary patch literal 285137 zcmZ^~1z23m(k?smcZMR^GnL_$OW0DvMTDXI(rfIt8MR6RWGE9IB2Di;8NENCtw zq9`RILayjwYie#~0su&cC1}8Dstn;~YR5)Hgb~Qesjp~4B@xJ}gK!}p4H&V2oL+o* z1{Y(cuDWbPD57SDZ;R$Gz2n~&9}R_swD6EzcH|I$HCK4qw%eZkzRhBP;dL~%App!O z*!BG+R)zM{QEI26SvYgrgMCbLKqs^ac zUOI5)+R3Bf0GKfLgo05?NasR;GlopfSTulAf11J=-pJchh&B*9$SnuijLt3rxsd)$ zuSre^ndqlFKy|iJM+z2DI}&Y%ea4mzTZU#xi=j^kgk(TfDcGDC3-lJFFGGk}d)d5A zf1vRZ_|C`@O>aA}2Ui+0Uwp$PAH~|UD}2e?zgwr~mf-uQIHo19VI7`5EaxCs3Z?X;@8GV8X2E!Lx?HSVICQ;ssfy( z6u(Zlb8y?*wJ#RPf@y`rZuiXkKhs?V)?GAS+->SqjsP(jeH104lduJN@Y>1A6s#buSPN6O7J-yc)qc4{psof(-H)w0g;X zC=trNfh^FQekecywB$!Q=r|!<^!i(_tL}GV3g{a^gh2psBik5Of@;`P^o$S*u`3H5 z0kSs9Z-E1=46D0l? z;l#49+KD**3O{_)y3k5;YAN5vC|$g*CR^Iwi{W^edKewfv>>=EfnoVWv3*H|U+~fF zCE8oSs>i3k7uOK3vSv~0=)DWb5`cWfGap*_QNqOSlPiDBX}ORs>xEl&PUIQcGpvSs z;?VoT4~3+KEaB~5T^vjA2rFs76v_kGiZNuY|#LoXk?o1U+kL#Nq)r!G|6z%5CTnDb$@3A%0-}y->QM& zCxAq!lpU-ND5=ZY4(}wB`3!jF@4CSrKu#4DK8fMo3#t-5!Y~U8yCe6P0OoJ2}&mr7^`YL&w8fz`8|OKz|n+ z74}4hDV1fca6uy$+nDF2j9~u89B-dzAF=q$m5`WPpJ<;JwIsEeSe|m8a!$3%PVz8L zf*C{B5TUV5H7#%KD6Il53$-mZcN|Mh%U~9LDz;@fH+5vJSc-&}NO5j@!AfqclA0Q) z%C%yII?nfTHQn51jqCISk+~>~4;C&KR(0nV%5~Hh%X9KYtLmO2`O0NQKC{>s0?r6^ z!5-lceh>cQg}l=|90Jy;WwGiCEyA9~^6Cw$X2lAsEUFcXg4sS&Z5n~4AM?BBH!Mcy zi)KGfHx^G-NG%ZO6BMVEG-)~(?z)fJyopUrP|wEIFVVF8GEZMN;Pll--fYJG>i(+i zYUYaB`dfV+m&7}n7Fo{*mll_-$i&Dm@&V%<8PXZKd>PHjML%EVID!Vpn zg--2`H}!hldt^dR$$SRTIcwR!vZjA*?5iBBTpwJdTa>h_o&OcDR8du4m1UoJF1=;c z&rjooMTV6#BptU!GeN+Ij7u3(6+AWki=C4Lg*747hRd4!$;#9k*H+!Qe&DE`w=dm1 z)24m8wXb!eyVtO^Pxi})FYgkKWeQ9Rb}U9}5>LxY%P`AuH90k%wGXu%OOeVf%TAXR zt-Y)Z7FCyZYN&s(S=U%EEbG;a9P1pj9Wxv=FXi6Y+z3Bj-;hwkQ@$4u6<3XF+|Swsfz@vQxwhda8kIDH zKAq9`dqQVtx5-=fy<543X=d$vJ`)|S#I4nBE*{QNRiu>oHO`|(w(Pd$x2C7^WWfsG zCup+d^;PuCZR<`c1sw(3*SR{(n6%Y#E%6TXJK{QeU!q?;>uEi4A4LJU=){VIlcYsB z_+*XDXF}0hisFjaiu#q7XJ0q4z(LWK(K}#nUU6d5!r&Ra15!T5T29$FOk7sFi@A0! zc2aJanod@~7IBPD#Wcl3DF`WqsAwI;wx8$@i|Ca?a>J&SrV^$UjKup!zw#2vL}g&N zu;1vW`>sqkww!aFPv0eiu7l1II1x^@sII$nb2 z4deB6P;*dmOcVX^%}VLecxz~e#x?Y~kNW30eWr@K+;?0;j5R`;sIr5j|3W|n z()s7^&&OZHSw6J<(x&gY5>8Rk5?e~@Ywg4HA-O(G)rU*WV=>o1sCVjN`^h#{O*G=2 zbV|3t#KPp;YIqd>knlAjpK-lBwf4a4vrJ$AT>RYhT!v-$0!MkBW{cHvl5@&oxyFOW zNikdL2i0pIe&44A6d$4kE<$UjdVK+flT>^@mw@$ z(t7@IZ>L+<)AKL1?h5TrID+{CWp1Vyr3K4PkCF zrjt1Jtvk4Ukse)a$z2T~qX~999YFljPab@LiUw$i9IPMegju|O_+?frc{qCsvHwdD zj+v;tJ#;qebBDxjcSl+p;Aj;wN?%dm`#nHO74Y*tfY0Mfk>q{J&_qJDaL}Hg+?4)| z!%SxfeK`9bn*GZPFy%YaUDFdD*OHeMnbf`g>xm-VL{rLCP7c8E8ixmfpa=mluQ90C zR{)CWf8*j%bO7i-bRYl_Vh(sck^JG2e+~b7qF>*?^86h_#|8u7UcWG3U$<=F|8Rpq z+0g$JhpK-~0|=>zNJ+hhDn$B+c8B`FA1zQ;w*KqmhHTos+q(4f$W? zel)aocH*a?_^YD-eg1BziJSR9HQ6}+r(3TbWce$Fg_Zd&%m0@Bn)Ur(R6a#>Hxnx@ zQFH6pF?+2;fP4fo-{6aLL7 z(uoCp{_{*~-Mf)1qsuM-@1V!QO;h5y5piGH^Jf2sX%2AyDdH{lJobSK}D|63FP zFa`O&p#DGmz$W_Iz@*K*N9~(`diGD{e-%m#`tADPlz)vx5*V0?-iS=Qx?cS+>VLNd zywL&u-;{sGvk@8NEU43jXa6~o{~zkVM)|d71gIC1|EByi+MOn$uMK4Gk-BX-`iJ`8 zvQmJ*JN<9Uzl6yw0(uX&Bamktza*}65d;wu5^6E!Wo90CKK?OBBIwhq`}mmg z9+=_ZS!Fapyx!N^`W_DpYwK>=)>bsTy?o7N&$wmTren^;#H2~BM7<^J_Z@9{ef_+h z=N85@$!kp;!sM0qTjC3PEuP^1t%}Y6X}tf74E)hb(`5kK0v2#AT0%^$iCMQ<=M3Qt z?+RX&0s!uFeN{qBSgJ9dwRdgB#Y5E8)J@OO4=ugDqOO(O+1fRx5tdd~9KSytoxEJV z%9I%$sNG<59n=Za{X@V1KeLRP|FzeX2#!BuWIt=bIdy~XR9xVpB4v87iOK2j(aGF+{nQr^p@KwT{ zuR}-+;@f1L#1PKLVm?*af9;hM1@Pn9=^TFse6?VmL^d@1#$dW{OG)Rfp$b{Livh#9 zw}vzwibK?6Q{eu@-wWkO$ZIh_LR3O-_$nfY><^ku@L6D?32yirXGe&S1k!4-lOEb! zex)6|{yk~&$bfqp=+P*@FiDKKJ#_Mgq1ex8RvY>Q*oJff*Tl_vVS~)Nx(h{`^z*4J z=LNys2zI_&f23`958goVmruUDl!hOK4D(sU|Mp~W*rH)PHQeqs>0EIQ!(8lMfluMa za`mAqxI_pe}w;AUwESx16U0e59*^T zXhyj8>Y~oyYwpHTXkH!3a*$v|ZKPY;Mrz`mRd4w!K)Kr6;42mciC=EP;kby`yMg>Fe{%F^d?WsZ3==cT~H#`ZW{`)i5stIyX+ zx_1H|LBm; zwBXJrEFcBYs!2`tqrBF=6ZigFMWZOZ|Bgaqw@Fk>Zpa5PNOUFZ7ro(ue|^A0=wYZL zn$`V&lzC~Hy?I+m)48k9_%Q5EnfuzY+fIcU6=<;D5epsOtX{iWX}MA0cC{231Q4{n zIhnNt;X6L4RQNwov>DVgCVRCUa{gp!*qVb|X&&fc`7GYrUvPf@!WDYIRdg>bmUUxo z`LeOra-58+OW7OoG2{6WgO%x}4u5%u1fCSDzZLwS9}8=j^febtyq2vu@0km=(SQv0tZ! zxR+hCzB9@@@%{pm0S@9aE;fVNF)~Mqc=^8l8cOBWk9CzLH zqFW0ji*P+z4LAqznz=^uxs#>m%$4OXe7dH3miv31*@NxogZwhX21?c2zI=&c_}W=k z+&(^Q7q@n=mXtnq7=h@IHNdmX^5Mo`O@h#(WV9S}JIf;XIuExiN=^bu7B@L2U~5qn zhj<(s1GFWFb&8eV2A=9&RIo79?kb>@G1=_?=7iQ8$%ORh26p z01wXI;3s(hVh|H@BcVj$2{xZ)1$AG^`fU%OlFqp0Iz@6FD-!8L6RAknenOr)Crs;~ zva1~qI72VNLiCqvXw0Mlow3dfoI7`Tz><^IIfb&_q}E$kwJE-@-I>T3(6 z)UMqP+KRLkARt0=hQdzN^>8OUkK|6E7@7flg#UVpw^Nj{PwQ#evS(pIJSqT6IstZ_45*od*Z4%G*nu5J_^c!aH#WG*a zCBuN5LaUA0Cxv&Zs0N-HBi|6v7tsD} z#U-G;jKOh$>LZ!wo|&$pMg4NyMX`zuY-&`Px*uLr?EcS|>$je|-j$O;uK+jTz+gls z$SN9jNXz@pq79G7;;e53gIwTSo~9xAPqI_26yJ(-k|JpQs325v-a1gfh`9QxI>@E{ z8E!GKvW_fb~sVjc%xiC=~QjI&xufaj+W z-?QMVGuQ$8==`hh=h-LL_PmpOQ-u;4#0Us)e{xU)J?P=PF(e35ZgpCoAJr%~@hojD z8JQqwv2h}~ua}?z`?xH1pYs^pyV1U-;`vFSdD&}T9k--6x7Uundtetjm&{7s4?eDl z=j5HPbaW<{Yh8$p)9DW4jasJr&$Yn&4L*+dvV(*6=R+ywdSS7AHyTZWoM7-98QP0W#~W96*Iz7fX+;*;n7 z#usMa<|}V6=$<>^S(0Rrtz5yU(UNnd7~~;N@(-J8N7&cm`he`)hD^8wFq+~`maE{Q z$G0GkS?slO@M=!;w^kK|UUY3ytZaBfCa^#H6iW!bi9Rc>G&yTGOH43syWl@beuING z{_84-R~4*6mS4Bp>Lv+*aZE(;Pv5Df(m8oiqs>f?W8Z9^z z@ov6;EUoa4Cg&*c^}eDgky2vu%F=`yP`MK8a3+2Ux&aZ7)%Y%j{Non#hUTnV0-?Op zaQkEkI62DT*G3=bwLfq8xr0DgYk9K{L3|IPMy-iQfYBg6-Bva)l?pba1S2V&h@(&z zbhXM9j~mxs*F6E*?HH#Os=XK6_8lFxI&EQ+`#>>D#`qcCO&>n_O}dZfVl;ij%o!{ZmqUv0t)Td3jk#HA&5J zen;c9^~f8?uTtjmV>`V34~Ytck-K5(MeN%8zIoFmE6qAPNKpq({2%Fe8{U9 z9#Eq8lUsdnVm4lQ<#5XgCACLcL$7iC*!zjVvKRiufE4trseC>Doz8~|A>}tznj7Qx z*PIFE4li7~dl(v3o`DHW(dbe``?TK-gAZ8^T48R`>8Y&GqJ|L{8jo3C#JH}b-9ZL@ zw*@Vjd@w3Dj$z7f5RedEkdNg4&BE$Kp|2Gc$O5%KI2d-JP=Sow{lb|0V>c)%Az=p* z32Al0=Z0NFN5|?mnB*qykLmq|{AY_?go}+`ds!+}iJF#`D7cbud|hQgqNNoPFy}_# zUVVY{$koEnm}Nr)0!je366Y;Ld6BDz3~x-%>?MD3E9!nPAI$e;Dx#X?EEMhM6-z;2 zBb*hBoinIm`ux>4A^H_;+KI?Z zRP1K3xxyGpo-8Djm%mOKo0#8Av0qlG;hE$|O;;+rv)V2tbzz4LremakFi)t$NJ7=I zP4H>x0VkRafs(U9A+O*V-oYeNBqnCx5m-a|2Z1FOtR`hwFFYANODw2H@wR$76x&hy zArhe)Tcoi0=a@{;qY5*1OGkQ|Dlg#LKlj^xb{95LBtej@LzIBS&v+Qg5w;6aZc8`P z1d(7zDYH)jXOnl1Opzwsyi^;qG%(#T5^%~P?(bWDzr1t!)WPc`9tppG#wX=~zopE! zO*h}OV{X>n{PGP#)i;SF=$ z0y+OOblMUpgS-pVa^^&hA&C*hOnj(R4yTknZ`d(QeO zHe!b*D^l*F@|O4N2ik$NA8?rvsnb2v=&({u8}CVt-(3$Sz_!nm17nw$|I_Zf;}n#f zXz+_4xyQtJvy}ofAJbm@yU}3CAgM?Gq2MvA9%-b)%y}-f zZrqgl%&Q$~*@C2Rp|Etbq->p6s}YTnEJX?92cMm%ysziHuO>N%OUb&RVmKlw#=scL z4v$1ovz{y0rX7rER&izJ(`~fcVL+qx_Foee=7|KGSh=q@@$8uWoTg@u4(j?9-`SFJOyn* zfG(<0dyi8Lo4Y!)dh*oHv0_~m7W$$en7X}ycp8tlR*`gEo zP2@{;spO}xk#vo#&ll^f<$V_Q5(6gqmL_Xbjd|AuCms>0TMvVi)hVh9Sqls*^1(m} zgEFc+IIec9ftxg!hQ%iWTnO2Z1}RyONH*M*-Q-s^_94lstbiP^>6``u80@VB{a${KO%?*KtrvcbtIevHLW$W!q2V?T(`)#m{2Fs^642$IqOD5Gf?TBnc znOOLEWxiD@=!=Kb7r~9^uD(OS{o$X-2M;f$k|%Q2L&fE{i%sPcF9^z4$4<+*^oJcr zpZP6Y&|14ATF)sxNVz4gD&scd<0=fAhLm1D1)p38n-aPD0WWo}!d)f)x zel9Jbb6#%SBwI$R=vX8<97bJW2Z@=t9WJBb4Q>{x=0D7QD7Kn}9l4oNjb`$4vP!>} z|IvPju^@);bSgLw|Mka#h)opR^E+drCh-r?Z8 z!J9*|4~BvEk)HbTnebM8Y4&}FW#VBuZys&;!9e?7co6@y77M+kM^uZv+l_sT`um-m z3hiItWn8p{3qpQ_jxJA3qEa3Ln@oFdQ1Rb(j%D&Mk0rDATpumXSTEO)d2bP|zs-l_ z8CF26Y`R|mK^2dMUs1;6fMTO}IJGKZ^x0j7Bv#)Rles9mG#%z1O_toG9FJz?s$Zax z{Nc6JI7$E*B4-duse{wt4izoE%{i+B_Wa}qsfKxaC@si!q7RTiBs$KXJhS!2{wnWoF5iE-^Bl{i&- zRfCLRNhuM7emWfXvqg~`myE#Ypw4(#UkQ0NUlSzhosDCxu4;83)%fc7j@Z9wo1Q4> zxJDmSnk7%U9fCL72mI{SL)=9pfBLAaPVzgCkYw``{A9?}S$uqOw7B4z2(V4(tA=6? zi)Iv4=Ca}*U{*Q3{l%?^D$Ffm+CwbwElvXVfAA|=+iX5eV45Yx5YQR1koDYVY>C|u zpMO(1ilIqO9~Z|MP;eTQHmW6x(n%Z(^HB^G3ZBJ|=6tN>z+t4!+kc!?LH(FX+|gqp z{&@wPfMz`eIflE4fXhO_E&vR_C@j2@YFS>zBqj;J;=1l_GxbfZTMo78KPL7S2pWKg zn%n-uWFnR#b?c**vUcLp-(fM){Q+Z*-eY_(s-p`iO||(r|K9S#oe<8nBxyWa>$Eo5 zw=WHMxhByd8rj238jbtt2imWu)La}3J$r4v-(@jBCCA_W2q!pbx&CF<*yOq>=; z3Fn1DSd#|>^r6BlT%lJcOI--AzEguR@S)MK=o`ddTsY?x$2Q@Zj74qP5Xoo6r8J&_ zc`Y=+3*&048l0ww4ki}_#u5sX>kBdFiR1w14VRXBVuu}(^ASNaA$dXCFSBTM%~KXg zUlj;+hLRP2IEr1A*G%l zw#BAQSKBm+tebjF=@8hopXDO8AA8YONfTVy3OBw0!OYaU`A~wK?;=_Ho67ccy*S>6 zuh0=daNe2>V~0G6dbetRyT{5I9KIZ&`*s4ry8ZE?GwFex`HN2GA1joZ`@~-t*YmSmb`ZcoixZ> z7Nk+>G&-j`H(=^6?72wO!*d)34W>ItzK}%+UWLMB;453aV6k7UR2~X!SBpx!dx3;JoO0)I8vb{iik)~Qp@*SczWj$l!oM(i;L$E2e2 zU3MV2(APL*kvp<5eXS#;_Y2gBfT@2vDznh|8{L`wf~KTKq*aO3qD%Xu}K-J<4RY~FNU zkpj(vjpzdoUWKZF-+UMXybg`xZP!Kzh8c%0UmCSuW~1b~AmYF#@DnIf9b1c%nz*O+ zoLjn@&b$QZo62{h-yyk#K7>{0TVEc-Z5k;PEz)e#MYa?Ayp}$o!^_}JvufNsEkCC> z9r8^Yf1{F$(Gg0^QIY{uvS5%&%+$2Ngl-;<`G*(s3jM`{Qxv^3nZO z#(2p7k?26v8Y&TqCC;09g%6N+?HlLEZo#FRXi|0p3WpH7E%{;sQD&|ARI#3hSwH*$= zF0s|sZCBrA=Qt83b*!IrXx<~UK1EkQRXtcQcB4`~HaZjY5r=)vyYBoLPg%(dByUih zh51dOsU-94(%mMKb{O;0hCe>V304{-K)pwZC>7F3{s~?E?nAyaXgnIFSb0;8Y{l}X zS#cN{9ygWqHqE7QWS-GcvHF^G>6~zB8S`+#>C=Qb-duW}*?9l@C3OO_Y|S%}3QKV} zC02n-9o0J8wSGQ1&2z??zP&vS z!K02%?7-`Y`){m>6+8(RhPbea`%`~!*rceE3oifR@o=SRChtOU4Pf*3xI7ckJ;lQQ zokN;SK*s67ajz07;3pKNXhmIrq!~xJQ5^I|)~9c6tl)&O+>AeuL+)C$I>=oKyuxk<@Cx)|u_lQbKCnHRV>8u>Nz7B`>FrKw>M zSbg;>q(FH8ds=Luw`b;ekZQ*6=oC5VgshVAmgl z3h2PorU_}N+kJtCP)J3YvLM(h@;8pU{a^xdhv?q=*=&^6QV*0y`%^CiG*RYrn8|F_ z7HHAP_K`&w-L0})*2oFRh8voWT9}Es*(LUDAwTfZ9lux}NZ(>EqPjYawHM(#=VTmH9 zb3}XL7~+_ff!WCW-1l7f`UHuCLe7AF$jlJty|o(ky8y=_G-Pf`sCXdV^&P+T_s_46 zQU%x`!2MrnUiJ+7U(h;4TT#(&w}t`*+fyO%TRR)RH|+{tZc%x=44KN)O9>k=mW;u3 zMA>&1M*Vx!3bXU?{2S6C3Y3WG)EW%*4`l-LVPE|t^X)U|7|T7U%3_3Ui+GPN5_Czu zM`+*Ni2Rfc4ls3vqnZ(Hl&gNvONGxhjPk(-3TzigWWUwX;g8-qIE7EIPbFp>QId00 zv`kl!p4$0AY8(HHiJGc{1Qs+&mh&Rfs^M1l!aS@X^^p&I0~O1;I3C|N02;QBavoE7V3AMh@lsp}P^IA|W! zdWE3i@l*+jcAtdFx$)^^3sMK{U;SRj4`PTv7m7_Qr4XU2aXBQJ6m^YL2^oYzntMJ3 z9+J4~R7K2hl;0c(H(VxkXq`gc6plyxAaTIu>16ATf4c5krJzt}bkjHZ9#pQxupVvn zR@zZQg%TTKv`k9&csGz&;z9wpP_cLFCh4W%vIrTnIKyGtctGupH9rDHTQ5G&fGSnh zt}yVKd)%6e9^yhR?wo9I{~=2Y1c+qz2HC0p-u>e$XXXO&$;0P0$u248Z8=*Mv=9k* z#v52L7b5$HvyJpryqH;XH0)iwE5nDPM`s*T3TH2zm8hEDgb%$~a}oo4-xkFYyxyc` zPu=-V?goCQr_c69TiWN~e49r=!gxD7f=j8*vQ{}LY4(MU68^^xI?&x{c3aVfO7G$- zf+Eoz+fu05$~}@(u2rb+N<>};p6PjP00(f&`R?-@9x3?vF!aXLbOe7YPQrdY8|5gX zP_$uU`1ygAXM!Ylw{U7&#X;v7!&fgkt;{pCyX1G?#NQ^L{r%AK9hc2SnT?C%ZF1oK zPgCT^ljMkV+=b~S%uQkr9?|eh{3`<7C8L$NpF)=Shba)%5)Haqm&}&9V_;G!V5{L2 zxTu9nrJu<$KY?TgGYxe^jQ>)@WAH(2#rs_2FA1@@1~{cm829T!xr0RTk9Hy-38-WW zw6w?=gj2D$9(?AVpVPNSaB-?gQY!*~@#LZf~EI?M4P{pFShR$F5L zKW>cusD&}Cznt3+CKM;e@;e2j510{Dqqc{YrI7QQf~$uz7q zLxzlv0+#l3gyY87$@9i~bw-&`P$#_*CqT$A?&m+I216KvCOe`?)a5x~W^(c^VKt)y z`G$r1u)OlCK#H^a-Trjl7y4t(YBYy599YF}64i)j7tZi}r3}(!M29&h^$Bsxy-f|A z-W-qt(!rFa3DUF}!*=qUa5-5#-fYx+iw%u$duJym3ZZBE#`OyUf*D^fmA)s^Ja%66 zEHd>=6%$4TMOdl3ytAB)&rX+RXcSKPtn^bc2i8BH{Ho)Cq=1Ri(}o&a`Q$S-bdK=G zoWAd9ynB6odAYkD0#pKWo&|LVW&%v9-&IlvW=R!QIJ&>xkfMmL`sLE^l?v78XanQl z2*QBnl1EQUu%Gb8quyTPOVolh02gtTd5HwfUf!ml44^;XTrxy180DvNc;NLD#~)7Jmp zbJ92gwIEnWEc8+Y@tj{$S!8{YYPF_(M%SB^POvjev%)mIG!f!x*gs80H2z(n=t4Y_ z*t~;`$F7tAemk!G+qdpe|1bL;yn?u|W@cmhF90OtZ5GV2Dm*&Vv|2;O_MPONb%p^< zD(D~@<_aVGIg^H~MX%>$v@ito-9fjOpleS}M?DkEl6Qc(mgEx>F#;tC_6p2tO}tVi zE`L6JG;sD>iDkkv_bVRTRqR+rV=f}L0y8Vsg!l`s%#?OrC?&Oag&LP{$gA<7o@qpd z3#E?LOloRKy*9vaVEUcQIQLZ9i!OJeD0G!bDTXeqLTc=sBTP;Odfg7hiR*v}uHCq$ zgCLQ~kC#I5vWdcg+z$N`+({~gC9ilkG^T6rhj|6f+YQVZMvg@!9N=#JFH(9WNEIY7 zM;!smyK!yX&oe=ZPp5Sz9W_-Xvh8Vx#&(5KY7@0AwX=Epf(E&zygND{ zE{4iw~;HE&;~Sv@VL$;K93@?)o=LEU79Z+##%+L9sECl9H7k;*x;$%<5`3Mv}K? z3Eoftu^yP9S6At$QIOT^Uv+F^^X{(vgmM~o?$-xRNhTc|I}#~chxnFjeoVC2#iors zWA+M_M>cNi%X73+*F+%`$0qm@cB{dv)|U|r%lURt=>r_h@5vHj6}1vDZJ~8PR{PUam2V(m?#R{6}?VU;f#H8H|WLjiv=~33Ina zf5xW>49xRd{wAmu!Mg;T$ndR7;bgM7@Cu#W%~&dL<)cRGXberz=0yN#1|2F9YUC%n8!kBf`qqX)2h>Mj;eb;j$eWweM$9<3Vc>&>3}CYt|L)((2i8^Tu=<(E2<7}P0K zfd1k4=t~N^M}3Uf*2^UqNSssiiF>4e#x#V zYBwteB2(Dx%W#8KUk;7p!Aqr>JT$?>M{cj)U6MVMKEd__)S^A8>mshbXh7n9Hb&mA z&gFrF}gW@x%{|K#H0cC+*0Zhs_+W#mw{(1$E- zln9^mFZzu;BS|fqoH-YN`#u|!{{Z%v#1saz+JemHP3pBV5xGqyAP&U0&BG!Fxz&sx zIyyb>R1XPKD1@DVFALaC$V*R1yO!6R_$W1D81IHw?xl=M3vd*Fb~*uT%Qtm?bZ#kh zXWn)YUuQM#nVB63-f`Y<>KO)DUBQGZDaxFZRgYff5OD4B7g#{XLLxo}8bI13<;ass zUh$mcClQNJn)w9*#tr*%fyP-(?{18JB zkz;f#_i|d$d^OB{g{c#b9YHWk=H9S>TkX%Wdn#o z9C?j*n4EhZyzt5Sh_*zJ+@G|{*eW40y746JvSVi!R2@Cpq^eKv`Xe^d^S6~9;YQBX zhJGDY+w@4zXbq$76$Hdq1Oa>5A~Kzdoq!LNpv3Q0 z7}6l1aq{)03_Pd=xl+I>r};SPSkDqui0W?XKweh;Q_cLRf+XQ;JHwrjdIbM$W57VH z8kwCm-TET68OmNHDSA^Z>@FQvcRF#*C4`*{9;zCK2}_cnULIx~N`_6mST9Qt8MfKUJ_9m{>{3;@Fm8aGlr*p6h#!M6@IeXvK$-exI1be2#3Zc>}LX}@3BwK zqJ0#!_gOIi)qQ1W1Md`%&Lb}_$lR5`i^5Hj_QAyiAzG+l|2uLF26WMiqDxGl07bQ* za{E_--0RVfArq}I%|IB>2ph*9p;jYg!%s1RXZD`W3d zpHPDqinG#e)hx?`0*+Efi2w|L9^sbzn0++fSA=CD#bLGpj?U%tgFr-v25q}B3usU? z2VQT8K~H^5M1iOsWsu*=XUnTJkC3G|z^NqPn~ybf(S6@yRwWk&l9O%f_ z`9?|P!m3Ab&M4ZSD_n|KkG{C*#wAVrsZr85c$F~|Ui!4Q8k)ej`g~dSLxXy?w=^uF zsA+a>n%!-ZmAocj3|qI|4%uJ?vD8yof;qbRLQHjFzc0PAzpDA#C*-EB{0{suVZr>( zg{PXOccGZoPtnh%*pL)524u@{rbp@NKq_h11elw7d;VERKa>DyVAgpKxu{gNJR{jr zQiKGxAtPOwo59+rvqdVy5JzfB0%gjJB2DSwjMR79)ygLHsXCM(&AGi`A{)CJ(=oQs zox5Xct9ybk?hQr*sFx9~!V?>}f`36~@_!&RfW=?ewa3G!s5~ca501-Q*kG?e+!QLK z*uTZZpR!>y#ka!WZ~KrMIR`a}IEiEs%{Fb`2AjrOqUi12#D-&>9}{49CH}2Jsed14 z?pp=sr9d|^a)1=!7BT%YB_&>2FkfyN0_k{9y~fMOC#2}M98$@_U&Z9?(TPT*(>OXe z*h2pH%veH7?UotHI;8~80g6cd?&Ot+N)IK$RnuJs_4)< z*_*cMUBeH%GMB_ zxv*hWMn#Ppp}8o`^es1R*{0P*Bw++0ZX-qlbaxRyemyxDtU6WlZIltZDfFsBVgYqz zNoCXhXn4F?T&a{c+2;w%TH=WVHclK>@2wj#U#_K3k=XDe6*)c5DRWO`N)!G(bJRcG zqL=(2i{DKu=>#E(p++&(?;rH+Yv#wsYuC_tf(!=2VOPlV&<=TRleVD4qG`J+B|s>s z)NL?d(W9Z`DCZCu8P9HE>A9jIKgk0Tf*|VZiBh;`reEjjYDx{wazJ&uGevTy)DleK#jVVR4_D*uveVoqQ@nnjyd0=0D418C_4 z0a2i3$zE4%*HB{LZsGun$;35C+}mTV;D*?0WI`Aj3wyXo+rYQBT6N?JS1PBjb9)z* z^gbl6mWqjyd=fs|OppO;xCNiR1VO3Lre4GOvQ*h`tN_`cyd_D}Uv#b%izn8uGZ7QJ zF!Zfn$pyC;yg+UW=}i_X!ZPlYnoE^Vhl-2aimC;{0dF9gFu8Z5Tgxi@N6Qwjj4W1_ z0&cAmL{uk~;@uf)}kMF$obc&uZey zh4_1U*?dxeE1QN127IH`TP!F^5-FHP<%${;MR}ZEm@IPb7^9@d7^U2Czk&t2s)o3b z9)Cd#hzjvlr|t_%a5;E4(2pp%w6tV%ceW|sJEP!73RHN19>n^7q6eWP_g=XG(M3goOP zj_y;sjpgzTD8w;!lfq-y?FsFMWFYA4T{$&cnp2EN%j-?1W+CAX{ow5@d11`9)hlT*0SA@#gl;Ecs%1UU9fl|$Vm1(72dzbmVrl03o#yXh3tr* z3Q3-zzs~Ja*+ee0<{821Y$7^$)^++#?ALL{!mW^1zM%*CeX!ktFC!5aI?$5zJ`w|5 zif=IT&OBvM6oY;siaQ0k_3D^UUqH3QuzAOtYNGzSw9nvM;ok}AuT@uobbhmVebV|2$3Q`hFi*&g( z@9Oh=Km4}~?AdefGc)(h^}UW0M)(e-5crF((;K5_WkJjmm5%Qu{1lBj#DN;|=}ZbLxP1Hy}ao!k9e{Q_ATp1 zfrZpF3%v9a7)Qb4d4Yt%8Ae>f0f+`we(tJokZ7$klHz)^j6_C8^nOnRKjc1cE*NfE z4IjW3g2ipundn}`H`^VMRoUjpTgc6ui}zgN9!&k_`S9hZ@j0xv9Y^F6b%a>$7Yc`V zm1L`gqO${E5+ZAXoH5PMqn*B5r-xC&GfWGZR&bCQ$8Og~BjB?Z*+=GsK;{r-U-waR z3=Ni5o^8_HpF<_}C>c`fJWlPeKmbx$luDDzDYy1s0+;yCUGoKl?ju8|n9$H(La$J- zJjItt)51hx0$({5Ns7Hh2|_7^E-?eZykF$SE&?%=krvm6zM0_{N95qDh#sLH5Wjap z7YW8mVVq&_mlmP5up@SI4nV-}z3Gn?ENU~^VMeUFnp^Rp6dvmF{tGe$T?WCylqr-b zwkZvD^_i`lx#vg(aRT|U^vu^WjP_!&Q6z_U7M*l*Z~nXtL8^>PG?jA9V3idHH+6h| zAPv!CPa|#Vk<~-Y#K1{N)+-xTNeb3l^49exBhe=6z3tD_94&9bQmHn zdPySnKoDbOGSi-+OwRZ6;N?)tIrl4ryM(I7Atjp9BdRxU>>n0vZqzsRm*w7f$$aD> zKS^(wb8X0+Rx@YNMh*-TGi;hfcQS!;&O0~}soP$m7V5nRFhrCfRm`Dh2`A=ILFwP9 z{y~va(L-7bbYKz}B=|wi%?i~>+K;Fk@2xJAB2Xjy=VI7F;1jwUUyAa9D&L%KrR43HKtELPDmP zG;?>NciN)fGoWF+$}pM#W6jt^*r<_K>teI-X&>8f?9hiEFXe2OrrS-rqjhWD@=KQA zTDPm{i)!!PAZw;uRI9KQoj;3S3S8=z62yb^Fux71oesTrjYnH`LpRHQ!lwD?e;o&1*lh6?IH2>xi>t$KOeoBr5_d|99)6b45{ zJSK-PyL0AhT$2VlfwF(jF@|l#vRsG8V2ZU2JroZLnv$?}v+azL0I2z(8q0l)!2I)H z`pOeDh5C2SkLz1aVK{>z8OUwI2%azZlQNQ>qoB1{xeii>gkVTHg_YbUkxA9DRu+o0 zYe>9rpPI{FgW$d-E4t%v7+y)w&zeS+j)lye%4v;bJz^dQdS~T&gH@5r6Ns`yD7~N)9(p1o@BEBAo*N0EjkLJ?Si!Te2q3QPo7Yra z0=egMOuF=SYEu)9K46#)xo$Keu@SKr8BGf6k&qUAi(SlXUKo}agQB~rSXwI*!m483 zG;qJb0+X$)#mzkDo8VQm{FVCS>s~aG?b)utBv-9qS{_|jIy$HzztaY4Oqyg=>7nqB{M zhNO8`LS9lX_j#L?yaG{f()qp5Z4ApyBKMcg?UM=1r?Y;!pCOc$an(iL{)^v-t17m% zC~n&#t{i_0T@~N$Kd30gYA$!`HXdd_cRDV0?uqxjyBvPHqqzKDa9elSC;28 zkB=U}^=~LS!}(X)%-Olp?D4lw{$uA?)(iRiv`oC7nuvB}=M%%aXks_r-Ir^1XA_rF zlUJk+bpHtIPyOOFSYH_T$_jk_xnkkWak6NmUUh1gnsa6KC>I!(V=0B$OdXs^JE^Kw zIn0ks$z!+j^m{|)quBAI7zd6?ydvXAHVqmI1w?}}S_6?qy`JS+!TG0;@^bq$!f`<@ z?yQ91uPuKtV3)Q3VGUbyP+tg;@cCVfsN~40+co7FsmQRlviPWFu>fuJh*#Qt2?Zvz zK=8&#r18mgGmpF9GoSNJjK%aRK&SoQhX61*O{7X&Z{?<=$HXFFw*8Z19vIb|5~&4t zRd$~DKO(mGlia@{yBD0TS z4@vr$u!vHlnT&+~%<{xhHccPVk_K$AZr(Ei5(eo&``Z(pMgIO|sl)UIp zlxB-(I)ZdD`|`U8U#-5qsZqorti2myPtA#MZqD`SE@b`GaA2`8z4#cOj%k#2{!P&K zlwdvnr3=CEhn$ugLZc#)`xcK?f3g22%Gi|7g1EpXskct$C++gz@L%RpXOYrycpc>=T<~0!t*%k3ZPDCzf=g?LmtXHX$9(3_XD40PY^|+{d`fqRm z#r`GzPwEaOfG^`2)a`?-H)B*(G<~o84{Y=0zWT5z&G@+edLL`0Eo9=b$8AZZDx}Uv zQ9Kl3BZ8u59LW8e4>Z*N>iQ}?`m3IH@$*&3ZnE2t-{3>uxW(OUG6x2#4=V__SpP)Y z|4I{R13icbMVo+822e{sn%>pOCGqKOsoRyRcfj?l#}}rYI)7B=xuUChHrbvGNq0nIL>MMkoEfuTf`~zes3mWbLyz*q%UY+G{lf| zs}+hPK*w`3+aNKfTDMG8Rqgn&~_b<_WBNp4cs|wEM@@nX5$tkH8*)@E^`rmu4 ztp9z~<*p();d3~;dUt;Vjyw|Tj>FvPLhHW$Ip*|Q5GaJ#3x^3iu3)lM%}R(bAp76H zJp*^z{Kc|WLe`C!{zV8lg^Td-6eoKw;{X$N?^tDMNuE6Z_ffxS|GuZtdpGy5%J|FC z{;e}!n`Vl@FGv2}oBzEGA6Mi5{Y^B+C$|6n=^41`uZ*h+w><7>4>c$*e;4+j;_@$z z3rEUPgBpjYDE>LQg5CZ87*k7?=n7`z7dTvH zJTp4|E4Ca{x{0>Ess+O0_`ub1J#L%(IOz>~Mey(YaBu$I3tR*9xHyK|8PhVvCYaiK zL(bCwN6iQEVYd>Y29=r*8_sby(h>mV+>f`~Wu=>aheUa{V!uZT%xdW4@8hfohYj>$ zAk#NrQ;NOPXTd>bXl7iPde@{l%eiPRkRv3JfB~HnT$VHowmJBMAK7jj_bLo(FrY}0 z)&Kuq0P_UC9#f(CKDYnHLfi$=$3o>lULHAyowb#_oa zT0zEh$y@IXm18Pj>+jo=lCaIhqxWu`7rx7@a!V&7b;y8}>yTHt?rO;$5%qzxt-2&e z#JeFkc}s4pBjNJE{Xr|IE%r5>Z9`4N?30d#9}E2L$caSQMgF*Qd+f*Xlx-LVUp)D^ zme*!fAh0cIW?YWRK*tzli19^`#vofCe;=yNyeLs75$9#PcN#D}#%I?UYM4#(D+Kk1 zc1T8utery%LG?OTWv}?xjO$AOgnF{G6}i3eokUBpU=+Pl!N$fB8?6jc6y4h^lFyso zjl=u3r~fJiai|$J2+V3;RJ8Uh*pQ!={bvb1ed{~A_m0<7k2Pmds>b?R?{dte<$+0Z zZuu7ag|2SDTAzI;pG>>-+V_*ABCdErQh-pCtg}kNJZceju_Bmdg!2^Y#S}t&9Px?cU-SU zVh8Q~7uaTq|D8znE+Q}j`irm@1G7%DIDxg@4?1rQ_A#R!YIU5W>uGkB)l{8rMk8f0 zQ^;!wNR53IQ2ao*k1pK1#osy#8wP5cz6`yrcB=CUL#MPGurj~D<~kzzgg-SXVcPih zs!m8<j#1@i=z&@!M2@H&le9;3Km7#$;^`)Dh^%ml5f2lBZJ7-k_-bjwT#^7 zPr4*Gu=s}d{yRu#PD*D^Y+%B0WPSa~9!pq-c?oQ}6#}riy~B$IZK!j%qeC;^1G>H!LFUbR7o+ z_i#x?PD-fm=Hjpe3o~znMc;};jp~p_4as7b(V|%jqY-(sr;YhJO?IgH~qLN;Kxz_lPLgs7}SMJgg@NULQIv9 zMJ4xS^M{t-<4PR%E6M%jTl3GgIK=m1vj=f6PVbdBu;XGMayeeLaL0~*Jp0$&Q~ED{ z;Su8Dx%KM_eN=2%ZaZLdT$us#cY4&s^nUni>QQgdQSt)4TT{KZQFx_4}lfDK+9BKk{hdpvT69GqXu%nDJPsa zyh&PR-nbYYkU@J}rJZzF&2%{K}ZzjCH!HLcG|vnk=>e4>+xE*sU30 z1bZhJ-zuN|2~@}Lz3Z=v3<{Zg{O^zKPAF=t8dy({I1$&5G!WN%jYRNnhB~Y)qWvER z$7`@jXURs)*gc;vv4mzBeP$Z|h`7k2(l4_@=Qug3dr&>qKz`orE{$EsM2du9%?^RL zc4cc~0==qzwF!qY)e8FpbFGpca=ig_#hZ?SDcCO-?A=LWX}XrVmvtYew%dnGw}Z?+ z$Qz~IUmd%~#N_q3G!Fb(;EjS)7EO>6O@=H?S0 zW1cXFf2?p)X)_A$$Gxl?l+KkecDPu>YzVKVzBsb}r&8 zrJ;D%n;%?pos!qj`k3R%;|tM{2vH<_^iM}I=<<{u(L5Z9Ldd1lTQWXE!m2Hoctv<# z$~PUaOv6$uO;%TYVrLTS1MHCbgvIWuhzB+9XRhC@)jg2G&bD|R&r9Fc{8CTlJdHsp z%Bh-=eqKFkar&qq)$#s9{;Qg8u$6Io5#=^|ixo8}_#PQ!$n9dC81ZL@zsQ=_zVyzeECJ@yq3}ifEWz2+<2pt_FWnbGJB_`zFQu?;X8jNBs1krZ^u4pn0h5q$U39 z?Hqp6Vz7e4(smvG6CA3#ad6aqA)qJ_4`oAhl00T%! zL*;z>V_W70Tm%P5`&sR z9oIs>FFh>L=?<(0P>EpyCTqo?Y%QGf6JgtrVc`dm??FM`$zqoKa4KhPzWj~~^v zpU}t`;rJTPb!w*-R;P1A_Cch0%kwZr!*QjqyQc82{QkC6CzWj3^bwPY#=HSX?A?nk zN~!zBU%5(cvhPCZG^qDO%-jS!oNf+M5bri3q#`(h!bgelYD$if=#2PN#774kMqmC z=dThw9UG3Y{R$m@#mM+8wDIFn$_Nw%HsPJ8d=}c$R0`3M1 zhr`B(9DWAO6vI-AP4g(5?=7ubIg@7gE!|w#=w|l?4fWpa!#fB|Rqc=O4PZ;$*;YI) zmT^0WdeoSn{*6?J!@1&=WO#{nrl$ypp8`b+2r<0^l3w6i><=km3=16Yyl{TXK^Z$X z{$vX?_ydA^XQabbh$&YR*6R9!7jc{#!F|nRsTyUh&Igu1HY&*gTkkLOeaAat(+8VR z4bGo@ytY+oBF3xZN6QYsp3+V#=@?Hu1(3UAU}&2~ zVg$I)sd~H}6t`B=Ao%mclOF42`#W!XOtgh`^#h(F@avJ#uiRvuf;fMqC6l`EelfqZ z4r|nzP@mBF?h^J|>p)dwF;H+l+FpM2Lo)f^{Ujrs-uCQk`wzs zb>AViu787Om=GcVnQ(y_iA*)Dfj;xfk*-Qb>r|3EWCho5pKyCj;ONZ^1lwgtz>6bk z;u!ZbMvyc4_Z?lg^pHeGnh4jRb4up{=Wx;^;$I zi6ps@dCo(Y3CND_SysS6ApVa{<>`uOs9T|=M7~uV(t%9gMLfIt4%Ok> z4<-|APQ!7tPo0*fwCxY%HnN&2+6%2AV{e<%O6u<+Mr4C{+|yJ>Y}2)KE3)F#!cY^a z^%3(c{<4^RxTq%vdN9~Lgkh`-IW zjlFz;<+!do^X@d7XfDc34spNS2sS5VIeWSc-mQ_;vpteY;kp1#@v9P9KA#a&GLOXJ zqKkESR|c<15rE~)NLJSSG{L?X=x7KvvC{}}K@-cc{w>m^zcp{D)+>&urg!TPlhigh4m7vc11=e`umdshb&h*T*bo@~9Hqy!Tta z%T3WHPh`h8!TbzBmAKv9f4XWCQrFw9Az$8j{24nJOBAGD?gT+#52n`G&>E8-cYD~- z`W`H1wm9Q{(_ZIg|B9u~nUbYr9U}RL*4gVjyqnkd&q-qIrVbn%S z=-5q3*t%Wjc?J~$96KPm>GNpz23xx)v z(*$(x2~BmNxc19|2|-ln1H*^lI4UUm0=}#akaM`nDb}E*J|9OQ zf1@pYgw0KHMG6eki?a4uYb|gLB@@ifrR7Zp;*y~>h+k?s_BL~LTPUkSfVB}2b>e=} zL`wT|smw$`ACPAvDTZ7R~HFzN15 z)w)*k#H<7N^)IdJR7z-_EIJ z>k=8MbG2|~D(9RWnTa@4EyHg**dzfIR#itk)%{UF$kfTJR_b*`hm00kXeO}-Lv9!L z>>pU#VG7=-`V|0b)S$-;(z=Y#)O_^ggkHlxa4i~HEE>PI?*BM6DQ`GS0KY+oHSe`6 zxdl|o_Zl_?1c4)|m)AB%(q7H3ZY9rD0(>S0}YAT?80r-ZCYBGp3 zR?U-13a3~*s%QJ^?gp&A!F}iOF4;HC1y*>1^=-gnjdTZ>g=9v`G3@<`Ir2ekE)L@XR2JAgP2P@jaUion!Kj-)XCDXQk$u ziUT!fKZUXG3Awj>b^W);l&*{d%MjOLj26?>(fow2l1*~-TYb*yfOk#b)B5|$vB~`P zqY!~kZ$b7|w&EsBYIHAHDWt_8?)Qyx3!HU>KExc>ycTXi(TPkQPB5JZbNE;?!tI__ z(zYTO7qZNyL@471;Tz+{Gp=EGQ^Ecpn{i9ENTM|Pd#MAy<-_CyILMfX??9GsuJcY+$$}HEG*2%4w!6cJu z!3gK0Pg@p4Yy#rUTEj1k5K5wkxs=q!jQ#4>@*yQ5hXYzX?5Z>l4PxeCAK*<$cx6h# zYcp6BZeT7n3#-%QM$@~GEXlN2uS?}RWkSK$tdK0l5tAW;^0ArC2TFRB>nT$sD5qq# z#^IkKh<86;c_kuf>pDV2Y3@uZ7VtbrA1zaGR`Jua4SS4db7}quzurPsL50SSOuJvt z2Qzg!bvp&VsQUZ=^&K()5|_e1&1IHKi;G*Us#t%VqgYtm?GLT|M4}9}uK0WXeC7xX~>|3Es@#tx|OK6_|Ik)?KtckycbtI^J;9txYw)pn-%$q*y zP{3)?P>~?Dxol2C8GwKn5#fP(`9`d(RdW}cPMaoPC9Ji~5aT;6N0Te&XzmTypV)n6 zuz2o7>hUeK`HeC@f<#d4Yt|Bzm_4`RG`~*Q-$Y78os`-Buzs%P0pY9=c(UO`Hjpja z2jartQXbGg>x!;K>@r!8W~ssGdl|H^G8AU-SV~r`mo$RA z0gtwn-=FWX)K)I<-{~u2-oKbtQr~z3I&*t}u2GrT_tm~9*hia@F_G=I8hllTe^XYT z9kYWF+AFu=ooZ(Aeg=wI%JZ1s%&?G9*sRy6p?`Xr8Kf>Rj_r|% zEypuaoktp2MKv)whc{iF%=ME|qxdMGg8VY;78x1grJ|ke7=Jk#?l-bgY&@~M*?W7qW?r8&R+i%X&L)1 zV1!^M`M{kWi}d7Vb3L^6ZDTuwl;4lcEG%nqneRLI=7v%iBT4PH=0`8~B#8LXQ)b3i z534Sfm01|?Fq1ZYy5pbsNe{F3C`@;c>{ZSI0ea)qOf&abNH893W(~^w=-XO-@rc1h zacrv~@1{u~%yzl7hPRuT$(iAy0EzS3J$8a|Lu);kG#$w&*_YI@FVgMT9o)kyQhXh< zgSE(F^2!Ief@t+ziXETt2!i2YVES8(4ev9g%4XV|!SnpM4~s!kaQ)7ZDmK!5*}!1H z4x7$OSG88lcDnxDXKw{tqGe~wUs^LNyaDnodhek&#J&rkFc&3TUSz34boBD`Da@4|$Qzf{X#0e$RCy|d?H{prSZA{%lr@wj0}re!dL&$^pDy=^=`r3P zzt8T@I$+E1&DxU-NS;p!Q)8r|#0IZ?AhQPC)Zvi_q`4q69NE5ShwDG7F7mlZ%keO+ zMMoi=`z9e#h!Y0>d5mr1zp*r~as`vCkW=5INJ$2ot5dEPau%HRD%?lcbZ9RpbB!wK zN!<(>E;?gTSD<~+yeOcoa&v^o#eE<3leSJSpAW~U=J5<=z-IWL_ zcg=eoz%5U1#Sz^O3kFal z-tQu<@_6|nC3EUYR)R6;UMTgP;jl-d!GTEW)nU zX|}_~bF7czL^pYYV#2-%U$nRHk!&z{(bR!p5o{3W8&`UQm)_ zGMdLL0wkeR2SpB5S5lH%;!ORLsrn5u?6k;{sUx+TfvF^{<9r*{r(-`Z*z|FL322PG z>+JaA5~}SHRBU>;J1lz}>iWxXP}2h1K4c~$UoqeO-qR@qmmKx3}PEX-X)WudGTG*vz!PhhFa|_BBm! z@qprUIB@H85szy9Z{xRoKtV%s@B|)JfDvf;@zbV=PZw4Mgjk!kU1Q&k7uU zO^U#^>kI)>sQ>YUyNViugX*|Bl3sJcESP#Nvl>L*w&mUjec1EfzTY>GZ zCwi$#t%?DGDfHh@s0$aD$knZ7J$ZxyPaebod{d@)zyS!)%aH#mX+b(X|4>@jlxQ;yhk9=|_n1dqZ>c;@_dT`6wMoZbro>U>+T6EWQydrmhACrk5QPyyDs zber#a@TL1?%N}(2PSp2$M(suZh$`hgx9wdwl-!VAwH7?EzlEsdgs7u1(ocyj0KC3Y;LxH5v&{w2|pA%8B>u^c|`SK!ucqVoU|FJ-r`@5+@^I zDE>4gfLpf3F+tvIXx!cU3%KAJC6y!L7-hiu5KI-g5*&(%8bQHS(4Qe62SxGS31eAf zOjWK^K3mj>0BH^Ps+TN&oKa(_~T zoH@4Ui=7s#^c+{3Y-$3YpWu;k>1$oxj0kMimHwS{3%J0!lr0HDghW+m8h$^DTdR9X zWs73NbydVbpx3K7kbRys_IQ4~yYLo*d`mMnLqlWmYIw`(%V?Q~Ms~v-&uNG2iZ$mW zZuR9k1%8z%a~V?jr=v$6-sQd^FY${(728nhHOe5S@1hMa0^ShZ${_iSEQrBc?5c8O z(MLQ|wE{WQyP7cX<>}#=J?BRH(?iS;`Xq^`)*YXbonN`p+1Lj!Rq=uZzW~7q#eNoi z)(^OFms&?Mq}R7S##7@F>&G-8>($GOJ#wG`9XqPr82(6pxE@-A@K;pa1^_fl1B>5Z zu28}CoBJo3lW?_8U;R%2b7_*-nymrqL42C(OLyT~z`*k|IRsdAfu(UaCZE4t3o3GS z^8@zF$OF^f{h}A%Z9Z>t$Git1Yy#+R?MBV!@nlu`v)IJ+Ck(6hS9g64i999VJtLUy zZ{?UlF%YN^^>9f0L=H94FI@2uMKUt!oCzvoGUN*kY~VZ{a%is>eWUc_xmYFxnGzTN z>Oh%eUdiPy=~O)Xnh9@gF5F7|KS^;l6+E+13g?1r0ZwBc(5<&FiF z2vt*)PR$z{M|Snn{=m?fz5L;K#pnHDEm*hVeh5SyP9?@0i6@5kmR)C;#9&=yLdhiw z@12zqc+g%S@%~(_wlEovOhVwAV^xBs_K2DzaPZ;ZU!F1}N@)c;+{W1p(uF{PQ1}=o zyRc`YvWoAEc*Nl+yRRMnd!@mqX*qVb9*s!lm%0~UHAN6|H7cYi&7GP)xV$?8s>D~E z8`C9`iG`MWCXC;JK02&n)!yJoUI@y&%y_`Lt8*D^L&IX9aDhNpC^=l<8&(&T5cZIN z%M}}_@#bMVWcuf05k0g6;)OAfV=~gE?j4i^XEc&jB0l@_{&_jWJ%^#ywjOk03(t^* zL_vMouIMlaT~6)9ZC@em+7DPstP_Hxi1S#C>~>e87Kn>?>~scU zV`^LX;tiiJM%Af$xzesOpdBI8y)YDtW0uoENIAdIbMf9VF3^`0ju5x{{x@oNHwXpD zf)GDvX8z{l;yOx&-7KzzN!OQ_4sqdGz2OR!1eD$fP`tBV+cQn&G>XR0$4Hnhsiz2g zdMgQ494}k$d_kM7&?OZgE5lc zlLzE2o8^*PcaM>cioq0Ud{9qGQ=1=d;jHFCvfu?|(r8MJa>A!2DenRw zMl{&A1`)ba=}62mX>;QAK1N)iW#cQ-l7F`aR+;-2B5Uj~J|BDkXl_nZ=shN}RicMxy{w>czyaE#DIn5=5ynKj&-T62M5tO(vS1Ur z)^*g7D#Y8lWM7J<_Tllkwcu z7zK)$D7dZ;m^a&XVsFQ^9A$9z6w$yCDq{`sOf>YvkFLBpNWQ6Is{A9CvDoAY(n8hW zq%nbd-S$DvukrgD;oBE#bunf~R0SsnWDG#voYebHaG`ja9O;}mL=G}DigmPeF3)N^L|mV z8XXj=@?Mac63Gc@dDYgu6IH#I$KHXmuni4cOl6{>9t-SZu2> zTv>wLrp>~pj&l}B!u^VHHZC*%Q4o`ehJ~7YwEZ%m$NGwc z5&=xfnLsfoqYOCgdAm0w$0En3bs)baMVSPlY?Da-1|JL8Lh4RKo;R^uSO2>yJPks{ zcj!?6+%7JJ6`#As#_J35X;J~GdR+uI{5*q*$=io<>yqkw1?I5R136iVDJ#_o%%XyQ z7KBShV<{I&NSVaTECRj1rO_cWf&{|iuCUmRJc1#CZoM;b^Ky$5CSuAL;vYjZ2TAJZ zG8`=IQz#}<<`cu*%2>QO zjqeL!*$dzidDBux^p zQS${i*5-znFH`BB!6#ldafvVUijf0UmcG&K2#zS82>-)Fsa_WBa%z<@efnI$9 z2PGE`@fB`~mR%4Oi)O4y^|B*}9z5spRE)ARAO?QD!@YECodsJlSZUpCBg|G%(tGVl zK%F^BZyb~PKHe6CG(v4qQDn(R`=pPsuhgYl%yt*)i2bv-{RP>}5Hpv#^^npu^EUaB z#}j65qIvG|y$hQ}GQ+IzV>Z-sx}zxW1G2mq)d?`Zal=b`+(a(Lr z6Ma$S67`(k_*8+%#VN_Oh|G#(MD1YKF&xS@_(UD&pymgt2?!b`#PhsDA}Rgg!oCV~ zSw417g)48*CjZg(&aeL}Q(s$5Z9e|N0TyuMbho%GWGDT3O%H#1L&nx=1cXw6UZ{#N zc~pfg#cI+CEdGo)`}VBp%VnvQ$hAvPX3ro{BG@v9Bnn96O6wNSEEUulM|nj{rEbjy zQ>U6qg5>8RARmV;s??v{Sg86xUBNF;8&JjebVL*C+v|-BkdhBoK{`l?pM5%ZRZ?jS zd@Ck3iTS)6R-v7z))Qnrt@B2LSFB$=%*8XtF)D^u<-(d-0B)-#Lvn9K1A=dJT0=>z z{GHslo>$iv^;^s%cRn#vB-C7kGoEgbL`E4j`@_hD~X6N3cxCXJj za1Id2TxE$Z`(=yK9Atru5|Zh!C~^~Ce9oL2GXn$c4$-tzu)I`nEJ}cayRCxSO)_nn zH`qFz-JHdZ(|K^)LE!|N;UrUfMaZ9VuQGSeNq0i z`~8@+!X3(IjGGqQTaCPPQ3Sea>)$uy#mGywS^!Tm6%5qGBeC)$u4(;-ZwWsv);H*6 z7SOQ2VX-8uZX3~FS4~Jw3is_wRdG>D=C>9qP6j1UAQ!wHpeOj9eU-LJvJ~qu7EE(! zT!bH1z8U`T3DWz=>|wbE8lCjH9r^J`ZrkZQ7 z>eg_#<&36XhK1hO4qR|>C@V#M-PRzlYkD<)_I)CazKKW9;yuV0NpWKDOArM!a@xb% z7fMpi%=;0-ieA52B5X<1s1ZBw-zGkKi9sgWAW$WFJ&1O=yQO621Zfwr-Iu09z|`v! z&qy*}BEG7nY59mlWUg%+mAEgalWacXhv#(_7K&k5rC)bH20 zPcO=0>(=d8>prJY zr-I-};=9xK!5(0~?`WVW6Znh8U)k?F^=`-ix~jh?hMq z^(V${e@+Tlzb;~qWlrz9IM$pdx~avKDo<`5=zf7)0TP6%Dv%SFitu<5F-{JIqq8pG z!Qx~BgV_tHDm(I(uTdHCT#+aPsa(TT!0Ns`sWzmN?4i&KFh{hR1C^mKtr2b@mh%0& z?pwnboH}#>0KRcbBAZN z`KA*Z7ypBT!r9>^WI15Y?A??41^7(eykv+1P@3Y^Npu$Dgb?8cRu^X%K1o;|;x6;u z`(m=s&vLI&4^_hS@e*EjjBHTqW1wj2@pvqkhD*R@SD9Qv z&fA-=7K4;_o0zrRSj z2Vri1KSd>ep4GTxh#}Jmv?>TRo_3Jm!34C{4Z}j*hqih7#_7glOG799q9CNREta<~!q`RR&;`Jg{N~ zM4dqZ?Mi?)kA-*?#+8dN1_Xe@>pSOa$E-jd<2-@wj0Spf-$z6=&qw@x@@mcflB4*Z z$n#=a%c;&!C}(5B^rjy}s2Kp^+CaezSPiG8d?=$uU?(*{a2i)Q*YNzB^pvehvS=;Y zqxUY8MGXxq7836Mr9?Ad6M8HWga*DEczp^E1bj>DAhWwk)VOn!SN`*S^LzJw3le0+ zIOR94i`cmj&c1MOWP*0k4=qfQP(mkEQnGddcfc+{Ost5qV<2DYfot+6nN0_P7OQoz5hoef@ zBQjRvDNlgy7z|=mK>9YcS(ow4RpORY#nDw9?Zn*-am_e>biDjNXb@Sm1y!x%sL8dS zR^E2Rp*CcuR;jlL^j=QLsIZBqGV|aPtOH&N``xC2S zA_oNZqb0xPMSDN>exK&s{H?;W#}vzN^@yC3-%y_$EraaSDfe9DBE*|5^OV;nJRCVV zi!Eh-?m5ZAL)zgKO5~O7e(IR#ioOP1y8BgDXF%xXjIXHR1MY^8x zAYrc6Yw{4pao1eJ!txE}+9O=?us;Cd;}ue4w!cx!2@CBlJZCJlm6erI=&v=(PHoy7N3-PidIGFikT_6FK0j(^WO;LKu;p zOsw-jPA{iW3f{Q;HNlme^Ia6d+O~=w5VXb+7YRrb^23#rH~Bss#nCT_fD#BcBSi^C zz|CN65=$io%mAdq>&!i?Q-d3R`=Osb?>bt)`p8B(g9f~VB2k))c?@r!^Fh}~R!+ZA zk)z?TJ_}cto zAt4`0+(g9%DZjZ+ZYJ8Kg8jGxD37npMhBkR~t_jYx*TGL}0*p2V41Hv9;mxDY|*k*yEkD8chQJkt*`*3lpU zkBM@!IxDghr+$+a?6NwE4I5{-(e)@#{Wx*O6myT$3`DrP0rUno)OM-jy#8${r*fow zku#UWz2a4EjY82!qx*$!r!(peo4^yiDDFXD8mGa-Q5 zU1aW^J_*z`$EZVWEf525mpDMPwj<@-D*J}dd-wVO*m~=zsNOGpbY|#~mXI1sK)R%c z7Lia&x}`;vmFt?z`g%`TMs^VvKskgu`^clk;fduv+q$&a&)yZWU;%mW>80cL)IeoE5%i zX3a3I%#`?F@(ei=>Z)S--4x?N}Y!KON8HC`lxnY7<3zhpi=55WGPYbzZdFV zGBciQ#LB?=aCUd)V-H|v)ok`^ky)TK^%e=dxt$Z!AGm(l!OeGXTpqIFW+`*eTTi!e z@u#NeQ=R`|%iGIA`@s6;KKZ{U{~cT?;eHgXeaeuc1THdBb=d6u>FVdWmpA=oZ|}7O zFyua)-ZHF+Kn_})F9^ITk?Wh3=^eSEZ-LJ&g!%HdXbNg zb1cGp0Kut=C{K#@(H^|$Zqm5~&&pp$&C@MV6$M$y_oba0?dcP~CTyFH9*cM0L@t*{nr zRGyHFm5AKnJ*>g`Fi()2g-Y0ZnO-1F;IYXW<$%UW?Qao>cjXRChd8(I-;Tz zcP;^hWVT*Zt!RCdBxi&1(c)2^tq7}F0OEdV{k%>9QdYXbGMT% zOxWCg?{@QXxHH`wbX?uJF}D`?kzGDOw(;lCD{Wl!@v=Hk^c8L?J$$AWVEeYZfg2{jzi>e-6Z#Vj_a-N03@N$Wr{7v~^+kf|eW~|IV;R1f=RQ>;SBL6>> zLR#>re#wi9OEvJM)Ew2cTU7CDPW0oukM%VFt?QoI|Igp{cVO*}>E`dI%Kg6^rSm|u ziodb?E`FbtoUYnWE;Yj2NXS{THqJI`ZMe%^IYftu{I=U3_HO5ww!fQ4%4ViRKcdvH z2JT1rrIF2DT;sjAdHEy!Py6kt5#J8TgPlkxyv{Gx!^`X7LNn7r!#FwKVG~zOc8m3F zKfSP}{s_G$^!PV@i+^U+f-$>-hrIgfNpTUtD$!Nvf4f;eSl3bo2b(J=^-Bj9o+w)+ ziE{)g69XV0DqKz^U+H(yXg52kH!?^wU4}<=ouxBh9C%WE^O9B!0%fKx%JQ1o&6;R% zKZ_ly))ROtV0T9~a{!FcYQQ6zDdPH3YHm8OZC(Gs_vxH^#Os}>4(+i0$aKQ|59zJu z3iCNij%dfhnWT}#{aVf~eh2-q-lLK;+u)YRL2C%(AUW&)e7noUj*)hlsZ`Ro5wvg!X+ za*9~=+cHmy3X_W`9ffb?o3MW_zbRqFHt$3{j@lFd zZrWY_6&r!ZracvhoZ6m@m2GF@4C$wa4*H(i2~Y*9O(SxlrXqn84Qq_!8NY`{);3Es zBlB{n7tS{J?an)U_BuXf2hL-Q9`O91S^y3cqh?HmY=y*!LT>N137G@@oK?7oY3n8> z{4{CW3WgIHWq-~34_?~cO+3`r-;VUENHg=3!?UE5ahGxdmumi&iSYEJR|kgh4_Chyauwy874Gq z(uovgNV>S4EUeKy1rTNV1vv&dXNR#VP9`>k0*C{hV1kaV$2~MP(*|i*fUvr0bMaT5 zdC2uc%04Q`(RK2bm{=$Ls+Qhbv8ntzZSKmS+?8w~(5O;?cY>--CTXs_Ep+Tq*S+{~ zg4ejQ+VCY1E9fxbW_N4QpV`G3!INJtAiL3gv~GHIwFk_+F3JNkKGnPUSe~-gg!o26 zcB2+7e<>sxdcPMr`u3cZw)*{KX13E_rb1PJicH#1;~c1u@=1Fce5Ce5ZX7}rUbW6Q z_O^EOsT1?vtxl?B%N9y@yW*AoVUF9Wa^Gw2U*hq%UO9iVgZh_7zK*kHR+xL+pKL6I zkNk)mznlx2M4FX_2K}ifxe89jy^9KfBP{hlB@6?UQdNTyk`%-$F}YK6vO&z!$m z8I8>BNzxvxKb=(3w2fd1#T8XKXmNzDxD1?5HBzjEvDq7<6!AvpCyi!OPK@cv4be~*o=6Gv;@OLTzhf@sk%7$| z>+jId=c^A7g2a;#f%Okh-eqI4QZg-x)cQ^f;fbSPX3g9zyI9OZF8@GBG6SYKe@+CU z7k@h=g}lYujDGzsx418-nn~jN4?xMOdN6)NxFQ>{ym+pH%am6Xx^pSbKELvxVTY#qM z=!+rupseaXhmYM9$a3#yg zl5QW(o9jCxD52pW^1f>(;s|05DGvnqh*9Lhd^VMOhe0{K27Z&PQW#djckn(=^YTK4;C#C>#L&>oMEf60UtveJMahy0E$=oStN zrYi775w6gQ`pt~l>A-$pX~!E5xdiV|!eBL@L4^QPc>VUz>>dJver785!P4aVtn@Ak zA9gJ-yluQt?P&=>^I}YSoyFgLTpUrpk7f5oh%~$;oW_S>gyi1*#GO$b@h+*)zHa;0 z%+ZqE^^A08VDU$n+@K&gC~{b`2!Yb3E{S9O1obnm0jsTDIQxT-`%-YI1icO%(~rxv z9vN#f+i zDBgIrr(XW{F!qzr+l9HaN%|MuH+<_ygj~#2mMZ;yKTfRz0)2DnWFFCQ`~vJZl`+pZ z3O~&g!8hbQYnVJSln?{=XyybMLeYhq;`e@&2f)enatkHLjwU|Ra)B)@GC{i&iGT_- ztZw4BK@3IyRxp=94?O`7Gjy`x$DBb~@=O@h)|VN!MYXCcuc_ujkG+6r^1P?##EqGu zQhwK$yDDP#%&it80Xz9y@%#3WbmFJ{$0JNBtf55}E=xWx(338ab;e^wy3in*gje$6 zEME@V6v5oIMm;piZ()7pgk>mb9F!-ijm=e_rZ3+* zoG(p`sUa&;t1G60z4vLH-Ys9Kj>pS<3&z2L>A%oEcQ%hCr8De>3(Kb%x9sl0ji2Cn zQ4wPJr8ZflZ%P8j1H6~2i%LrDBR|u#N{8WYT0*?qWHK*ud<;dLZg%Wml9cqgt-F7= zVIpauU$67&kx39wkVW4_C^h<1%(1#|G^l6sb?uj<{IW6bGK4znOPyuAAaf91W_=vGkiWun+H-sZ8BMTQoBc6-?wR=219qx z=*tuWW#&g`4QrPt3cTm<7GJsqqn&-qE4aJTbJ3Cj?%m0Cm|F>B)>u#{UUyGHAr={+Z1b2#i0AcM@pv2RTVHwBhK~s zfbuVzF0bJhRTwFTRZuoea49eJy0M2}l{lP0O4$cfpmJX9s6AncJ8Lwjjc(82dWwTmEDbmVjjnj4%rbM{x|8A+E z!D*SS{yoC~mI3Kd!uC78I&&x|@ecaI3X>DvMfKS1NR4i^O#>)J|;{ zqqDiVBoa)H{39buxC(cp&l9$LeR9R);=~kaXO1!*lhX{L`R(G3-g*V3@|We$?>*Kl zT_bF39lZx2NXs=81)vNosE3TOpLfA3CVm(3C)iTfyxW*U)>mlQnp zsk=HKxe!O-k?p`l1-#qO%3sBil8SD5Wen52K>6XoLiLH2+fkCM(WTtWW{9^4Dcvy( zjhW85v1FFFep7zRFiLaAgF67(j5@Q-LH}9|slz4G;#M0vZ&MRPv#UNy zKm??T-@BhVjp(6bcEb=J&)+ct7@6qTpA$Q6h1UUaeDR*@56_!Ej%PBmHQH+hFO|14 zw+xj!Y<3Nk{v7r#{4~3l zfaK;+PS4CQ%=cwluaW<3Ent9$Njk>RVT+Lt;3A3K7lKP7qi#bXNIk8izPy}e-uT27 zK-wu@O%5f?dYX!zSi(q##pf!PIy`fQeCSMcxW^c!nw0Yfqus^|&)Er}cQbPS=~wfl zh2qfTHtLsrHpFbJbBkui&uwnPjl3GU^dRftsh^=UZihAl@0;uN30cUSsRmi>K}!Z^9Q-2l}08}$)B5ij56+V!z+I+XV6$#KTC9J#}AK> zrTfxDJ1L-%FIa2npvc3YTsl?x*@M)&V z&@Bhu_3XLTav)&QFIu~|M~&GdBsx6L8HGH#z|%sS}k{+ zC&nTe`3plO6f>u5J0G^HHzb4m@kgH>^+wvIN<2UH3vXmR>i2g3OcpgZv=S$$5T#@hA;%uL6UxxpDA?G1yvqcqcHDW7Ho>5V^@K zRh-Qkd=g5ZSz+d_DIz>*r6P33_|?Pn@+T#1NoHyc`*Sw) zHZ!QyWr#}amMH6?_7f9avK9$q7XuKBOQShZT`omMF($stFZ4Hcppa68tz`YC z$&5_Q_DBLmZ>RF!Ifc*=W-m)Qwwl%)tfI)<@I^Dq+J6;=N8=hoY*_}NR;xF~5#KPy zky=@72E}>jaee!X0vB%ZzoPB?aU?4`^aHyAE^U+hP~9i>=!nWZpbwc>+keA-KBdAu zWoUZCQNNUT)HUfl^P5pt_=)?ZY?8pJgvT0H! z^9;*sWvch_gy~ufUsB()7@_G@gDxrzmh|0;R&+Obn0)*8oBW~jmwXk(;lwA4SxBCC za;>gM^F|xg=F~{3^Y*P3nPMuqW|PnOP0>)MO0I9~5m@#7=&}1B?IcaED};)qc)e;8 z4IME6fGEoI?~+3X9cKXMVq^5$=*cd-1nw*MwapXHdz%s@x%NC>i1=NuY{jCOnosNS zi1>zo`(=Co0j@?C)}%)~G*=5UAxnVcrC6*_%ro=4e-+b(>EOK~*?wNm0bOzNdD;lc z^K5g$6e5ZAmT6{M0oI9rmxD__bqsc$8p}pGTh4mBzy)$cV`IwJ(VKyy^hs`5cJVWg z#^-9C?@yQ#sLcc9iD3OQsQoI^aF&8yL^kxjkw`Ohl=u@s;@R^yw7sm!F&E(eAnzX< z5&h3|q;IQ2uEF4k9Xv=b?yLb^F9K`tQxWocmyTO?SKnQ`9n}`y`rCfyejbG?6%nVl zAX~K$C5|t0kF;yQ5xw!lA*CAlou3Q(TS! zR>6SB)N{@}I9p19FA}<~f^P%!dB_wPOnJKL#O)N@X_;|xe7D0p6n{T)+4^Z2KNtR( z`7^t&y{%KXk$Y81{-Bf-)3wWx8qg` z3_I`vSDIKWsaAtyuP9e2yrY`XhtvH{Y!*jyK3(fe+=u z&M9(%TjL`kO`6X9O(&~c0&V_IxeMQ6N`08r5E)B3taiiVv~pv!-h#mO%KFoKljgT& zXU+Js0=6&ryOuUyo}EGI#>fB!>%Fo9A3|jm2{2aWLHj+Ad@%^~l1 zufw?Mk_b5F>e2!12RBJh{rP5@EaVVhkFr=nRs01u*vt)$zMaNUtYCdrtKWs$z1csP zbbA^IbZ{~1Z4V_h->_FF3|CvLPRRDN)iy5ow|oxOgQUPvt&v0SUg%aSQe#UaGyte} zC|wwr?RR9pnVnZ-`Bs}X2hQ8H&|mQ}Ie1eh;i2+YW%o1PZ?9gy0JkTC*7lRzU|AwK z*CyhN%aG&!=46Y_0pmp=duLVmSq~pnMGHEW%NYHT2b~v${<}5G znadsU@q?FN93e8HWVN;FRaB99fc;gBJGFGeFb?8=>g7c*)*i~REenRC5%ur=Yc@Iu z0Qm^`V!=>*NJ+kCmpr@k8;+5@;O)!;L+!)(s7cjra95mNWWLiH64iKaD^Ge!$-LRE9N~s2?e{&c9oW!`pie*i*8+lrpw+l?>{R zjbS7bcc$U41Mqv5uTupfW4*i)B2gb#v|vp3A<_SFd<-w`oD4bE#Ps@^d*Jzbewm{< z_^6NO{u@?rWKb*7`LQxEi)1EHN4^k`D5{#v#`3eI82GnjB+>!~(D$iM5yO_9$+BoU zEZeTW4i;6Eo|ad#5uF&%0O6KknAdTQPACk;#mRz^QbYxBgI3o zobMK*%~KDmnR=Ei$2vUazfqrJP31dXg(vp=ah%#`L^UfoEyEQm)_NZTj*-BJOCGWXu@rzz$=Y>x5gp-RHfa|>>vQ2O?eyc>s z;pon2f?V$n;AXq$&f8ZIW@U75x3f~7kQ8yk5oj@D;_jBznOE&yDOZq$a~hf1hmrJh zIGckv=Mu5-gH0Jp=ktXICPJw;skF<&i$y-d*~9{{71we!S^JtGgm|;9Pbr_CEdQJK zH9k#Sl{r_(>pO&aMVuZw!@6k3{%=_4djJ39gTqCm@5q z;(Jl~z=(09zUz|o%zEVTuSF8qwBy zve0Iy%_!T<+jPzpEYz&cJm6J+Bk<-U0ggq~Cq@1JS|igKj@WqOK3;)y{D>cSq^#`G zA8TdjScadRcdJ%u<UP#FqE9IFV@|>kxoClfua$kk*SRZ@>#aCjqG>B|x9MH(v}Jo3=AhQtGUOP#9d~QB zBGApM0!}CGm|^ER4SA~4GuMX!q1X>prGdKFLh<&jmMAH!w~93W>Fw4CN+$ARb0E`Yxf8$7SluQ=H);3-0BcT9 zYjAy}{UA+OODiD%`}DC{#o8w$`ru8*lCT64ZiD{CUqvn%0O8OCn+rE1Yxfc zEKO>IL(&|-XD0(btP+m3!3LvB_8r{Xo$zqCYtx-Oq-8OVZy7NlK z_o*Aj(Y~63Z|f;}qaqj2&GWzNP@wXN3d=MR8At|Gvbz8m(|Ke}J;=Or`Ijn=Mj92e%zpfJb!)-b?;qo(v+$H=3}z53$Qtr5j<#4grZ#pn!dnU zY}~ijh>*l9#~uAbb5%?A;iM2U$tc!F#GmLl{05xfohe2tF#<@LTznOc<=WHj45SJ! z7%@Y`VagigF8*2lP?&kj0kV^NRyy%r^>x=boDW(>KgFB^P-{&D>1t{#!>{y`DbupK25-VT0S0k1jv@B=2l@0oz99 z-rcj>zXxC|lKN}2w$)&XqV5{Fg(DZpMHDqzpxYa_Nx&wf1(y-p4Noc26LM?$^R;MK zg2cz@{#NvCO#&Zc#)g<%k&;%+iwN*oh1w;mw9`KXGNq-!^Q&VXNXTg)tbt#N%0QaY zAZ8`$+bI#3OUYS4S=&;2=G<8b<7^mbuhEt4i3B#jX*%-v!z3brnUB;_7+#p~;-jm? z1;?KuE-Ah7Tuh4R#u`k|Vjl==(^=l?aaZR2FQ5+_!NE3G=-MkD+#(cMJkY}Du8{LT zce4sWhmDK5CHR4dJztq_=u=IL#OZxWl^C1U7PMAFH5HmN(Dd$udtABW!?32@4`<|J zI@MNzkZh{3RQG2>VLGw*?rR5PZ%nm3`NuV%E)%ofdCbjxHO7bb;#ICc)^L;*v$U_J$EL!|}oq?*2m6Va%k5A=D%Q zhwSt0jZ+yF@82+1{k7$Wqf-hs1z+^Z*;HcuCsree-+f8sxVF9F$C)R;RqrBLeyY`7 z<0WULnLJ_vrL2>1>i;o)GrfH$&Qg_Kv(AEA6s*}}_9@68!^35fgQO8+U;;ljyCOCb z$g$QDpF7cd-#O}G)I6&Tjy~8Z%%3&xXI$w`SwpT{(!MFGM%QWsTh^Nl3sS~{GxI1n z5mm)cPlN!#dUkvW0c5tfn;EVFsn<&9*~VpHC9Ht_?=9cs1FZ$D8kb3C6eYl4$zDk* zYVZn>e}3HKj+Bh~D|ffE#V+pm3m{Y1;QK||GQ86-fR}TP%gDpfg*}fIQneMZ9^pSI z6@A6od|RQ}B7K^vH8p?7&R*;9p}I4|kw#x|5%MSxa`JfsK`K(;*1FM%k3&J?nXFMg zljAWLR%W;mIz=!C!0i94ItpbvpU>m;hZm{xGQWn?H#CRHnrZbv|N`S zBC+g`=y9;mNg6b?(-}tL{S>kKmsD5)vW%uv=79YhRuxD}BPq7TN)liOcMSPxXm6P7 z6^1xnUXYkX18W=YgRURQlXI#B@aRvL3VY$~4m`OexHy0+l~@E$56DJm-Q13dcV>;{ z)Kib$Qlh9#nmzPR*14RPTj3`eXNAw!4VndEdwCC-$%26S9oxUG_>M~RW`1om~P6PtSXpNfeoAvYHup+Y4Ao=mW33FZo32m>)@(AmLy48PeqxFeXgxgaqzu5_5-(rs@dqqZ3NN3m_Xs`>xD`lYCkKy3M8UNQ zd{9|5Ip$lVP?EN<-`4fo!}6jrA0}>>g zL3vZ*QOTNEif1eMcy)Fcj}*Pl<2)cjN|O;80;3t4@HxC4@KYk8`*UaGQKd3Q?bO)z zvlacf|@yHjMBY*5}5TA z07^2r-@`+E-0sgm9+tbiOgok#n{y4?a#idM_8|zAF=v9jGhS)Cz@&8>5WW}q&pPI6 zgTr85c$8-~-`Bt<=}MD(ThxS6p`WCuzH2`*q&6p1THC^TyZNDqg}`;^C9SG;hqDC?DFg)+c=Ca=Gvlr)Bky@=^$|gVQsGm zJDs%G)w}M~K$9pKPR8f+0@G@6E1)om;;RBn_ z{jso5AVuO@Ts6xlsb}$@to5xV*ldbcT7z`00T;xqFM)-$2(t!Jhcn&q4ty+$TAJga z;6(4KHy{G3V~Q2E`h>3^tnSJ{0Fu3kSvS)9$L+8h5oF4maevloTBJSooNg;YygV&{ zZ1t}Rc|aLnC6Mfhh}@x}L@tw7p(-2u!LKl{lRuV5+b>zdI?&j4O6M;+i-s+-%55p? zqqWz{r>Y*jsiZeDE2ATQz(j#9WWX7?`$IaD=P+m(mdmIahnlr-yB|MM$KBjs|LCTE%v}ID;hI@>eQJLH`ugo7u&Z5VYUkL0*;)U-od&ejqmNerf9mT^e2~_6c zc>7E|b*>%WoX-G9SGUqk#BI4|@@pTlKz-@_$w`=!B&qHaavOv zt}31_VYt8K_;*drvh`(j0+9&zR1yiNgqtaU1Xs*~cjrYb#dP4Q)fsMBvxso^b^GU8 zA%=jX4FG6$JrD@OSspPH?-$Ug>ryWjM# zaBO8#3SnSCMps1y2=nE#oI|b>t2&*4cXiAF^6)w{Y&N-qD>vZaQj$!s2?z|+EcYV^ zgEvU{O2pedI--kmhA>&%G+o2aLbiH);#_k6%6^_Owx& z<nTq%{miMk@kCXhe#AaHHDS zT;&&5ok`Y9@MUOwk%_&RMxR@(-5Y+{3g$)WrLpoIBIy<4jHZkx&3<~>nVw(*%}-JK zq-jd0;f9^dG#ww%lk`CBK`SPC`8e=J%^pbJgX%3^qO|iK?-QymxtkpvRV~qCA9@Ha z5`St5Bix>mk1fdEOmab~?xxhNm_D-*5y7xTnpx8xr6~JDRV?&lep46>v=GPeORlDO ziAqc2;XYKaWFXmz=(Qj^=GXs7@ls-?v3GqnU$Eug`--pUY+_PH`A8j|DplRpmps## zEySZH$5C-IJ5)qEh3}TM+=yz$&3t*p(ruX;iF4~ceddYMY7j7gkbG(RtexVUR5vro zWl=~_KH(OVpEYwC$-MY_XTgtv%wf2t;)ApOFRDe89uKjeM zuSf4rgKBLF29VM@g15LkvR6{9m`ZmGpIFGc>XYkp4=$518vG=nO>v`K!}w#|IFhLA z1KeuEn4R12?_^5En>d($UxX$*9pJZMtELftU}*HL2@I|wsnkFT`q&>Tr8#_S@k-2> zzl6T(4+s28_Sq|)UN$PqoO6QACiYGm# z6Z+?&P{5$g0fuYoQ=?<4j$ydoDUnEil|=8?5P=1Gmn?kVSrp-5mpA_XvDHiO@}4R9 z24(obn;Vi}aUIyQ-Ruz$s(^bT(@&x~r|z0wy^7BwSDv-5x;3UU27|-@7M3vSna15; z9h;oo$!zlOF4l>3OR|L>1^|3hvycn!E`U*^9{-ALrBxb8oa`rC`&5A?EPz&wD-r(9 zbTC}B3Yn7#vEL9Npo^Nor9I%W1%TxTO0t1@n@1g_jR>-897Op&HQ3-=W*vLE5}q0z zDX3kPPNAPV_iuCIH!SR>43y+NJC_I3$#9p&L;LD=LQ=Nh0lWaNy(Z}4U#`ehj2Dlk zYWVIj62aZx)ZlbweWbkpOq}2Zg3!BjX(J``=~0rGn^J69j;3#5kA(pO7X0e^I5@@| zTD*Omv5pMQt%ZGwiS8I7$7Pfk z%lqQF((giw-peZ3vxIIfoE1M-;SxB8fN8TFaea55kKvtOhy4A=dYgY@n~}Aqt-?6T z5O_L1B8%SFCE>@jvUsDlP@m_!m9aJFSmDIvxAO%=LiYM;y+l8k9$tikVpost)hrKT zErLmtH}$KaclVsYA?=4J=O43D(6;xxef8Agk?c%Bpl8M|lVY|5dD8ottwdZdL zFCR+E8`;^9?sW@ZY>WjOB-(>A zK5BTuDoN%pMff7Aua8JOce<^x@QrzJdW?M^f9M@i<>!>7j16!s%AcVaHhuYwyXVL` zIubkmdFkuV`qy2q_%>~i)KQ%PyfKT63>Kur-XmF!53IZifG=Sx5pLGKkv%b}cu24- zEFHnI`enx19C%>5V8F+8xZJvzYK>z|XO$)%s?ivVOH8b5WU}zE2c`K@?8We^K{9j| zZa7O2c-XLwb5!IbXKAjkh&5PzAE()oO4y#%CghB|qF`we*!zClmJr@$TplO*wY;j9 zxJfk8;ym;mA6kZ_ee&k@g3Ja}3%*$DHheYOyfL0Q>92ooMTGBa_7&3b<8LAGMK}ByqgrXy zjn-%`;%SJzUzzhRME`Wc$OsP@Tr=D4HA)}+?DjL6URmmt-SS$}aSl6e)8q11Wm<$! zV|cOG%RNU-?ru291cWaU>w^=YH6?79?3GeJp8+HGc$oydn?&C z@mlf%WiZ&DgtEPcLti-*$1!V{UFQwJw*s9fn4^V-IaclS@bEYMk;H$^Fob$Z7+S;t zwVTo#S-)gJC1nMq%CjQSUMar)4J^uwss4kBg}&Af1A>St+fKrfp2@2?8!C|&(b7*V zK>AbDSlF#(MBl2a`Y-q~c~t`}f=_cTYqA7PJxx@LUl@IrFXVA;UyiA%#=&NPi0yi# zyOnUSCLF24{cc_ExU@h07zF^W!E-j{FIoXW*zWS(N^fULSyvhW)J7k~5f@7Hs502O zdFtq535V2>g06G+0U6m3g(VEN$$33Oe^EMcB;M17hr2L!jXwU4}jVCNE&&eMWn z%LL&o9qqbjcuBft1eNkW%fEb#8{XhuipZIl#&I~kZOh_4R+Q?06$EK=Y`(7e$`7LXnn1R>&r@?a5)`xn}!T~4BLmLFUc*yWuU79 z7rR(xO1i|ym5`5W2|$(@xw2!*!M(bs1jP1{)0fXTTfA;$)5cK3Zz~^Vfv^qPa7mdK zvN3{YWPmfz6aXBqlDYIFRb4cyu@g(T2=ax_JHfr|?ruO_r{x!Z_gosM#?r!08& zZYiPe3pLq=Hg=MFC^yz1Y#P|mrQrH#4rlF!jkf12&0@Kf{?7&P;IaUqXtjYf3l=)9 z#n0`$*_61DvLi&r*$Yt zCjTK)UK|WIUF%X6#+A5!RsDPjr2zZHdpz8A&VSgjOv>f0x5k_oT@sq)^ga2vO!~EV zQTusuJLXg!7#{exH%@;i|85C(9|U~etXzHB zUE9RIKok{dR2J9nV355kIcl+OC{5jb2Fnid`P3|W90lly&!Iu6G%9Q{%1RZV(4?8lF9_+j$Rk9>gV{Pchj09=s+(1dd{ z0-ybWYR5l$i+H{r>>|Gcm1~A?&;X|DVe<3ove`Lp4Aag`_>lDtddxJoj8)w;R0u$+ z(!jR)GSe-1i7YDnk8)4p%u9(HC(sxg*t|RJK|A4D7;z<+`qFiu#jRUAD!k`+nVI_f zR5{cLMVuh(n-!N4nKRb#v@Nc-OSf6))p+~dT1!)pWmn43fy%{bHlzH?q5E?adZ)9k zwz-bNf%lxx73xXDh;OdE%lToVuCvg;fVum?^DKyrvv{Hstfa)P-~P|MD~m0rq=M@i zy8v}A^>=dskpCC}n+AdKa8qZCu0jPY^dWRV@wz_DKQJ6XIYr}h5Kuk6qMvn9rG+4-iaDv5?mcSk*OBrxt zr8c~XUwvm3S00?-qmt6}4O5tfDoDg`cxH=jp4-A_asxQzs+__-FV&~OFUj)L|oui98^ODY(`qVSG zen5yB1@fjXbwh$HA(($9UXbkOyQI0P4hNOX!eEf}28f%e6J z=9~KZ@S@Gfh-!xfET722Rdpx(a0^Wn%^0dh$<8q7j*l@_B1Qh>C5G;vVl<9cIU})} zzyIOwtu=3P^|m!dxI&or`I{mDer4rF_Z%-0P*f_wqul?w`#HLgHPBRqhaj1M#IRvf z``if6@G#g#1`MtmvrxuVX9Ej5$$$mnY!cXHD|btTs(fHrQXXUJ1F0iLGSWF?26H2m z*#n!RsG<*@R~_BCv94Qov$^`3J3<;! z?mSj&G<-a8u+Z9yOy!9I&X?^-@~`{i2eq4L03hOeNrO@3Nv>3+xJnQ+=hC zt8sOcya$Y@Kzp_R!VOQ}XG-bsERXjnn?JwBzz$hbvZzRa?-y^3Z$%#jP!8Tm>#{xOKf2q71l-A@|TPmuTc?|$Uh9?`F7ks1!rEQkd7rcU3g|0ym zK#H$DioJ=QB_z3q@XIqBLQ$L~cjP&4{ppHk=fsA_80N&DEc+2h)0C95qs&jFIbc2n zh-Amrjtn8(Vcx6gF&u#vF+176^-Q4~i30@Ot8`ai8ph?a7>I1??SqhCh2I5 zV96$mtHKwW!S{`8Vj<~T#UbRJoK&lF-9+)zoO{hTlJY?}L_TX$=IGtOK4w88!VHL( zleLh?wkreujOD%y4D#)*tfjX`@&p4|wJrfj)mFUfEcS`Kw&N*~YeE!}>}>B(rQ?Me zO^DDw&hkrwM*}&Rg2q3=^vXLFhmrARrx3Y7nuX$%A)4&$#8{cwfOe7f*|1LhoDSdd zC(D<|F6LqsmP2PJ-YA&ptK*M|0jC{Q-jcT+N)cT0;_zEuXbRizet#KWAK6M;;^Eg1 zoY?)`OdudOMlSx#Uo)w_yM6qh*<_Ve_e}81K6>_bh>r{JsGBaLZV50oaBsDuk zWS1J&_pN!n^;E-4Mf7AV++gPe7o9v%BR7vS5xzzqwUYqi@Ka)bMEa}WmCe>E=n8Q`ZR@t14qZVI(HSyrl zj|8J9VHBzljh-2D|GFZTYyKYgDQZa6&VT3OWF3|*dCb<6Cr-hm$K+2GVF!%D?Mf>j0icERJ66jmAVNdS>y{Bw5Em37pgsy2MpWb@~1xP9<{B#O1 z&IRW+ilbxx#6Fc{DM;cMAfnJRRu_-eP#T4T$OfTqQXY9Ps&56D0a%_B6INA{PT$UP z`m{krm5$?hqJD}Ly>_<%BSe5yuqEf=FSJ9)0-PgDNqvT`$f2L4$qPcpFZAOg&C&xc z1s(}_`@^HzA1+YH1KQkW*a0yHTZh_>z5or?R$^b;U%_UboOI&sqyZKi!~t&=H>muz zli!J3{UlgfYjljp8PSt?;eQ~&20J2@3}y27G9QR6I>bAcMQE?zGo!Y^CIAva3npKm z?a|d9yaS={KK~bMcNNuE7d4DJ!QHjEhvM!KT#FWWDN@{n2PnneipvL9QtmMFctt-CSGgvsmMq4dhXl^|cLof(w94-xTTv?f8DF{$T z@ILy%5h^UxtVi&hJb&dq{;|euK_e~(`Ra>@kU-@_^f|R8<|ji8G4u`0Chlt4AIvGW z^O|Y--&w2vTIjpb1^?l~mOG_c6f8Hkb63iU6*-RG@UvU_$#3zGnHP+_jAp9H=m%m$ zYLI8mth`_A?UkK3K7%bnoj^4PSog2jgda zDDI`{!~=glW9DRpCMqOCMiQL2pc#4k>qpCjL~o3Dg0eOBHpWJFbM^nCa*N0-BMo##GH2`B#eyemOnH)U8MkBj$;qcH^!nsjCDh(z|Cz_06BO{c{ z+-Aw#Jdf{75R-Y1hY9LRU5Gi(zEtKz;tpOIMM zCYZwo0w2SR^3G|~V=ub?0j($~ibi5tM)3jkJt1&Ai{5dYQ(*((RfjcH!_Di1 zeCp-+xYt+}<^B6`9dXq`L=4qqq|cE%h${MpIJpW5Wxl0EgdOcD@9{7Ub?prqb}^){ zhc7FnfonOMXw)_rAA?X#k^E*)*{wyo_2)g@#xxbNu;TELr?IAi;v+p$E>3O%)!=m_ zo?93EZ~e;K*wMgEPPpu$Qmg0NrmF(=WMW8LK`O#0QAX^+*4g%Yb~DAwpm&q{?o{Fs zm(eA@5gYjI3)^HH1u}xu^*!7#Yh&nedcU4M-=FIyj4XmKpFVx!^d(_=UR^|fuQ2X! zRr%d>MGPC+UpJTD#|=QZ30I$lYWiy}`e25L8W3Uj6b4;K>}1MCCpPs~yPo~ZjlBk{ zOlgq2CdgG${oCGVyL?ObZ}exJ6e?wWNG#JJW|4aD7HU#Q7aP23$J+6_EQpyCKHQMF zJ~mwAen9TGj5Aiiaep9QoSFYNAF~Os(dC%Le!kl~9wGBU@kS#U$WA!$X)6N9H#p7d zMo7r@c_zjN-PZs;Kja{&s^w(>fD)f-NLS87`CKeK8!tTh;p{A&w5NPsg5a%b5qq|kcLqa`Y#a( zEa5iq;*GSUx{VYis_sG!mf8JpfnORHpD5G|HY#@w!0i4UZLM16 z*c-|v$YoInRYnvM|Jbq5mw^Oc>}!O5^aEHaPtW>eX@=}5_BP1W78Pa{xI~f@Ib`*L zM)N^*P-t0-RbIO|dlnwceIr7;(fyJI;Gev68u6?}plIYR$_xUbfa)R)Y+7FiorL(4 z;aNB9;MvN7EKBjz%$NQkjjBqirWI(_Zto!3!q-NMS;5{67gt7sn)gZKL2B`Y`3%pc z_{^Iwf_0E$ivYQRO3H~oo1Q#AGGD%b!?O+~wS|jIq%VWQwd?U=rVYkX1j@}YEx-A1 zCZUv(iugoVV-~Nfm+TI8lhSbeteN0*BWP(@y`tZbZ*S2Gh#R@Xv`T#l*DS)4#l%LO zL~9$;&}=RH^E=Odvz@_}bEu)YQZtz(HVGNBRe_j|phHd~n^bmPsqsyJl9{7Z<47oL zdhPQ{2nr+#f&(Q{S8VA z@bX8_D-ykCCvffstTV*<|E~q$hRmQV4j;vRP}_=L+bptihI?rrEp%SqiBBKX(~>j0 zO9>HaMBMW2Jw?ff7v=;BmXRue4ha-%3BS1Z1+m*)5Y}98)a`sV#0a$YXJS`Q7^pF>j!F%AGnjdJY>Ad1URu|$g)F7f9SkM7C)yIla zRWIZ^Mz(Ehpo;oAPj{)aoKAlV6Qyu69*z@iNkczo#oFG|dJUN+Pq@PSfedY8c}nKG zv=qN)^!bt>`GBI~Q|F@{{zD(0hMEy0o3cjSk#7XG6s@HSmg5C)krOW+u!D-4x z3Z+g_@BC#spc*e^jz@rX?18mE(T$8;YGRULm}ZO2zuosV-L?B`Uahx5!jaBhSe z!F9=w6-a8L&-}|q3*+V9ZP#|0nJl2vJ;W&3EY;I{TDc$(q1kt9QQ` z2XkB$aO{8gA6nI#;_#2UbqZAtk@+4vEm1mdX_Vs<7tfXNSq)m$@#ce?G zLg>W|F}P=J{q+HyEnL?9`;g2G5F8hRE@>m?!!=lEgx*T7M~4FUn@%sMTu4`*7w^H_ z5sV8B!@5KwffMYJkF@>Z9RVEpcsve4OR20A>3wb-X)Cda2zhOc z@f?*ANsJm8AXI!gY?j~YS*Ut>dYq6y{Z*YmQyD%L!BI;B__y({lf-+i<8ejxq!+ot z5f4RHNkqv0hR5oZvayf3LnhW(bwVXh^M3q}F4Fc4)USWF=zH+7Y`6ZPTWMcqCZ0zN zlz~tTKzM9w6hHEL!W#M4sZDVjf0J^PgLcrjyCs4>oq`e93B@vz7tE13Z;dR)1P^y@HE_!l$lTXOOQxB(v zP6bdR_;T|m{=@EJGWVozto9SH_OktKLyX7?sh=VLVV=o`t;Ef|{xRryFYl4*=5w0^ zMVR`>nj3NeLubBXp*$hf@mcdxcsYWUV7a+q<%+_QzhdSuU@1mX8T(wrxfcNqoi50d{rJ~W(E)2affAiqkLvvb(>}QQH7c1mOMy9 z6Hf`7w@p;^Sbp!~u%0LKcPfY2r1f@lv>~30bOLXIa7LEMmPP%VC42NG-E{6F_YfS} zgDee`Z3K;C2U21yJvad+ae;<~B-tD?{gX)`@#i#=JyZp32FjBMZ&AI)eF0EM8|BAL z2F`DniLR~((uEerT-7FFNpkr~O_|dq$=sAt)lH)02*%&NGo4#12)=YF(EDw0_Za}^ z0H0j`wQ@%_f70AG&p}DHSYc?D<`BBNJr>o}$;RV!`O(G0U^#8ls-T z)V2+gKF{Q0g}c$hXZuFa0%cgb`m2-nKjrykKQ5vzLhaJr#dac3nors;NaL?hbPD!! z!8dj79l5h932b>nv(0%2*$Zdv3V!yp7XfZMS{_jvdqh_lzYW&M;S5Q zHcL;9p3SBsT7IPlx5_s*WDkDI5993@OQ4)tNL<}d(4G&z`Z8abu4fsCM?ZJ#kIUSw zJFoq=sXaOyzUI}oBl3mursL1^d}o#RQn@bjj54hDg9b#)5q ziZi9n)5!MQ@3F5IJP+TooJ)rbRI+UB#_Xh0&YzJLj?G`qsOmF4H2TjJoZ0s+kwz1V zJp888Q0{MS z+5TZZ01gvK%E68=*q!QUi_s88>`2ObW7L=ZUCXG#AxEmL^5paN{nu2ckEO3*3#Vmo zjH7rqtd8A1$y@kabxgdb5I2hVt){Cp@zB`$0nUP+YlbUZs7uS&grDAli)qY0TmDDB z)nZOe2t~THYeUnSQVS2z>x_E@lB4K0_Y(Ij&3UfUzb&oHHWG?U?YT!~FUwbthHW&s za#5+Y{UWo0O3k--BX)&3S_{{`xiypoW{THH@*1$+@OUdpbm-Xq+vOcTFmQ+R?RE`* zAMuu0-qmr7V`0_J!+t@PuOr!!{f+x`!*OS_YfS@AMsD2s&_=!`nO)v~Yr~OuGvurMXKcCQCpV4)T=&kOUtdR-Wl<~ zvm_!uD0+(~>_Q}v4e~rADhadrH*RMgbQ zu*9rZ7Ix8#)D7lO_O>yaLE%1L?zzeWTNqc(Tw!%BYSP^NJ5r{i%`L}qkKQ8K7jnfq zK1=hKax4M6&h8KYbSxK=ni?Kl-FK=P9AD@?7hLTMw`|Dlt11?bjot4Q(Q!g%cQl%g zZ!SSEt#_Xk;Se?(lN8*nMQ;}kXu^@ZRbZN{Gva?)$vQPQ$oMMx-zlu>@$FH9J)LSP ztIsW*QtH}21!GAqO4>3j!qz&NV{a*f3*FHyeQ_)lScmMR&!yBU7RS$)Rp#gXku<_A z$k5e0%PdsXSC2#6dA^UjZ%?+2j3(!-d|`I=yn}TD5Gda5HfnYHfqmq8zo*AMyzt0H zG!Ud-EW7)#zwp>HTT-z>%4;7j{wv|fK|syteZ6?q^R8AZdlUn&bWHnEFU!tpp8 z0^Z~3&r2T1PE`V8<&9j9KRm{YLub6NjqQul?ZGU)U!A<|Ze+a4#GU(W5$B)6aua;3 z+M=62b{~}a?M^vVpok;pm)JX%tsCbzc{$`x3(Wgr&-HTmpm#N=i?s!^H9wrSj|pfC z+fNddiE~h}|F9q;{$mU=>SXjmQ=JR)rB9l~ zyfJ3RJNjw~R=e<@hlhPoUkHR-()xz8`J(xi!{I&Geqiqkr7MXqY=CH`$0?A`N5Xwi zoMoPWcaU>048c!N>-{dtd=Ot-bTAQD;O9W56}8a3us+>PmMrCSMD@|}PNm^fd(~7? zf(=$+L+g;PSiy)VuF9uM@?;k3uqqS@{RAqmS|@d!G}`p;4p_PdD*BwBNsKO^(TfK2 zDbXwSw;U2}Q2d^`ngRs9IoI=zXp?4s5NP~-<>x^gXu(LKCz+=cO5a6x@#82DcUp%9 z@jmZ0euVr+7o1P^pIivZ(txVds>tVtaSc4JF~;H5;*SB-&@uSR9EF4VzDom)iKVXA9{6Wh{<=Gunzt(ITu6W; z2;hpXwH{hp-GRlNTIGe!n{c}I5MgxGc8S(9_?0fCmVGMxzYgL5>Wu%sQ^Bsscf0rY z|7n>*h!D*8TR}s6I(ZQLSMSgH=&GWw?EjF9yQcp=mb-@kA3Px}h4xi7d^K$U=f$54 z`|xurQjUs0VFyS3`4Kjb{`V!I`g#dn=ck!i{_o$vf|h>&ZFpWk(*MAUu%A?~Q4%Vd zQfKY|JkS5mlJWHlWPX}Y`UpD$-pA?Y|5sgf&W0TovQb~Ari12yinv*$@sT|Xi((&U zn>3=q-ZqZSqW}NH*$co^SF_KCRr>7}SsPbkEHQ6S8+-jLBF(UuS=sL)EVZAlus13& zICdZVG!nFvh0(}0f&ksdU#r|i?f97oG=Y)8g;vS|z|QO^8{p%1KOb@FM} zM!R+AJ$xT*TMk`J3RV42wNK2_4N66Y2@#zB;cN}hHKm=OJhqUi_Q#ON9W~s^V z1D109(ny&7{-$vuEe)A1yJ6eg@_8TGTQ=5y!#5IQ#=J94IeisginZ|DkTAgVp8mo&5;blArKn6tU~JTMaq;=j-w_@kw%;Dvfxy;#s)-i*v&z+0YkHP8n=v1^}c) zBoJA*T1HJ*o`$>;UP*YBx2=Fudc?+MJx-t88;^l!O=yPW7Eaxz4^6}GoL?}i~4XOM-!4D zkD%yH!k$*vMciCRrm&aQg&XHq7VLKMN#^-sWavvH8;W4U#rsS(Zypz zOX*_c4N{l=E0!{>p!&+&Be>pnC<&;YhIpQ!;FOF`rYT9gdCduPXH=_J6nBKP^!8c!|=(%MoyxbOx z-NOaR^~Mq;7cGi&+B?-z$IJ*eY#HDrd`1Kbx!eqlMAn!c2{>vZ%>Ar+|L242*1olg z5zz_cJkz>&5mBR6q%wNJ&7Vycl^7v<&Gq8(PiEhr`I*0uyOrTzV1!w%4~$Ti?RPqu znSGt_8?paeag1dL7+pLkV>#;dE%|O%cdfOI@diCD9SmlkI2`EAoK?bMSrRY@UeJ?# zaraeWT>$&<@OYMLV`*<8&Kd`SA>#S7cUX@$iM8@=DTZHWXG=1zt695zSPI6eGMK*&c!Y( zMB#{+1ddD$-Y$54Bs6ziJL^pNP^OCHD0_>BXCkl++srsvcD5U(h>i_b}>U4VN+lWQjrdD46#TsV)mwh$=&Z)L7 z$4$>GPaw;GbwsD&m6s#qW{lr^xg?b*2AjcXo3ie2?QToPBaKeYRrz;I;l4Kr^F8yO z#OA~%WBD?zZ$NL(=?Y`2giaDO{J!?lBJzIYO+y*>Bj zzjzH$y~1so8^7~{T16_ zEF+O7wm0~a@&T6b^JG`si*p@e{E{^^I7~KUk7#bb{i?9Nw#L;{JYcKQX7IMQwo1VH z;!3FTuUf9B0}R0w8}W8(uWDK=$Q&vE_1=AdYTxeKEjH4oHlm2q^#fC> z!3LBBlj@iUzj^uCV#d-6F+1J-JwN>YVJO-=h2J3TqdGwoESQyI!~75^hee^;Y2E5H z`juhi@J{)Qtj7KH5#$qtSHN(@I-f#KR?BTz%m+_bRAeMF^sT%@@PtVn|Dbg)@!w^k zIuTLQJc`uz&)W{UZKq+sMX=C1AES42^!A@_kL9DX&!pzR5r`PT+WhD-SKYqonfRZx ze0l*g8jQ&na~|-@x;{pj%W9a``^)ZEFmDu`eof^X{0r{7juCbzW{>4=Zq<7}t6kIB zmPeo_<*~2@wyTMk6mNRo!f-u)HH7yjsr)|$IPNH7w7JHls)li^xfzI_YDoKFXx|q^ zj&j@W;-?R#_7vkvCU6_1*=K0-^^E9+<73#>;=)e`_=9JE*YwfXxwsfECFma39}BUD z{i45cn7Z3sbpE~g^0U;vKUeDutj_q;cD@*6U+CK1_E@{8=YWX03PfK&D;PdYW6yc; zS0Z9LAZ{3I98LyI2mWlqc2+|KkV1!sw&~dZw6)s~)hUo9&ZEbVjrL}s?j{G)Sg|}o zj$8&NWeZa8MK$_*7hKLW)<#Z;Z}xVG)BRCC7NEKeK1&^(6-3sM0S z+TU1gbyEn>!XB`v|JwV&YkSLd{pk|p4!;cYf6*Vo^?S#HERyoDZh!KzJ(~)nw`;kA zT_~Tq((x?)hEsOfTz0Yk!=APQ(&SSNQGkl;w?F14B*jdeGyxW{cqLKUQ>U@;uGfL^ z$!VX_{MRGyQQlP^jP@3XYHBN@#rbIl$kRi#s{M6D!l@C-@>AV5?^yW1ETZq-N;E>F z9VP+trD~^~HZQ5H{l)<#0$oKaZ;i>MMVvRNp?9r6(Ka_iZY>>pqp*r%uP)LmZu;B2 zS)e@yuBML*CoAKN_x)NUNq=_i8Ub{re@APJDtt5oQNi07XN~QwG)E9&kNxo#!Sc)k z_X>eD3!#4GvJe=yUt>O4+~;^!-hE^LU2e5WVg^sDq$&Szm!AqV4g9RctyRkDL-e=} zHt6VAOpjk+Op~$v#j#_NdgGFzk+MDj1)O^p=)6U_q=&6nQ15M2E+UrPCvY?B&o4EV zbd{EqrYT1_1TP7~#!`srS0@U;I(it+h()Ck4Kq1{JXYX1X;7K{Mk^HeozjG9@YR+Y zQ0h9mb7LEpt=)(=FGqIK}z! zEZfB0PL_uLc^H=WivG&>fh1p?HOSlWnYKJ1gYK0JTPxqT9t&6`+60{Z>F$_PiQ^tD z1e0=_6>mQ@N=*5$4KCoLi_;M8Jw>H!3sAX_YP37OTQJ4elVt8A%YLDXdU!d1d>Hhj z6~1N_L6ns}Bdg0gg(`AG4o zP=k=em|fV+CPt4CJL`E}`jVa~O)zaS<>KFLJis&5n5jq(;_&0k%RGQ$zj5bbr|Q?w zrtRmxZs|=Cy}yS%o)+%c<_|FCxz2BI?9J-c%uR6d4zFp{BLF3nq=(d5n9j2}j>1@c z_Irk(&aErmCpIil)NvcEh05a!sHWGBdDxZRJyGSbGP zkl7q%Gd*auHOPOK4si+`A58j?0`YyEL}cQBIGN!h$Uma1+u;)szqGm@_#4*CHsT|t zg5B@3ocQoz>_n$G&pOJXo_G1pJ>a|l+K+`V%Fce(03Zyg*u~Sa816+;U(+sl3FDGk z%<_C5^z*_9aPByhK=_U&!1GZyzT{w5nvb;hp4$!7S}ckyPMaHX#t-kH!^3 zuo-%tG4+^*uF5{RnQES}631QU7?qz^a6!@_=;5)hB*?m9nj~L5n=rQy*?)0U@Vo^(SFquv;ku5A-b??SkKT)qcZ@h9{W_Ti6gbnv8 zfY0->e>+UCeUluLX>TunfpPzpw5z|JK`AXD3!4D~$CwW+%Xpd#OmFVfhJBF+bNJf{ zV7~DX0Jvg#JRitkoKnYb^V!`}If^G#>ZvOk%ULycl3#-8>E-E)<&|-lX+^xY%N_K2 z^p^Nl+9Y8DcbmVi^1CcdmI5E~J){c;_NVfADxNP5M-lq?LVn4(6C4#=1Rw$qNoOBl z3(3~T6jg340K?hF=$2i9>^eb2|3ba8CKr?F17G}m97nopMDr*Z@K*{JYrfVk-p~s~ zyGZ#z$$N_#iT>96ax?nS@f2LA3?~}(v=a!?ssW31pXHdw{k|Qw#KM4{THJPPBdUvo zT8{*l13vORzSx|I0~&r*dYn;N7L}HuOiGZ=fxD2dO)Po2dg>LkmQO~8t&SI8au)3b zc-);Cd0?$36*(AtOCq_hm(~9)gTY|Qs1Ryd9OdUR=MHlJyGL81Kg0h}O?^7tN00g24^+!{ZkD>{br;@YSiyy-G z;S)(eKH(SqczO8Hn1&*9|11eK?8gU-J1#$dlp}GNv1{x%cLArL$fYlRS@%A~xme&a zi{KR-ZD>M^Nsu5i%DIN3-prL3N5_H7`sfAsI@cmkopmRv%CjDBc4v!+HyQ-{(tDba z!5Mum*h?KT0ls?3B0IvKS*`B0H~Yjc5a8mA*Ifl7hA>@iq2IvvZ>Xr2wS*SA*>Ln4 zy!X2w0})WkmiLWf_mCNX&8yqRJ6W6dmxx63!6Oq#Dz6@CU|$7cLuY^7^Mp6cU~7=? z!_$_&$00D(yKFh#@6o|w60kR6Y#F3)8DQ$ZvS|Tt_3MLE?v619NoEZN7HWnWW-FDZ zDj{M0=jWkQET9Zj-l16^cu@SIyal;`KSx~XK@+9j|DR*3YmG?YPCXY;^!lyWA9Nq* z8v1Pp+q$vN_AN^OA#CU77EbzatTX%{@8XN@CKd7%JF^&pz8+eQNH}wU@OJ7oKYk^k z68`u;CW(O|??fz|0!N;y$qrkkv@*cVEfUFvnokb3aAQ*j_gaC$q~vL%j`%(Dkx>2? zs3+0yEHxdUEhFjifw_RDJz=+N5U=O9pQ|t`k-9nmDqdQVCJF^|%-}7Gvw45^QBVE8 z@OptxJKdWFO?HJ`Oyf{i!@*mI*)(rQI#yO?d|Q>QO)aIT7Ej-YQ^P^Er8k&pO^HzR0RpdeS=s@TXAC9yQQRd z=BWv;bFAn|f}%No4+%@46^QaZ`P8C~Q95!-6XSd3{7?NtHe~N|Yy14EtI{_X;jD6F zCR-tkp<5z!b}#+=)iSmOD?9>G^E@Ph7*n|m3?Jz2xm>pw_tQv}kJH&*_CJEnq_|e6 zcsYsXMqM@LLqnfUb3r{7@hVl;q8AP^*_>=j2&K-RMstWQ$K&>%$2)@noZO(LC#|Tn zAHKDoa2Ea11cc@p4tX^WspM)GmzB#rp4L~PWGCzr#9op!@>~jX-KB-$#F=mc02*wS zpdVA68HA@mvwWX8@1xUx$fZdrZKyF^d%YW;>__$YgqZ{rcQbt6X+Ooy`klDm%BKaA zd^ACuU~ej><*S3IH_E$NTQ02|bX#m++Vho-W};5Y+5cVK%&ZmqlvhpaIMla?`RI<4C#c0kQ(if+&jv#@>eniH||v zLV>GZljS}=8suE{L5f=H{c2XEwj+^gA{{ROYSs4|D?W#Zx%ARJ5Xt2{wEHc6+HV&; z&p^uX0-&ib6SFs0ej(h^uFv~>kL>y=wC!E2+8OVRx+Qkya?jAVhP@K-e!_cupeBoe zDXWeJuN^Qg&JRx!`8E#ddcPY`Mt4nSu=KnevoAjZgz9+p*;R7Jtmgqx zS2ZG6m<8I|I;Gs{252Uqi}iAFu?WkesJzh5ET*Apwf)^)y{C)jz>-1& zG7Bs9k{FT|fd(#4f+!KX!Org(Y_L4_9*KZ4t}PWSthw3H+vwq$6joKnu&cyE`P7fC zDg0aO7$0!8(9FSZ=gxkcXX?X@y6#C-@;>e!62yg{Xu}S54L@O#yvaO>g_q*Mi+jsd zl?NY%bSIOo>>+~`)z2z_Hj#M|MSGf)>}^KACLy*nx1TC=QWgL8NyF9($A?z3Dx8;P zIJDs!TcWKYeP>YCItkaZDk-06Oh`>+ptHsky++i9bF%>V zzgiNuxOc)V+@eCNd+w1bL05wdWdj2 z_n^P_CwT;b4kXLkYt8xE-088W46v_ zy2`X8$r?bQN2UcGMMO}^6>a(=;B4|!^splK?j%9pk0S>Rse?>wUb_|YnS*`{G6-+JNfC$&5 z_4bOP58FSzdtHsy0eS$t0POG>N|!wADt4c(3Ea!&@LFfL$KZU^rpE@(9_!Sz{9sE$ zK=#YV;6hYj=bSKo{((?+_BCdSY3A1Ib#n1%& zzg1ccqwynjC56^u-uJBtQQ~Qrfa`ZQVCWNdks2FQ57VC49`VlSyMl2poZT$3H~I5qx1+Q+EOYAJpUt& zes%nHfr_;!=9zU5p4?il`{i!WGm`QXKM7)q>ko}-^~uj$EhRVWGSyU(Ni7^mAzwuR z@Ss~uX6S|qn)~~=Vr|oi^P4d7W{5<(2p-S@BH45ZkB^y0`F!UL5?;@ z>?(i2HB`33eamOww4H90Onqwy5p}o3JGtuFT8Vc-?VF#c>t)~9k6DYWpCO+=I-7dy ze*JslrgpMF<{sa~8i_CFc+A6PmA`tSH1$RS=wL?AwJe8pBq1^!sbMZ<#`L&)-=a(} zm10V{M#Zqc#%dyz^Wt$9+mk5kDB?3!tx29BS{b+A%yCh0i&QMv)iqGm!ouzH1^zC| zR|^uwNt#X<4uyYk~!DYnh9 z5Qavm^{Eq{R;E;4P?oP+c=IB&Ptp$q#c!=kiVy+C%*9xwlfDWzk%*1j&n4sUSe)^K6K(d&B~~eXMOuMqgY0Z(z3a1Z}EOH zu_+^Y1$*=gqh?4t?8C3f8Cwj(Ud-=9Ui$X#_|wQC^?BT8Y_cyvb}C_CkH}n=K|dE+ zS_}Zr=R$9URr(+2H^e4}ZZ6pI!Otzl6u76~b*<`Zp?Csvapx4lEZr6*;u+p&`!ceW zDC)F7dxZHbUWZPjDI6I*N_h;=&oS|b_kHBS2z>?12OYq%a z)eD}0&+Xv}RM7iJf(gW^2y>p!V!Cdb#sY=Mv=5!_3Z~T*;vNQfKlwUs_pz_-#z!4% zB?A)9sj_{bVCbrpVtl^nif5kROJq$R5+TwzGdLaE%(@;gl{HaZU*U_E8X=kPo2VQY zugh<%-9g_2fk;5=yyN@F_$ssq=d$0wM7CDfrgb?w+P;wNJpS7C%9r#T1gz@&0t2iA zJqUE@XOP-J?<`#=Wm;|K+$y3T=Uf%#W8&!D!41t4nhb;(2+RJDzoeD+;dkB`I(4}Z z{n%6E0C~~@l)<;7@2EafqRRPSA8weyqd=;5@8V%i$!qXSdV^vDK5Oheb)$*e3tXu_BgqB|$Vl3mY^<;%n~O z{+n+YU*{Xk^Mmu_D6NPJqvG)6Nf49_#nY>EC~xz73oD zuw(2Gx_|rTK|T`tW7SVX{n1`i5Q!o2@8`EKJ)2J>C_T!@{2K)nIN*yUtWMN6ntEQ8 zR(t9t0>mEFHE&F0eClxlrRz0NpYk!JTD^~i?+Xf-O%$Dpys%(kE{)RhNld&NLMxa@ zI`YviCPa~opZe}3R&y=ib-d$o$WW=rn%6%O1&f;L-8%#!C>VW^V1#nXc$vPaiI&@} zzrQR6k9yrvHG4oD$SvoEfsz#9Qjlbt%L|`~tQ}9P9(28oKWM-e5tzNMzTLwmc2NC< zwhPxO_|oeqRcxx4Ya<@Rrpmsh;`(tJ7d3z+M?HW zdE1c`Bgv+loF=PtGpXcilUr*A%jMKjvSh?00-N5pqdCQmzPr=MJwb zg3us^g2ppRZwT=jKVwe3^*}5wjxmKTjfvm3r@&K>$j4Jr6n;?DpLKOTm9>!(7ChKw z-yc0St3Kp2OXt)Sj*|4yKBufft7aO-(w_0ncoC=~)wPYrz;~x(F^hopr&mPhY`@SX zLFFm9s0rmG+ZKcQ@g$(XaP*~{PY^H%fy!Osi`Wh*+QY2((U=KrW(&wZix<-mVA2rn z+Z^5hsZmo;8-An%;OErZ~6%9t2N#JaBS$QESCBc z2sepl((mf(z33|MdD3>H!(%hb+MFf*tKE8Rh2;Trut`iaPB>iS_}a^-@}3Kzgu7hU zT?^0e_EqSBj~cp+=^#I$yVJWor#)K+40ey_u(P;9@PFQkb_PAzw!kA2Bp?;_S6;H1 z@ye?Zm)cfq&_Ou7Z=-S8qV2Hm0gh zK~vfjNA1K*lx^~Pm`Vi3ga2|B*YK?7B!tN-9?8rVh9gv_Bohp77tHTb$@}SETF@)m z!Poi|q$H6mk$+=Hh_0H@JRrJ2L{;o9%GKDrA}|*+!O@}#tQ)bJm9wowDiQVRTWJ9G zsVyAYkyej;Ek!M^HcjqAlPu+k05DXVfej1jhzAN4BBVp9`Oh zsv}~3n;-5v?Z!msHMB7i>>WlSByfI62G~lu4EwBDhEk7Rl z25tG3oUanISSbG7Om--73M~&==#|WSjGaZqaJ&GIsmVEJ{xrUhZ{2!-KnsOD2m<{8F)C`p6N$^ z=D`}j4d~s4es6>=?VVB_w8I@|-Xdy|bOJu(%H+_lf0I7gQocqPu2AjNT_1iR4;%*N zgQ$BAd#inf_)r9&cCX#;3DiDn{Anz?Mt28uQHCWypNu)Z^$FicDT!m9g)Q9()5G{n zu7Q1;T?I7{jPaZrX)hS}!x2f{?8GYp(i?!mV&Y866MWRqs$&Y@)_ReP)9&Fq;Vyup z{@2+X7Pgn=$7uMgSpz)sOImw3q4HFE>dw7nX>iC>SK(pvKF7GoM96`Uo20Ic>GEA{ z9ANmcF%&!9+D>HEi-_!77lZ86r{8I}z0(_bS9#icz+TDk!Jqe(B=2NqVuq6})}`%Vk62eXJ}gVu_O%R1Ut=iP|vcRToAibx)$y>{-`D4mmr`Dvn`h#qa$+B{Y_@i&HpxOYxy3iQi|44e`BM zct0PaPDJ)nq6b_lsFM_lM<={#`mX-y1ac5ihGq+>)?mBe=fs#Ng~O1{pK>M-vIWwY zAI(Z5%SIzCM<4~T$Kc)-J{#UHxh=^B$E^>jR~r%nF!DJeRWu)O4Un$RBU z7J>EAG@uKXgLCdc;77s%nK@i?Py;~NE~Z(>S1S@;%U@-q(X`AQOA(C~p;)p^I~eoG zHNVkTbEAbE4P2Ks*C@rFTLe@fm|%JZ2&Qt+K(SOMQi8cMs{o>Z)e3t zEs~Xmzu%|N|JU0?L2ACGnWh?fD1~Y&%qw2A{Jk1=+$`?*BS1S)Py_%Ca`T`Kzba#H z4u3)d>(Ix;i?I*aHv=r$S!;PZS;f}4$V_qr;cn!d*ueQgKFD4JE!THc#`=cuMkj#_0f0Yl&|ds@(i7uk{j3{BA#?q+JfHbk#G#5N?A@e9F%3uw zW%U_0xROWjTzqtOB^V_fK-8-U@G4RbL&WUu>|JTaXeG2LGCOsD8%~00Tz1}I1Y6#$ z)B&Vk-n2!By-f(IIF00_BY2-(jfT^iP%>K+;6E}Ji|_`u)%7*jL6*K|pIa>s2J?m_ z2Q9kxX6TvrFqS1>r-K7`4S}``Gse=#K}2 zm-HYX!^rh1Tq7g^6X6rq?-3X9v@X5vX{AUSLCA|jB3aW3ErTB790BqPA7|W!dyn0F zXry^D4s{eA7@9nwIIY&vf8IS1pNv#9GV}J>N#mTN7(oG7BR5-0Y5aa(-Hj?U21OdY zX^Ob(%qW3tC}{;9=CvdaxGf}julXrn1L0Fij-~G1KbZAs56W;8C!~-GM?iTTiLbH) z!b$F8$GS4aPuOA0Gv3q7kDV!HkbmW#L$l{b&?&+|c%Mi_{Q>3V6=)^Ax8!Cf`riM+~fQY%GFPpGA~A6jg$EZiY|53^!$+ znB%*{IGwC6-zIG|D-7yQX$FGE9y&qRwk#f3B8r%{!A4^#pwE^q`zgRnwJYX!B6UU6 zIUbC|pxZgpOkHgZ-984c=Xqc*_u01ce@}4q>l0jptPt*~(42b!1lq%6?(h5z+VN+L zW_LYY?yJ-Nr@ZMHJp<=9T@QquWc@hV|5Ac|I=y+Yz#+neU;ypZF4BCQ&n|#%Wp}YW z9iRJO@H0C0rKcBD~2lS+yeRdn&~( zOdDU689#ae1lgGY4Bp{DTSv$eew3^gOB43ZNg;R8BW_nCR6hZbpdSf*>;3v}B2&=y zj41iZo}{rn^6rImQOmVY5c5}^(Fo@M3O(sEz3ZOKjiGbKj8)q-eMgH(fPB0ta@Z;| zIeREo;Ec%1$!DMfSDG4yuclTJ+HrR_t*8rWfWE!Vwn_CEjp=?wV#J}v+_-{+gQF(? z1dPBf#e%P1*J7eF$wlRTQPm@L5ZoiCioA&ZSpqtp{p|t~2c&eulK+1pn6`!=f}m|< zbCOnwtH2Bh@ia2G#MRrW^shYVhP<v6fXn`P>Q=2*Wzx)rNy1%?gaNBK~8wT zd+z;l|747e4SVeD$L3mV&bhD;>;9=RDO-?9o|J@|zfmDsE6lin0qB{<;XZ{zMPfIF{5?@qBtLA z_5ReApiSl2mvPZnaswrB2gps)-;pb@mE@l;#usPbYo#DZpvGFsJId8*w(BfeClu|B ziL5%bl$TWY&TB8OamDYlbZx?5@0lm~-k2vHKR@^{E zBT705edl~x#y$o9O*}C~j?eXdOafleHJQN9!09BbqXP2w8|t+~vOF?W0I*MxZL2T| zMcUj3;9rg4qnb8;-!CHjpa+5E2Bd$|bWTjtxeLB)j4JVN03fYIi;Quy-DZXpZm)8F zHj6ICeq$B^^2C05P{<=L??lF6r)f?QgVQO8f>CQFUr{bYeO>q1Vn9oGYFT24_vV9a zZ>e%W7Rd8BJoIm<{e$n^OYGvlZsuZgB#@;z5|*5)hE|8u$PE&Jj7xW5)#viEhIyZl z+t*+4C{}3m|2a*gQB3jZ%%u#{Mvuf_fJ^--Cl7loE>D(ph{2sOf%$O2foq=lC2&4o zwvze#d8YD7@US5gG7+^j)}1DV5B|pY{3>P%EvAdI9}*yK|Yv+O+gQ zyTYF%cP5f@h$%`8AM<`VM4?vWUz=qU?EE5#0z;LSrZD?FV#J1{2EzCBz)4EK3}A_~ zF@FG%?^DEFH#s?LE&y>klD5+GwZ+XIM3g*UDi%96FGLzy9f}ZDyv8`8qi>|H zUkK0%P(%W$%F+U!`5=IE*dP$4J2+Cti6RNqU);;|P8-KB1me0hp_@+oBK!XcKaI2gnZvZ^ysd_C zOR|uTrf(>8cZ8lvQUMl_Au0Yi--D*7-f=2E+J@SQ3ro~BMEqNl zW7D{fjPz%i)pU}Z!22Le;9At;5|*WgE3wHW+9WrP7Xs|XpOZq13;U}@{PG8?`LZx< z_S%xUd`55%bVO^KSM0l@tAO)%Ss#wetB!6ZN!Risq#%;D+ zBXfLQ=eGE>u?&571M#oI13^?$86YNk(lSpUY+~}8UEhO?>dkmwe2~GQw84e(K?Vq$ zI)y(X`bU(gco1MZ?#2e1U`K5JkyZCe-DEj+g}gpe{Ai5L$}tEfT&A; zvsGHV0w6g~4(NUg8Dt5JH)d_+9c>ukX>!r;6 zrk0$beesi*5}>23_8 zzIZ_vP~rPEN;{vCq@jhiX)6kQt8S9odEwwgIDIuyzOXo%#s)12omF4I&~E;qAmbgV zQ$sr%(iRg)xDkVk!z%e3vJ)kf&p5|#kjn7+AP^G+e+@gnyuU>|5c;d{{GqrEnI(m$ zFGZMLh9rVVaZhyg>?hN}z-o?Ob-eI`9XsFSOk|vp`%kTw|T`e5+^(0HO zbZc&G>^ItR9Y`dAd~wTY!cYCXCxA|h!>1-Me@}wOC?<*~(Y(*%k0@56nQ2FN^2|?( zK&LKuD1pLjeA<*eX$EpO&ZB<0%`W1ux%^GkEJ+GjfJc|DG)qJN84{$wJ%j!#KKG zpgdw}6wN~^RRV#g&3`WL6^tJTZ@cDyvpGZ+@p*gTF+Jv{JF2W}q^CA2D3!7yeCsF*XUG#>k^$v@!1?7tzeh4!Ic z=N-+o>9+UOyS4roY~ok#WOlS_JW>|{6{XGI0~vTfV42!4yA>em2f-2K95WMCbg-y- z&EMz(k0El{%vMpETyCA;M2@4rX}OkUUm!RTdMwtPQCovK7kPZyZa#baP!V z7GXF@AtS%Ad>;?bC*v$AGG8fPl{)IT)6kNao7mSzGet$A_yKt`O+)P58L#|DF!9%v z+@d#;p;yt2mw(a|0x6=k9L=!R3|;psoCu%Z=vkvGp0pHSw6A1{b&Gl*FJkBAz zk2yK3lyux2TOXjJ0Pv%Ph_cszyT5;4KpmrZ-~R(sX~_il z?Y?0x#12^lS3E4Q9z7ME&)FAU_i{~^^+r9kWk!PmNVWx761~7|d1XeO367rgOtVKz z2z7`FTGn0+0D(oAo?+TD%{|fC!(+PLJ^S^a5PVeqO zdb3q0?@GAX$@5nlvs1!nAoM{C>yD=8y3o2M6j3M5~R?2tD+7caG!z^?gMF?{u z?>^D^M7QkM$y*_7!I>#0YEU4RQU_mVnbyx}2r_e?tHwc4kgc&*K3xTWqMv$B9}8%< z%3~#scm(;!B^TSzAqLvWGAg`7S2{&Z_9b+4i$W2%cZ1>oXbmC0b~j};ZYY*zpBjk~ z9T_{NcBhyQBayPV+9Y6*Hs!AYs#fn)xE>c{0GtC@K>2h;)vNGr1nsLoL#KB~R&E7cGAgi9|O-&sBy`6r;93a^a1_3IUs#Ca+Vi z?Ej!&a%i4>-lWscRJ2wd0jvJ#yaNJpeOEOQMd&-LV&2H0wckDMISZ8$6Lg~If$3&t zT7rniubnqM=!)+tl0hYM*AuK6MCGY4rg!h~dFDk=G8ps86w@CR^X~nz1L3a<)?*%C zQ0rutcgLtR?Yekwy}+Mi8{4lwau;#_S_+|M`{pQuKkHU5Z5~8#3y=KcXpe z6r6E-CD$bHFY*-$?RZmT;R&z*(b2)RW=fn!N-&TJJ5zbeCdi7G9G;21KW{j31~h`2m5Db1%+udM4ZOT|_`;Pb0E&q;pB!^{Q^=6;U1`#a zdfTf@G@zaZ6gPe=NQV7HYdDbDztx)qJ*9G+Gswd z+Yz$Gc#kEtl3L(czQ-NF#BOsYc0$oVMD`J*AH1Juy(zNBcL&GH*^&UibD?3T5cRMs-usu} zzr$e?Mq;}41ax~0mn1>U2~_sW$jI?pxL|2Gsi+RLbIOw}^?C{1rND@XtqUYzku1L6 zx(s5&{AK=T=JN-Xaqmyh>rFNO85w`d^}dp!rlziZJQsYh;!_056$V1MMt+@qY&vsd zU<0MuU8>4h%KKJh$YIGDk9FLxXq}lz&MD^IYzO9q_^szshHW@R!y47q`MW*a{K%W7 zh>cC#y}=67aEbaeUiJ^o{}hgl*m1QpQU8Y2_F-D{$pnxqMpfou3ujYELl~p!JJ)UX zHP`UBJ|Udw3kHhL(g|eY1)WQC8~obL`bfm{QK4S4n^&bVQLQ2qUls5IBk$d#ft}Sa zn_kk({P|Fw;-r~3)fxF9>m~(1eaKydC&1Y{usc}gvF<}zUEFZS?>~d8-oG+qbw{HY z47kKpWGHDE6V}?&ys}nK3!tH4l$FdW!jKnd@%%Yt`YmVJ15So~Eb_DiR<_ziwA!N; z-_N$J@;+|qh?uAXv3)JT&#H~F{fjTgd|OI8#1jxvPHR0PAHH?#luJ$hF@x2nHxFxk z+|%WhuV>XO*f(+GJu;T6*2=Hy+!#(@Ur(sNQL^#`!;7epRuea9Sx&cX-k;N$p+Ssa zH{^mXyWs5&H5-5KRe!w(#e?o>}Zdo zDLEN)Z(Ja-?`V9mjV?ep8dKKnxYRi)f*tH${ZS~A=N^H6jhEE7ulmkwNKIdriLX!t=U-W3f6SV9$Jh>7L_uk~9v6(B@ z(G#Ax8DW~1?ls(tT5SY%^Qv&TW95yC5jnb~lLkI`8&JLP{IT1(s=a#9vfH%kGWfRq zF7L9|9pK+;e63}L_HB=Pxn5`HvI#1(7HG{$aM@qd9+g>xcBj$tBMr}WT)T<+1YK+( zeNSX|I?DGmnRJ|P$>ze2MrGcKbUwB4@lU>t5Q1PPJM5j4?=K$q|I`C0i=!sFjTa4c z^NkB-y&e}*r94;n<4Gf?#r+j`jzo5TOkew_8jH{2Vx@~=~?cqE}rS>5Sg6FAGQBjetn)tktg# zUawaRmLgs}pcpJCS>j){kyknD#W?9Fu>-N_u$1s7t%h8svA=t6xm}=vJ~<~>@A$mj zQFS?5%St>@>*);KnhS$8AiTSzNx~d_OAkVGiGDI5q^jf9Dn#lXtog{nk`{ zq;l|%V@Gy5csH3-_iEYw_OtJs>sdU5tJ#W~Qa6*=<{FFY>D~`FMiQja&?S!pQ{Inm zhLDG@mXJ3c^pxu8*jc1MVLq1}< zPfH0&l^G!s3n?!D{6l5*1GSkFb)uqwA&Y@sivO~CEZzAV+X8yoO<#Bg*LB!q)R*vF1VF420 zqa0S9mvM!43;-RXYc1hi-mSZxeq7Jd8r(XH29-HUNV`iukz%_Xp2Anc`qOcL_=_{o zsIoR~r{TXUEgGhM1*CJ4E-dmm&i4%m+@VdeQR=%X0m;)htfnZcNvXQaFE0RKkbdB7 zfji{hwHa*UrAC@=t4dqXXDHcEdN=9RIeGbG7h^>Rh|2vEG5ybepwpU}WM#Lvm!9lY z+c9t7nv4{b!UbV`K2y90cAS*(R-uDC0qgX7<6ywdZ+DJ^N3UM_KCImP88*-$oKAzj zn~N#WhT`#!TT1$AVC*|Cq5nurBeF<12&0iQSw+P@qtmHKzkF3%l33(-Vqf)Jv=$O5 zS!S;)iiJL9g?BqIR3l|y9elp3{b+MNHMYMm`M~o^A0zkHS19UyexGvR*T^#z64>s< zFfD|C+o%7VLlcYTRmjdvEd0(LbS;k7KSSOD_3?f4z%2}Yzxj$3v}>MMqr##AG+Y+Lkzb zb1^1$f<=+N@ ze}Lcxvf$-t3nR|XIGGFJ(xcb8fD-x%#J@~QPFE4nX=7s~!jC`Lw4dd$6);HT z`SZ={T)3)1OB|GG>jMqV@HEJX4fFF(U~0hh^-%pw-#&?q0F_eWNyOeLaco zdoWd9fctkzK3s(ZD=6W|um0qXfNOEd+I&6XC$ROT%?xa%HR?Fc=$V|05TJYn_&1ua z!EE7mGZlV@S*>T4G$VUv%jhO=v)a!Th1BQ16S5xsX73O9$u^g#;J*gxm~L2MrqcSS z^IR~aq(hLY<^c3x4w(>0mJ+Pu^5FGqjaBXnAPF9I+U|cVvJ{oj!W~2?vL8mT zohw}2B$KMQMT@RFRIAJ+YQzjtuho7vj>tPcCSbnADQ+IwAUzoM<;&&JWUAghY?9122 z2Z5NTDLAW<@w z?=1X(7f|*x6XZ>$l3qPL*khj0F(%SE97?=xo?mjc` zXcunXH`DkV+R%u!##we^0V_|6x|3Z@Vhy$$46WE6C!4QL*w9*f7Io`a=I$#adU)g< zwGoBFIF(=ZF(1w=pV(61g1CmB@4&ug?y* zKl2aXcP#jt%2g@jIu`QQzD)QG=F7B1sq?$Rg?qZho`}7-ANfj&cw72R{v!nVRh3`b z3W(Gi*!$+38CvXMC%b0fsts#4g3MHw?G}u7@{`LEfs3yXvyZJo3@K);LF1Q(iiV*M zkDlsj-$ZyiKu+zoi~XCv`=gK2lpt>ruN2uwcmBS8hYY6}O%Wg)5_6;;1Ff^c&v@5N zvs+6Y+77sTgl5*=Dzl>8^?t*b`hzHmlHH^>4T*=P$#dLR6Oi5A7sM!-A3cv`{m_ov zleG&niv92{LLFiEyX~M@#)+IIwKDx_Q~{gm23EAeTPD!{H7c@}=7Pe{o5+t|in?uC zBg8W-s;-f+x~lz%w&Kpz0l8g1fe^7LBzI_V7}u1gK3;b3N4?|2`iAs<{sZs6xYcIej^ZI- zo#<`$`gDdt%d?t*!?e8yLh3mCTQs`%e|*%W|JK$wB2iJ%m4L$bM@4rul$jk2=f?xp zg{Gsn+=!eOigd_@h~vbhUC&_hw?0SkA~6K=NvkA6@QWt{@%!dR(49oXa`S$z>=+rH zHER$@)y*wwNx^GfT`sv>cN(JGDPFtf^@AM*eGTKwPrr^kom}ahnf8S1vI}EVYQGEZ z|E-*vgw7odjISXu%B4n8-@m5QPzf}hR4$jL8KY<6i*t#Zr2Gvr$_MAaVQzoED+wnAVJdy*mAX=+vps@vhNOdQ8$ z^`?TJj|WsoHB+MFuEzvVPi5mfaD6OBZfFFRm@6#Hyo4;(-*=@vM3{rf1yUR0k64Ei{lNdE~W(_)K z>y!uhGhS00wmBa5?o79yI^tq-VxhuNIa(}GF(Z+Y2d0L18qSJe6|UNz1Mq^o0rB{=R$-I9hCDH z1s7l4)%eKtkV(^gHOiB5 zc^Wb~`4@$jWG*1j=fk6l5`@0C3A${!=DHi}FE6@z z_?L+=n9;Y`wtm5d%e(edd+M01p6Zt#_1;49dF%ODTPC>%aJ(~?q~{lzXd&D)$uE?C zcY#Ai%9X~h{a1y|?#zDS)h89(x^_z-8H;%{O>pUD2e`weWD|ET&ueTQt~V>iUC?~f z052^h<$6u`mR$Szb!Qi@1Qs78FD+On-bTV?#NgC;h&-C+xZ@veqHCxGPLrjx41-2Q zJS0xq{?ag{sr{k4vAOXrPKiZ?f)W3Z1i){~eKs!fwy~CJAcUx0yYhH?)qAUMpazopY#dCYB%9KQ=bgnSW4f-_J?R}A2m)Z z%QuT#2y40^oRqAH?d)ZAU0SKf7|U4+>YcwJbqSNJC5JT2%EKju;HuCgdVdExS$h1F z%;)ZXW`UIB%hO*yl>CYZHomXTl$*QQJsUb4D_G2~t2p+r!|sQBc2~M!V7sOcVuRzk zS|j@ylMH;x6?sZ*?n%6bqs&Ry<}g*sBI~ zw>p~6)jTM)OOtm#Kkq9CanH4d#h3H%579ds%JcFN7$r?L(Ne@}%wOh{MLaC14hvWm%a;E{w|}){ON)_wt6529xPVk1^+Yy~^KhsrU(5d{#9j)P2 zK-!~`HkV^fu%&8s0O!=94 z`LcS3lJ)-WN*JXd7uS*|q)V!Ket83}a42sVa=@AW%@X&;uVa6AW;L8Xj^_apF@{wO zyNw3yqYEvYsA6z4r8YF|wAYuR_*1pn$1wAvv8;S79r3O43`;^CF-H!v;XKe*!5=PNQrznrs_O&u>C+1&y7D!@ zOW$9dU5c&umb_RgiO@FjXZWX+F(p+?QiauU(*DIlUosic8-~Jdck6{Gyz3hO8Qi;4 z!#uVl(IpKfo%!Cxp&E%PK%D7kVeMHd>ATd$WbShG5MRpmbUt$~iPJBRi~F0Cp<`s` zB&^l;!|Lz5D8j_bK(fq&lS~VU@+X4#v5P0Sk28rTwh{vt@O~`r&4*J54s6PtQt)uw z9PiJhpSL2kZcPe*tvPt}5%pGj6gF;J(l?&I0>auIr4`d<#kNTv+y~7nl@1o_un_9s zzYSlK3wX7M6eH{c%=2DJM?35zaCDl|#<+u(QVTF6IeK)>UlQ#>Ea2Z7s96_`Cy`NdEZvD?hi0)KZb)w3;m-3&V6#T}{ zhJjO$rN-F^8|R{2^I9m+PZ_V0YFnPH(rhK72G1%Ew#oDV6ano4?lv@I!{6vpS<0!+K7;0qwEuAYE&gR zd%&QhZ4Xu78mJ@~dd3Kgh*}XNIM}W2aMWSwL0}}osKsz#4QY@+cZ(M^RK&?WnY7O& z!86O>Cp=H`<1BUj<|>C5XlR4Dd8eyt)FFbSQ>}ZQ-*!_i=N_@=wL zKE7C?0tDm6rRkbr+=1M26)-EI0&HDzT6ozv->U^?BlxtLPR#uj=Y+>h z>-WyB+aIjc;WIc_VoSAqVkSk;M!c!A93+ajl0Lw;8iu?gWd1-8#wmeOHXB{7)rkbL zU2g>h$v=_5Mn8l4T(g1zAB?^G0_8ni+6z{y!$pxKL&`u@mQ*S5h~b0Ye5Q~x6(aml zTET4fYOX4dNU*{AT9$7Gs$EQn7t-vjBarfOPK)WcvmQ&XJ-}hKj7{}lv@pzR#@RsURiFZ1aIoq1JUmMy7dL&+}eEqn4)RKH#otAGS zF7VW}|7-k?Wi*xa>&JtQ&b|cJlSwD^L+T`}EQZo!&&s(UkVqEo%C#i9hiZ{B9P~DI zBog%Fl@5wTesc5hJG?`|J%)XZ6qn{V2hfK;jd_-nfp_RQ;h@zv6miHWByKDf2WmRY z$>G8m;X9$;%<`MaiZuF=JP`{~*zq(YOs$bY2ryWO@{-2OSL?}M|Xc)2|b(i#ZU`PG0i(onh^2t^=%{JAXcv~z*<>O znNyXb{Cc?ap;*zXC=fUbRnd$}aEjKstUr2Nm?uoX$W((LSlG7ctbV5{@@1 z5dW3$J8UdAEGh%66drR)Vy5kGjN75>EPZ0apl>e3-^fqcxAe`9YF#P=)OHSSZBo*` z`K7a5!Zd}*1$Nqbu?8+!^=DZz3LJYPW z2M_)nyXVv+eDTM2jClhSJP6KW4dxI7VF5k2^{pj2Tpn`(Di8ggSq8+hJUD zUJmH3i@ZUWC-iaJ^uePz6IcETEVQH}aW1zKJe(Y%SE=Z0OH4-jM{7$C#UflMHWlVk z=&LtO&DSMC+~n~thjGk4E8I;J<((wQH}roN!N<#C=QaQyw1up!aOHdm!JZElKFC!b zn{(_M`vGh_P=@whj%wzkW7%#Hz~hxdEa^w7(g>8taov z_=t$^BC_01CEr;rws;AHVI&^vZ=znK9}vwS_`wlnb4rb~yxGGrW z3;U6FMX9Wq-E>K>)eSPvejnJ1iN~Po$ecF73843wQles@TMG%V03)AUpdEVyzkhvs zpOm*;c=v}dnjHc-g(E})Ia{;w1M3KC(ut&1M{Xe^0yfTc6z~1SDb;k;zF#3+br`E& z;oLetGk9x?$%f}4qECb*o#IMEuvo3cmT7K`t9%HLR8e1Q&xmxjiEh=*_3dOJ9 zUu_P9Edd1nN$MG{AA!^wD|^BC`EFjn|lqgv=cTIsb^6uHNT z8l&)s?x_Otx%S>D)#FR?HRISk=jMVZ++q7?qxvwM+rqLZX`U0d z_9S|eK>YfUl@2ZKi~LNWDtFOX)b<0C_`UF6h5$hKdfMCZ|DX7XlFBBLAS1?F*Q@wl zFZYj}Nxr_~JoVwtTN!#@-MUm*Fzg$aG#x?E6%PvQr$L)tGNA9y@K7z7U2X0VHN4a_ z=O+(jftrVv_k$6W<@Hxqa+Zs{uiMS)IQwdzIVURC+20TrK%APf@|sEKyEN)1$l3-q zmhv&%yO!o}9OQdI!rYQDj9f{p*%hX~h@4)}!xo=POKcu2TZNqP8mag*CyJc)7zetp zbGjvBsh)d%Vv#;#>skkSQ=Sh1Y#)!Mc8cFauxYiQLs3r7Cbl%#Xc(=#E zxuW?*8vZi;9J}|>tIW1Xkb^> z)@@?X?T`I5ArLxLdj2G{f7o!d&=-iG}fup z%myHLrFyBq+-+0fT4v)#_2Q-@r}I6DS4zAF+vF0U(Rsz(z%HEWxlPu3W1~!Y)rz^ z3W!HM5kJ^BAm(;?DqQxuq|(^eDD=1U58*>v<&}p*HA#N2^F%H6oi1q2fJRPnRQ#q#|Gu~=cl9PkiNI)T@YiXn&U0!a+wV5cB18uquF1X`nNuBt$2A(;=)(&U(Vc)8m-{D%rT+vf-_p zQ4$6&GumCt81eZ8@N~UeV?~b3?lL3y;r&M+2Hsq1uC@fIVnl<3XGIaj`=8Nfzq(3$ zhsejwUhgYB&?e{rh%)R?@3foGqD62UYv&9hLJWPdAquVdT{hu%tYGKbEA&{e-o;=> zE@E}Gk|upwf*dghz1h*Ib#qf}{ysSoL+JPX#7m`P_F&pH|E`ck^U+4D<8$KWT5+^P zcM_Qb^_KUuH z8~D27?)rq**7;y#*j>Qo?xH}>#C9ZAhr{?cx9BHpAbCr3!-ee;q_ZEY5xcR?)%w9T z{jcL5NWY4^I6F4owpw(E|^G1w@Pzg9!Q||7xs@OGBmK`i<_qO_Y=ikve$i7e`GqW z>}c#?sl5hJA#w;V>P2&!TI`P(C1Qi(P?n2Vj=U(@ez3Ma9rQx?c-KhURd2_un{<>n zyau8O7g}6aK_v5CGp?2#X7UVYkHK*G-;M<<^b7)%64-? zP3`0?sKnzT-{a{Y*De`LCBC8us#OASur(L0A_Vqsm;HYwc7N0IyUo=0}@camc zUj7(=`K7_=W%EO6+VLHletMP;1oBZdh+6{pf={!8I9r#Yf&5P{t80;Pa9F@U);)yC z>2lNayjg9em&;5|-oRCO>Zv-%9p|`KJ7-R&l=huNauJ8^c{&gJ2isne?X4j{?^hFm zTQ@Pe*icjH?G7rrbZr*rx1St{ka3x!yFuK)`+C(eLpO##6MZ5LW#I@jK?$1p&H;#k zFt^w$0ML7U$0@hpNGg$Udjv(wp~>AxhiF+9y?=KFAB6xm<1lAgHf@!126$A{IP;~kxz$)#wB4v>x4DwfFSVLaZ%NOzG0F1XjH~g-#@CkmCog*;*T9%9AGmweQOz%ae=JWXf=>sHV;oE& z?jZycRTB!-+Iy&F#)5lE$)`@d_v-%V?kJ}GY)bR>6djMoIFdr3go4LXZn~|duDU|K zILE~dV;a2l+i6-Bk4aS2R&C-BB||y|zOcZ=LLeb|X1%%QL@3M*j)y(zal50vI~rZf zSLuyLwS9AxC85~{U;~f!IbFAcYZ^-?E7y#jit;FhD;XwphcC2ucf@9+@vgv@78&o> zH|Q+loiaI9@49ZFw^CBqH^OBI;p2n-)h(@=f%DDL$lYTG6cyZ@<-Y|(B>ZqN#tFbd zGJU4M89I@D)bPS`Yf-&-V#tuwuBBfVBHiUi{bO?d6fQu9VD_HHPW}5y^m3yB*mx4=BFsJ}ycy$zRdpI~ zbj%gx;SaQOT-p5vT|taQ($#MP1cxijG&2n<#6q(M5N?$0Wh$!D2An_L`p5HTWe~>t zmfYDD-HcU~%$uV%)yehoym;C=1Szk&ynOR+3LXj_NknbU;o9@qOU{HNexu3Ai{Fnw z$DgjlaNe#yv9giop0l3mqxwDMl@6xt&1GC1K3!j=h51~-KO>`9D*jIPL0P-C4ik=w zmW^~eRkWoxxhvqJ9e^vGywf4>1j5YMEx`Ac7nSTVGVu2!{#;Pwobs5i5Q-~-c zCH22EHQu=}D;*&z6|+vLnBZrw1+F>gE_P`E|W{yn7efp(gL6@?7GGIQj6GOeg6)6Ac&bu=D9G#GTLQVNq{m z8r3Fd$5A*;-Z?{L3^b= z7~C%}?5fcX6@IKD+yF3ksa-TQFC#Fc{G13u0B(1*R{{2|9EDdV)@sh<@E}4D(+Hf) zKP+08$BtaT-En>Z43Lmn8Tyz++A)HnCYTtau|&AhB1KV#ET@WBJF7~%aEK*{y)ndI zr8|Mjh5Pp3Oeq##16Fz<@bEjz`LINQYa@I#mR;}Daxtt#Q7tImE@1Z*P?I; z@B*MHY#{)@X5Qc`amSs(%29FXaSt4YN!QVO7(Vq(%bcyd-m~cgAz%pk<2VpQI9=; z@k>j&9x~E060D^3&nFa&ubfwbCO<3^*I)LHdoNJh)`Dg;RD2+O8^o4x%`t|#iitP| zzrn9A1u~SS#ufiK55^LsdBU{jAmc(zM>10nOpvz;IqdgYDiZWCl)?)!pl3nP1P=R| zugJu4+S|b0OD~v%#kK`gCVuaHXMWQ};TXEPFFPc1BYcu2pJz&R_NG5J@u#*-DjZJ$$_NW+*J`@tY$FGX*_OQTGpVXvU zvDIqXb^L>1_KS%*uL`(4bO2GfH=B`A#21Ct$tDH|6jzfM=(4+Q?!Klce-Z-ez%?}FEDp7TB#D~g71ClBzI|LrKxFPajq}-AV?fX*uZFOxJ57(k@VWs z9OV%N(s6~|ANcdMnpo;M{&IveUO88q-v|hJC4ae8B{~i6l{hpaZ?xH5T~AGsRlXPUA$%qP84o@nypZ+Dj;%>2Npi!x ztM_AqxSMu*?|n&wpg(V6VZ4DgvQU3uFcX8Hp4Im|Omq5O(fw|SC!+1Rx8g+Ls^}Mc zpuuRzS*BJIRHG*_px@<@RyEO7k%ITtzCgmFr_Bsm+IkIyq{PP7kjEESZFDoFW<|Q- zEZ!#JBZj#`LMIpnL*K=OOrxA3A|l6ww!x7BABbWJorVDNx~i4VO~!=3br6y?G4Ejs z^<`%y^I+q+X)p8?Y4FK+aHA{${qfNI_hJ{YHwjH{K0!z(u&>P(zFqfU`LVpMrSDT} zFirShNi;1Fg^c&$U(40+y@gDXQlH%nkBYm?Jt9E0&UD)&818XL1U82q&QI5lNg9>w zS6fE+Z692d zD-4nGF`%AKFhuV^>3V=asU8riuh-MW)PxZIaRvbn`5>LZ3B8g(2pP$N88XH=*K+*h zRS-AIR)+^FhWFEtmKUACRuiMw5NR?b=}-#%-~7D#F-7Gf(}$2d-wU>jF^~7icd2m% z!`Z>;uz7m;ZNz@KQ`jE(4!w;k@IAkg-3BRVYXvuzTmi}OHn${x+FxObtSFYWb|4yV zNPL7p&#P=ylL&dpK$k*Hn(0_MHNFOsf8K5V_-+dlihDGla$(LvZ6J!sOWUJC<6*~X zDv+BT3kN$k76g~hAIGK@A*sA0HNpfrnIJNt)Ga4%PGQl*v460Dey_a<;OA8+pC!Le z`CI&xh==sVGtp`B@$d6^qNDPlu+5px0E~jDx4wr?Ow=u>0^fh>H# zG&nmSyY23NPY_E<9Tmgr8A92~rSeRpcYG22g4F-&-GR3+kP7fzN!7*9dJp!#C00gY zlk3u=5?bhuH4q<^mQ|J>w_l9gJw4nqoYa(kSd{#L22vYMmI&SSD%OzQJ zRK?Nb8OKz8ToM35s`o`%72e$bV1`Z^=0-a<=Z0`sP(=%9^kh|?^d)JS@6?l0#;h_+ z6(iNEz-TWU@;4Q%J_x=T9F(kYdjZLl+b*67l4`>;Uc>>XFA7$o7x9d<%abS-8dnxy z2ly!wV@yQ{ji6aGyQ6}b)iFjgV9e)pVZgJBvXeOE+~26@SQGYUdXK4zduWQp4NfpM z(f&V9WKx9nN_YlCb6@U-xD_&)M>A2tTs~?O8I$2ONzzYTL4bqeRLlesb2tyK6`?#} zXZph+IB02Pzt>o!@5_>!I^WP#@HrM4dMW1!i@y*m(YJ%MJa`b~f;P1kr~*JeH<)@5 zK}OnA|89pS6f=USLc-8hOW{fM895Z^_j)t(^>ABTZC29~LhXxBlXya}#HjDxiEdY6 zwjZ>w74Sw1#eEc^=b~45yMkb~viwtZJ0M$#4L<5@I+?m!^{;x4$WT@F)wSxql*5 zv|dV?&j}$IPP>AiJ;Ac(@m6TO)b9yHdwh~!^ILd=O83l+)cQ+OsShpM*{C@0-Oi2C!YH0i-FFcz9cv zJM>Z1z9-%FDBQbfp;n8{+cCU_Hg29|ds{2#YglVy>Kx+cy`4u8Ur)^pkuLYXJ3em%fp};Uga1VSu&E{5xlow94e>sj zCVizjg&~*Rh&mWHxbOe!;o9>v*{j!(Ume>bdrRx<>3c;>2ij2iaUAd2}vTN6J*rOx`%PWIvGWX^OAE+EQ&Uz4*tScH%YQ==8)-v=q~i0wxHG`vx! z70kh$mZEt%K(tL+tNRaP!B2`5$6Bvwo+_rtr`mtz`%^{p?1eLpUM&I+?4z1FfdGKJ z(VzMNf<5+^#(6ngd3@LU>-hn}Tq%T~I>d;MbQGM>NZwfhY7b+_$56XGna=|+kH4v4 zQ#N>M)Cs%O=3WA&K5tr2G)2zIqfFfew#NV!B~Owcf0MxzF55U;*6lErs!~>pF*@nC zI`MZsRVWla%z`?*GW@RTE(GPRpSMW_Kl$B`^Me3LtC-NWcQS!SMw@GFNm192D}WjT z?bMxv>h`$opGvuIIKoNHj~MXeP~$+6i5F9%Thh2?hKV(&MXF95KG~sT21Kt>EtwAv z=cOjJG7)L7j-o94E#cWo&vB0GFcZM!+!u)za*a&h62`GFoLvotf-1o2IA!r~U0`Nz zvG-Wo8*c&;ve2sZ%P%HVpDg;6Js)DXn#+K|K}`bKS$xsk&RW@^t9YL+FOx1@z#^7V#ho(K&BrVY z+xi$*Lb~Edi~Zu|tr8$`T4u(G$oqEI!}Bvjsv&>z#^En1(g35%h_Vh;nVaM`Axi)% zOEV;|P1g*+xXUlc@_-mZ-xh?2 ze|+MkU)4zN&g~t{z%w+9{iNy0b`nghdW02xQ71s)Dwoo5)|8*ml#>*aJ}@AZp8Nub zxe3d<-pGTL`T5%gmCHew_t*y@5TG6XqmPS?2_FDjBB1krN-4sIP8!Di3wS;2{}ts< zb=A|Kevl!>jIo*@Qh2bl;y72#{;f)o@qc%hRltjD@TnDruaU&k=`~KCkHWkL6BGUl z8{utkyf5>>kXqRes{Za|4#{KV-F&wY9G4*k+gd^lhv*|x@vW%vM@TgkzM?FYuIGAT zOaG}SNB4E8+dh1)vkt_42(L zZC{ore`wGP#Uh1xf|z;Ym=$347&fm=OrBEfMvP!(DUB5Fl*iW^;g+3m2)-Z)MZ>n%$-^^M_an#Uy#Qf^tNBRtX`;%s%_8uDJ_x6+Z$FZ$&}O&!M~t z%)(dw>t0fLHz>j>dVsKi?uEQfi7cf4tR*TJ8z2`vtVrrP1+5WzHteGT#*<57FdTt= z(C~y^Xde7|6F@>KNPVGqsOSR_=h!u+v6@SY_SD2%vrSPL-fuj%qpT^R5Pj#b(0`q( z!0d5aGiaAXhlULK(dBGxt@H!~GZ9bz*+H}4C$EYz}{2t8<- z-Z@?E8AuRr=CYW7qh^(!vk?xct?~A(0RZ1+CsNu2g3s^x{_$=~{!s!1b+RfV9T3us z2ODVvJZsIB6)pX%a~`kt;2#mc4;KrfD&3+wPO)`{z7zYVa&61E9D^=*x;lE}Ew3Lp zgg%}(+Q@SgT4(j(;#XiC`3}S}yYpze%E#}>PtEf2peF5lcb=qSfK0G~w!c;h26T(= zqw97mD{0n5o=JJ%mS@njbWntII#C}@8C<4~e#-BfL6u3~XAPbXf}w@ljJSDD;})k{ z)N@Elb;ZS9zd+*EhG`4~n0~ik(((6*WqpR-WKzf~GMk+^`KCv- z@AAmG<&HXPP6&KYcuY4Su4TVVg%vEPZ6}pyBbk?$BW8CZcazAh$Q^yRlzz*_UKiE} zdj~{{B$ibf-!3vB&~%-mh!Te?xC8wOUuz~SDtuAt*CN%x*v=nU;mawQ9rm%NtgyIm zqs7>AisSh3Ha_kOo;v5<+bOH+@oqqm8#EJn>WO3_1`t{J0Dj;aP?#yk@;Y|3AQuXV z_9Jt{(2C(28;=GS$alFd;Jsa{b3I0ATq0qJzD$^++0c>-BelnhLxofW{>3+k2xbZq zB+2cir|Bb+?^e&&S!`63K=dnI2=*wgL-PdNS zTGZ0mm#GX3J?@J*IPs9IIxLO^~j;gZ`W zcgqp=y_L(X)ZLPsi+&M-soTlc2A}We1wjBXIOWLK-Y5w7J#s&*iH2Qwq0l@D{gK*m zVXMHeO)jN9*w>=Z3ZatbdQ9wclA4@627NSV4#BVJ0a?72Xy%3YZkH=HrVoC$+CazkoRG2a(<|U@U zGVj%p7Cguy9~BvZkbr>wBo4QY=l$G+G7l;f3cuO*o7+!03*ZTdd zQ6GLnaJ9>-O!`QNND{2E!OampCL~ap`Fb-C(nmEaT9NPCs2VfR+qQy4_1Qn$ zXl=Db=@wk%ez7u35By~r1y6l+Jg=R$BTaAlCL^=2v-4?y10^(Hh(;<(Ox6P_%PDT9 zq?L>5VLV#B7vS@kKL}v8KR@`_Q;pIn?o}La9NL@C@MMCwi=vPDqay@5{5O?y=o(w{ zMmRCaBJ7%eX`NL}9nwAkGT?iJVi|Wi#iN_kY)?mBPaKp0mEiMGh}^6^9>y90U9VxD zJrBkXhY!bue-Ww2yAl}g;iFUjOCRdNnfqSw!hwkq@pfW~b4p06%RwNq#$IQkWK=De zHR+VB>q2jCp-N-SBy&0pcR*NVSgW^uRjmVqZreAV#i1Ch92H~<9%*qPMS3c8L}(71 zNut{)1O+kg<~-if%SiqZVjj2W6lo|j)#F6?1jywupbfcpfRY&C{!Ypj>*Z*Th|Gj? ztPG*x6GKdgUj8o*misiTzC-zS2GBu>sJ$;YkI$PT!2+aMZfw(s}&LA7@o%Ew}(~f${B5m-(RD{<)XM z?C1b6&!}p`bJE}4oR=YE(Mvuf6*0WvC0Osb#meuv+RW7*Q+PqQvZ<|}HtwYxo%ZN| zMQS&(ew)2WqBaWFZg;!<2ieu@waHA0M( zakL_xN4O%|ft$JUbI^bz(0V>>r%vd3dHT@IG~|EO4NU$qIa>)w$nUGaecOx|Uwhr! zh6+-{A_XA$Zj4npUtcMc5M^+tMT3Jj{kAH24Hw9_H<{ZJAU-c)&7fdzVd1Smhq1^L zUZ?D758B%4mFk4?Dwi;1@>;tgf$OI~g#%2q;u8H6Y4(37y@nMmngcp~iF+x-6ASX} z$xu53x4$%fVy*QcGKvz=?WWH4uy&pGWO*lS*s9X$ChMCe;29vSN2Z0dcly{abV!Xw zsVQAdy(E<1+8K|dKk=#d`{_saxJaPp(;}hOZuNR-EU-8KO?A}ILl9CN(A$aj{``+T zB`M|>I$;KBXu>8dZq5|_0+M&JMy!~+SiAeK4czs zHdbba+3`I^0S$95;_?1LE9*Q)o<~_W zL3~Cc#9N)m3cJ4~kLKob8&>yEE@O3{v!7hVXf&iO1mbE2>TpYU&+SRwX*)QX#uBs_ zTcWEM&1U?&-+1|~|LOq)Y}{vN|918H9Uin+O7I@f4$eKWMRqz?ax)U$1@A37UR2`0 z+#$7MttJx@bp5s&JY2B%hzt=0O242rnbg^Y{xWfgEQ?77WAHl;C-=3iH*~b$rD10% z`Zu(+vuR?kA$N=m>uw#lRAcTbTg@34-&VAv-FAE?x-F-HKODE-QNcYNb7~rerzenF zRok?iz#h~}-Q%YP^{Zvn$@kel*HPk)CMzXH!WiE2K$*+MfQr?_-Ft77G5@OvlU)g) z+_-8=oY8&UVutw8)aSY^YglJGrO`H`X{PvES^F{HGx875uk>=Mdz7yR+~LH6_Uc(e z4m?BFSv;xPuWW2QKT4(s3gnKy8n)4XN|h+#a7k>#MqT9lEee*?kv0M6bC~CzoE(J5 zvIo;Qlm7H}cvHE8V5emHPI%{-2?q}_!<+O_GbQegG6OUsyTp*Ff)nsgL!<`g-S0Vt zg@u;`uC*jc!AOECSW+eZ*)e@ZM+Gse#MHH2MvYVWW9c3y*z2;NV#m6rO6KaUA9IWU z{_Tz2%o*qHdJ|!g(pZzB^w}fp!rve*+V(KtmBumcXOD43Jo-?QMz;%I;R=1Wgp`0W z{6WNP;V1c*J-164Q?PUfICZ|L1 z-Ixu!Uab_wtBg`Qh-aSOJY4#Llol6dQ1Hl_0J;~JUAtMD;~LG{yoFaP)dMv?Q^eVG zs&U2)!~62`BZ9r^v%8KDZ{%U$?2pEtJ!k^!O2Qe<8l5U0C?yXEgUlI`zG*F%G3jJy&GV;Ec)=_uA-vK-q3^xu%t z?VyrnD$ib!Toh+0$*z*&KB?W$`*r4Vp~+xF@SO>ILpMyX!pGiJ!`vjh>ZBQxA&$Or z$Y1z;6LYE_zRMT>Z*#xfkP=I0 zmPo=zPO;GH8Z2{!&8S0M^2WlXxdgqiofIo4+cB=Faq$)v52zL*ug;yjdl0?bTjMai|tG%Cyf6F(O}O^ZH`S z|1FbSaYo( zsHU8P9>X%ZxQqQ=sI@nBVR*4JrgEq8d=1W`CB^Ji-F82VsGB4K8uYvUSD2jqpAe;t z`rJDI?$}OE;uuj5KV%*C(mVXM*MBL81q?FTLOJ}7R9OUN#Y>#5@Tl~%~5R;(KYJPrvHm^4lEs6F@{@TjaG*-Hru!EX@? zsc_)f(?3K(^?D02?eTK%h4=$i@fp_}4Kz$&R>c`EN^vntBXtup47{4U(H6|7^`de9 z3bMp;Sd%1vU#?jnyF@TOa5LZkW(=VCbarPEPoRsrgDZno^Cfi48^)M4cWRd|;TIJy zPpGG}c&0*MRH$B0rl&9Pb5yv8A0kOg*ZXn>7yFK~$ygw>dkMq&bX6ST;&5^Q+Y9eO z2AI%SVUgmsUZvp^cwb(tQH5#G>d%&8n)ulq1{yJW?SyvTJj|t7kc`!ssAk&Kpr)cl zCdrEZ(%&?wQoe>)8t(|l;NUM#$p<><{K9SIj4|&*_Ir={;fyG_W+7w`CO4c^n?~f9!)e}=#1j!_zILUQj(iKf`;f?Gipm}q9*+@!TOmevc6vCtxhXbtBk2ti zL&}zeVIpONO4*vWx3=83ucKBmSvEq6HfGj~)crPEMGd8HPaAod6(z}EI{2fqadV!r z!jmYev?BTE2Rn!z%Quo9l7x_{^CezxD3ekaOp1u;Ly<~Wd@VeCA8)phwo z7Xr3e)9rs`7s;o?tx5Zli!XTN>*Z}bJcFASi9wY#z2;=wc_>XRU#3W&kms-!%l?kNlj)N_S_sC}wnQ&-`QBw@ct)pmP75{rqG^4$Elpj$V0}%# z)A`b*BuBy}vg83~KIAUO8Pc=&n8`5wR$E>l`D$Y$5dsQ`vw)-yUUZ{|#FP2kEC zCY?IO+g@L=YA3cK$a%1<)jL7$LyYT{tM9H-|LPun5s!Bu%Hi5fTz6!PQ!q4%&T0~= z?{PKHPip6}_%ZaelhLN$E^9^}zH&-&-Vi37dT0IG;TZy5LkR|BX{o8HfmE*KeL$7s zAn39F)ezR}4VeVCVV$SwH{K~pVli3Rnzdoc;pw30;63*vnr+{|c+DU2nsrft3KYo% zi9Ap1FP&dmXhnSwHur59$B=sm+QahR&KRs*J*=02U_?Ou8sN`%WO_2<+);%GazK#J z{SuFC3k0E76i=EU|!E87{POzN062f&M&6HQBpVu5U+M+w6-5-nn zR^z6=QMJ9#Uop$O=mmLSVJhRfgN1ku5a8bmV5fWHt;;Ec4D*43uDqrZ0i(+ zIZtcq;UNC2(h^)5Q%Uo#W}NN`%_{N>L)YdX#T6v#U!FQx4JW-s2|*+vS}rN!6RP?!#f4LQzMqiow^Mt_cBB(a`Hy{=oIV)s^tFf zAOgZeq(D;t%U_6VM9O-|K$Jq zh1T%ip#^_XhP*4j|G#E5CPXrYG&A2U1kPh39c^xy{qGrJMG9*wBp|i@`RSchre$Ty z>;)hF7|KrzWqO<>Gj);WaLPq>Vb_L|mOl1}nkh{V4#tHBeS=`^J7YfK;3D}ezJ@G! zZdOSS#$ow=U$?pgN&ka(k8Gn~EnV{a?qAjl9&j&E6xNU%yZ8AoBY)fZ*ohT<^Jy`? zYw-``Tyj(EL06dWf9OeczfV}}rS#}qcy-TtMPxb>KM7q9b@k{xBE*&ZEn9*(fqd} z-Pix`id4RlhRO-}Hj^Hm|NgCI{5&o9xHJ+L{Pj*j&!@a!XO90xccffn2Q)R>h1*fz zMskjcWt?H4uZ1)kX~qNlSVOr;R71<6mlw*nK|pIJZenMdMLx|rcBQ7`JaooQ+bVvv zLRX}7tnbiKQ#<}kVF5x;w9SY+;`*49`o^~4KOb=JE zTK%i4YK&kv=p5Ij+{w;m-~+kwpEH8W%9@gqfj<$$$NP+Lah)?thK}W|zAgIYO;XO0 zDn@&m9>kv6U|AOUX59RSuK$qsZ=QZ=`~vnjcCQ~>CcuuzZ{lDFOT#kSkbR1qv*IKw zn-7{t*jNQ=B8o*tpE*!@7a&z|)#rNa4qVIEd+QCv=%DzX(#Cw{lWu~_+iB&W++Nfs zud5M3juTs0rWWDIY>t%3u_td(&rKb%H_{l{3TRDuAP~6|) zQlY0QIbXMq(AQWQ0Yl%KkFGEn=UpF9I>&wd0D$}_Z$LVJzdjbE{$r+ z8e4cb+#kD*EK5fVp4Cj5u#{@UX=g8!_kJ$zWoGRqr0J9_Z-05^2Qg;kC}iw?j{|pk z)W%<)m6fk7_&!_yXE#&YJQz~_uE*JPH_pXzyE62+hKStQ!#@?>Qh$%mpW74d>a|DH zYw|;dw^xFidCDvN4fy;C**`pQ-wrI5E~7C3X1=0H7cTzRyfx?7KgyB}NN@9<1vNdM zYQoK&I(J!T6xv-l&~zyq#<~KI{yX~O8vd8J`yZZ44Cx5!%z%NUAR*uHCRa#hz&938 zI=`AtY{6Ml>e7))K#wKYR(oIwAC53_lr`;4#y1XMSKg5*_eC2Smh`l5Z2PbSO8%nK zbfHuuTDtpTiv|Yo8Me!*wjDiZ(GqnsPH5Y1<#xQxdvYu*|J`=3N};>lb8b~BH#_+P zueQ-R&KB7zqR~>i8Oo&`0t?oa4hravd5}32q2mZUnCxhMmT^3aA~y!U#fqk+X>(n? z4nM~7FT$PvnM(8J^t4MvZ*|^22geh0V(JC1l1Pq&-J!|vKHv*I zrl($|8%l6@W!^*ceGUjHM;M0WTpLKjoW>D$=hFJqcJJ-Cb|B-fb<3i>S0wHp6OC1q zug{e(0Z#}wIu}+I4=LstA6pk)kFpZV3eXD8wz-c$u^A8fu1&I1|K#I4s#*TV`dAkY zTpAwa`@+^g-y&OmZPnAD&M@((amEYtyr(?>?ngh|_}s^7!;iid#WVSAHy=)o7rC91 zNHACUbK5N<7FOoOK%^%^=;B_{e5`TbwP+z52)HP`%wY_FCVirUs6Ieclq&4gDO^A> z%eU>3Sc0UbgD$Rxtel5lYm8L5_hm~!?aHp=a@C6Qq1}wGT<7%xX8);d1}u?K##D z9@Xuzzpn%xZlKB6wD7wf<0h@oDs9^ArYx1I^K{(t$QJ0!{X+l}a+H z>`yeV6sPz~$lfTYR5yD)CC5|-WVeq)o=wd&ZMdW@_OrZ@Oe(GyCQ0JQ>juVcXU0Md ziJ+w)ERu#6IQ2{rP$zAfVCCt3qHeR(FnuyS33(^002g(l#(hQ6-{`p>#2Ky3M z?-5E7>I+eYykll+`Z0Z!Y%X)7;P)!dThIDZ?IUO9;(jBQm>oS8o0z^!L%iU?@6awx zou4B;Y;po!?z?`1Zd>MGIPrE?b4+byUQtI&#oK9zF2UZr8I^lg$X6aR5h+nI{3YP0 zsyV=Ygkk}Vy&|SIZJq5Q7Fl%Nd+R9LV~gw2O@b|E?VXHU@lZdqE@&>02Cx20O%P;Y zM82c=v`U*SOp%Lf3A6H2Af0+mQ0L;3?p%nBGchK&{j$=ii*uEd#3pUxMpNybZn%=a z>furWu0gF|VrpKHSHrzhbc0D>u3PxdJANg-)LC_*BR_5(1;JsY4KMYMZ>t;@j%NP~ z+gs4Z@seEe+QNdo`}hECrnm>yT9%X-E3UNg^tm?Io>z}hrZeI1=KZb=#uL#Cb zI$-pl*gHHGf4~OLPL23qO_KjzG6-lff~?;mf*Xq<|Fi!S+{g#TkA7-Amf0YFHRu8# z%h-x|d+EVhwYr^SR5zxxhFTskbllziITe=B_2{!NvN$R$meOEhn^~`+`$wKYk#$yl z{PC#*n--4NkP&&B!&d-aUzf;H#uH}R@funha-1r}tE?_x=r~>Z*d)ubQbXJ3g>DWE zw?4(X>SxXZA_+--HU{G(I$gID4-?5Io&u7=Bp^l{$~7Fe>2)T~DxR&OXpP0mzoj1z z2_Ff&iMhMN5;_yqg%7cp6v`AlE*P?3w-t;jsWPs{|nVj;#fY$-zbP5Ji~nCwvg^6ls1n5 z0T*uT^yWw-lGM)yA)lRJJtFDd5t|p$zQhHDrE`xfsq*~NfaGRMj7Ki%{y8$%XcR11t{evOFvdPsf2`+N}=BRmMr{%eh{|$ zxl|aqq$)mSH}WpLV)VD)TPjI9+%S{dzDnIN{8}{$%)4>bnw$X(J6y2gk=NJMAE%iC{hI?Ev%RuNno0=x^7A!IDSo0V{M~$WZXZ z_84!t_UCXkzr!KHBPX)qGp@JuQt-iz{g`F-6u_IUfYV*iEpCkuZ?#ECxvrJJc7@)3 zpTEzSyEsVS@r7aq={Wx}p5~2y@zXjU7nJ*ip91q`<=dq>wyoKCl%_Nv@&&eIu@RiE zBobMo=wlyzv749y`<_Fgj5O8jS5nUz#l{`sI_>9@L3FejUATMMTQRKa`jS{|%Vm<; z8L`rV5AY9||3&NVZmzDh8l{}S{#<+u>Wd-N=II|C|M(DqlrX^D zk#P@K4s%9XSLElAn=V>9`wb_=uk)iDa$zkVTk5n|F3Bk1lI&_lt%| zV~j~EFIr0&Y0Eih4&N{14wp@;uPcl3lxZ|FWdSAeC`1EGc75Nf7TlCt2utJTLgsq2 zfY)_bvfJ574L4Diy?7Rl%7n^lQJ;!LelLr7)El&aarpD0awF^wCVgpru2d3I$+;{%aR3u7P`H`m z1oI62Wes26X-9%zmR3}1&dcvR<>6Nej8bJ+T*ud(1-+5w!h5SE5v}tS4*%H9DxPSI zzWJI1RK95*kLi~>2(?aOGo0W}keqI}Y*$d?f*l18p9a%TDu2WsP4m{O=sMwG{;1mY zx2~E{4&C^1cUTr>6h`rd%W90tF}%#N8b}k={XZ# z!2QExk|Kj^;)!!SUy+~KlyN>zSL&}1_1)jS+jhBNhH@g^SOucRcH;9Lf8|~=5wuTg z=aVV+{qcf;@s!xx;Wt%>I*x&*Mt^jp87D4oj~|b3u_1Mao7dHYft3TgVmQ&`&SUq3 zVw&%}ZVz1&L|b+UPVX+pX5*20eh)8B#yeT+=kxCwj^pX}7q5C$i*SW`-{9QfKh*`C zSTrd-L+TcMEW;S1pM5HzFcF^?&J!Bv7CiXXznt5D?tYCG;p<=Ng?WLgpR1!hcQ(AF z1m+$NM~gbzl%!I9osS9O`^k4CU(o3h(XNTgSvSS*$%xRr#O%iv3=tNqt1`eoDJk_X~Tqjkn^JUJC2VN<`3NX3@eP)O|bR8-elZ-(? z<&s3$3IP;oa%YBKa7rT22UkwxjdOUv%1OI(hum-rgRqR-LB$2Htp zOdH-K9^c{#Q~u)gBouk)Id9JQ6&blLV{9YC-gY!aZ7Qa%9h)XkbcAo$VvxK5a-{LU zVB;tx&;qsm#Gjb(WVwZM-@T{RHhZoj8S9|fK*_%!jptqNaARaHmi=~r#>O_2E0(+l zg3F^L@uo?ooMH{Hxudc7enYikcBk#%X8F6pvL0I|QY_Fr9HROTeWQmIPrrvWhW@S| z{N?F=G=Ah|T-5RAiKD4SXi5H+20EpkG zoUc0oxxTSG^ zs6=dJ&{LxTJPO~EgV*)-z01B?fiqRRGi+nGs_L_s`*eR?Qeq~NDUvBYbW095>>JJF z-MrgLv>e?ax1zFEIs<1WIa4CvRQOqMEYb<4*ee*PN=WLMJi2!hJTIVHW{H$F4q_K! zdsSB*vC3SM=S|RHiPGtny~O98mdWoE)qsu{`o#P6xV;^ecawvdATl05I~_SNaMd#Y zUZ`VLM*oaT8fxhW$^J;e(a4o5^GLZqY&OU7U(i4A`PK?Q_~8G_3^m(8_DZ3E?zof@ zmwJI?653lxIAbzHFLJ=~XrGA(EoUJ2vq(0C>!)$&^XWAzy#Kp#-G;QEg5BoxWc$#^ zbC^x?z8ULvX1qwIR}{BBx{T{Z+7t&r%j~1gzE3uO^{V9v4NyOnMzd`!a9FKgZghD2iv9x_XB>=XRoF@;jA5fwO!0Hp+~)-Jc)B9T$^n>uTwkrNrh=#+q(U zCYUXj04;7Ol7`2+Lzb#C0!n+Y3>ItNd{G5Rd%;@O%p6-B(+t9Yr%6?peqT8fHMA+* z%L7w?_8OTAT5PyOmu`LSkS|_>es&!Ac&3wl%kz_58o(xAfZC&$+^_ zuKOo{r!-LGXdoqSkLSa*Mzr7`MhuH?M(g0~ji=`yav=6TFM$V@w=~s|m2Pw-u9tGl<8Tde=aPn3Uy%7q+GnH;54T>T~4@$R%+7wyqUk5s0UrsmoC z8T%MD*{O#U_Sv?2X;sj+U}sNitk@8KRQ$QMLxjaLEam0X%*(nJCh#fM>y+v`4a?rK zRN0VU+H8VsEo;Ddi-P;i#VSEpQ&zkL_%d;{V*A8*Oj$8gn0tJ05|gfD&26k6Acy7; zS;y;lciA$2km*4OF8!WCD5ab7y(du`I9DS934{m2aqcIuX$^z*;WIT-vATEZfHgmb zkrAj*&!=jwOZfg~$Mk$}FT#SG5&EJE>BB%azE3~)Q1t{zO!>55st~x!xy(PI#sNbH zoFI-IR{oPAbZ)D(l_q?)XA@HbaDp+(omhS5! zbpMi_{ZiG>J~9U>X_vUgV|RPI<<~E*xyi}N5^P>;WNCow6AL;L1%Xn;RnfwaO_2mP zNf3_UKAA`kPAnIQHY#3`Fv!_Yj@-Yzl_k37Skla7dqqpYed#h<3TKWHN<6LH66k%w zF1m9R1U|QNy^q|Jwe|v}M9mPDohYWgrw&oN_DuM*2|`w4q$kz029t-S@*q&l(m~%Y zRZ8uSm^+X~auV-r@>2T5Rl{s=8#|75-nI_VVs}5pfw8P@Umw%J(~L({x4pTfl<%QY zQN;C`qc=(7W91dYY-I8`}(`L&w7t!obH{AMqR$B=J`hyJ;%^@H=U@@_)8F~Er=Qd@+-2cxdX+bxd+IC z{k5p*gP}0vLUpq?D ziDZ&3_R;!$A2|aplw+;?>|$h>2RQr>0!=+p99Of{SxUY zF!4p_d~Ia<(!s`#v=dM<4%PKzRdX;FUSe6 zo&A(Y>Wx9^*0*5j>DvycGsxPTq}=vem343=mQg}zyJid19h?1zo>O@P1qQtuNL9AY!Id>V}egSkd+%L_o7PCdC#^bXDNuDZ=2JnN_xu(zV0@$8kft4IIuwW6!Gv5xGmP%u&! zxq73=!qYDiZ_cPw>6PX+ZRgL0^Q4|_OSdeM0>mYcYmu=M=(9?%lx~n`SGHZZpLbH7 zNcR=pp)AW%=w!`?bnmtb;U37J3b8|4^*GM5#)FE8EdRX31scTc#xCjXS)(5;GpX`_ zb^xLCtZ?ET>)Qlg{u0IaJ|7*+v5pjs8pTmo=l68#k%j1D$O{ai0P=qtPR#SJcts?c zP)YAgQ|bsRgaEwJ(-px|G^Ql@8qfkTravJMx2h$0_T627ySc1k z&-Na=4HDY#_w?2-B0%orxFf|~_2e&#+4mLT(+~K5q;r8jYYKGdi)r9flBz0?wztcS zW+>|dV3Sd{;{pGic2KTlBGmbjl=62;J3f7?pQb5&=9XP9Lt-lDatEy4(d$I!hGuvT zTw`nM66h$MabLXJ`J+p(ZOZ3}DtvI1QgpQZc1r@b7)qZGeqH}bBAEXMq!%X(8rHzHIkXdg5Y5WPQ>(x~1Qw_tQOv*t%#iH=?_$Qse?b(N%_ym0 z;FF)AMGuICn%c<}a76gQ0>ulZ+^}J|!mMkBQo^rUHAITp+Pt-855bs1?YrK2QNvKO z@}t~6obVO5>J6j8Ss+cUO+)Qs=JuO-bTJSjd73=(^vro^Iw%YM-tql~L3ioBL5t!l zODvS*(u)D2iiM8O0S4b6MJhdz~szJ;Gd=Cg-AWM?=xu(A69eDFabqA16-)Zv2(33X4h7 zAH-H<-5J`1>M$`Ne1875RYO3)kwENygfoicY!VO8pVXvyP_QS9i`7*$s_M!B3nox} zTSAGY07Z9qz@47@&ovDU3!SMGu8a0u_nyc}^wK z$sjGbu3$gQDfgc*Hb|&=f)Mec!eD-pDCH%5=90~?_X-X zg%`!6o%%LgH$74g`BXLwwh>DrKZ(|#dL|9=l2Rrbla&&B(xpOz965JKwWKjjV4c5| z`g{MKQJ)kuABSE*4*DX`7!;;go&r6MI~Re1gFc}n(JoK~3M;r>lQ4n_TL`|&K6HGG z6*+_GGh6HljD{wBLDmE| z$SwWixsxbr;B`^m=SE$xVYHD$@>7ul1 z=gb5jKfMf$eUeO}I$Xw_wO;{OuMgq4T+h=>IDI z$B4=S;76y@|1MkChf3*zfC87?F`t<1p$rUtDF5qq3{T*8-Mv|b39U^ z)7=s;IA?~T;s1P`kj%=I4SImoe=2m7Ol1?dU6RGZ0}W297xX+=SRF@EGF4LJZ4kV; z@Rc(Zc3F!&hrryBM)yf9(QhdSCAp-9AQ95EqCGDJ5IJ5+e~*T~VcGN+Bx&<#5U`gh z?9(;E1(RFgQ$(hxL9A%7*uqFm>FN0?zPsEEn_!mvk9=}kZx0FTp*V$@vvcY~lr%&7 zI6s)iQ`0&n`J?Pi$(&2EZ+J=i*-yQRMw&xkRbbfmQ(tGcMFH;6qGRXk0mYHNIEPeC#JgA*bX)t>6X~NX#{knLT5A6Q)1MW!pZ(rJxSMHd}@3Q4a z*$^h33jw)86Vq*D7P?umzcJ)N0$_gfe6)Xq=@ib^z+beGqybgU(fiRwnfV>Rcvdh8-vpe$4OLf0#~$^0`sn&!c2P6bCsmn&&=iN~7rAexGd% z<|)6c5UE3eS?DSv{~s*<{{yLLr3Hf$>y(*RvQ9`^TT?W+m}65x$Akv-XB6b8W+Rk$ zEC#%r4Z*uv_wQ>_pF??qY_C+gCxWSm46)XOZWIh5uu^J~lq5-JmH_d)-9b7 zv}_4A64lCd7L11(<;Gh6EDuhd&6H@N{-v|?)8tQ*vLPC^| z-n-m-(Z3?+o=ngUvzFZwZcNYs)pkZ=B6Shk(2Ikrcte5!HoY(~{6PIspI=Qqs5j*s z(9zvAuQ&?srz%MJ|JZuVsJPmtO&F(-5r9v zLvVL@cMA?7KyY^n?(XjH?hJX(`JVY^=Ka~ddhK<0?Yc{@s;epmO2sP>UJx1Jki#9# zFAVH7etu>sjXl0sAQ>y%fxZk{-cL>c%0b)(4IU3~kR&3#x#EFZ&s3i=bWya`iGojU zto$}OOcS*NO&k~Y5tY00@qe}>>9BZmC3*Hx?rTWW%+Z*$e}aSoK#=Bn@aN)elY)Rp zzM=6&tzb7%??vn?k67X=_c*)Req69%V2mIMVS#TcUumx*3*kN@0;DgAncmSWdxVM* z(%fR$G4=kPq)9T^usF{?BvL#(aqUdxiG=isW@^$4TVIDPQLaV0z++;Ph^sOL|0uZY z^*_YoU0U2TB)i62T|V$lRQZsuO2rk1hS$Y{S5lW3*>z}E>6Bl5)@@6<05S^jH&JBG zdLCzhVvPwP*Po`-_ksdIbGnaU;__d$7oU-nzBSn#+u#|8x?bIXS8cLavrQy-^5xK> zW~;cN)nN=S>kE5BL-PIVdz1O|1Wi3~PS{QIt4h`|VtYA)wqp^Bwu@~SRO!SFi zdvFEU-cvf!j&s!8%{ zS5)81_H;?0eeO+WBKSf`52)QI0!D(Lon>J2OM4FwPVXJHOP}2<52=Iw**9a4ChX~w zrR6=l3nft7u-m6s(t2W=jTz=HWJH|1^kCjCk1>TLfcS`pHDeI?tnbuJbmNqhrQdg} zf7-vV*7Pmo+z|=r)u}%RD8bmilV9`f52B&^AGoSUy(pnKpFR?69_7J{y@*iz7kuJg$_z#a8HK)ZCI(dV29a-nFQz>bB}>Q(sQ3yA)DPaol1idB=Ro=FEi8>RsxJr zrAsva6K^hQwktj3m>z69xC)-;KrwbkXO*S|G@)kIU^Jo#E&qZ6Ee_w637%3Y;(4Kr zyDrghMpKFJsgyAYJ)Z*;K*f5EpbZ`vp$HlDxjW(3q&j~c4%r9j{0E7C4h{f*Y6FpA&}yRy8hq!a7wL{vvNERXZL#Eq3dNVFW`l#U zKlJib0^G1;6o8lf>UJS}6doN{n?iLWW+R1n*dSEtu`$#|3v>kzO9O!2^Yw1tsLRs} znsIXfYsLy(qo|7tu=De<1Wc@b7XwIFjSuBZW$Bg|BbBLdoE7bFh7vxZM9Z_gLqpoj zWp^@#<+77^V8a_HeBAaC=vB>2H_5a|6BX-Y&uPwA{_1ac4}bOEBs|A8knCy?E_F< zkm#! zTph@QmjGs^TOk~%6(7EsWV&+%S_weJ7FziE`)k z#57I|t=-dP1ZiQl%AvBTBqYWnZx)I-(Pd$(>`bTT%nu+d{QBy-b%O#Abl($yNT*Qs z-s?g`Wvycp)k;iev2~xiSP^X5My(QVf`b`!Y26u+Q9z* zZ7NFw8jz7SNAli)6$n9{GxkD*%-t36>UhYj$0y|-efKX>CG!L&e z6iu}|U+;Z(WJfQ3jWBG^w{YSQUPtjAl2(24mP-&1dJ-yBUzkZ_X@F3+bnVJ;17Gbw zRsV6jZJd~73xiVAV_l;1dxvNwatz;+)?Wz z?5Ld@^Fbab0^Vf48Q|knD|&Zqb%qHQX7^l^^y#_DgvY4Z_rl*NN7Dt8#(72whup)d zK50>4xt$ddMt;K7EgewHM?nGE%|Pb5%O`ua;)dc@SdCT^lGs7}hadCyf2N-f0}rLp zZ8ME?3)#SqQH9wgnGte!>4IU~#b{n<(6!-!DN1mDFBAL%8jE#b3To-d+{)?DXAP0I z0owI`j+xDhsNa<3ZPfi?k2b<6ke`z3W#x4s-f6|jv?a#SZeb{G;weZdPW!RHI0k{@ zXx9iXe(w_@=!(wZ`7WCKK2Q+ZH3|*4(d@Z&QV4yIX)x3gJIX z@}747ev67(rw6APZpF*;G>ss$3f$RF^6$-FLC1?3uuE<{OPKaEq)gi;rJSi8lFBLU zi4q-t1`8v10l%#mAJo%9VGF zVfO%8Umkap+~sH%*%Our#5sdA6l0I8dF>U{W zM)7SGvVRm4Y*yw(_R6O1_jCH%$o_yd>0cT@f*8S(JUeP%HKr=fvXhDcAu+``5N$l0 zGMgxUoG5|FG7bXrYg7&h9yD&v!j?Wk?p(?fS$qwf1Np=> z+a91fO{j7Uh#QEv-K4TzdkanwCqf+a7$9vSyOJbg3~|aSc6j~hji;_9%H#uP4hGO%a5VjW(PV5)g}o>NBR| z%~I=usSl>$FD+m_M9M869XGFXf{mbKNDH!VbP{4iVFJ0wGKPM0ZHb&Y!lCU~n>|Dp z&YZ8B@`u)enSssNF}@=~x~{Zf9K<3WiAHYUDKWJlfuPtKQ>eJ` zrKX~U%b&WrI9N}Td_^IJ*s7J#G=gAeAC1$2As2WL3UVJkZzY><1GdYY2QG}NMX(55 zm}dyuGiZ9i5r@QCJ5iGYiIbvyTN_nN33PhpGTv4Jh6}7@ye# zBXoFx)c*71-pGtmM~hOM$YFa&F|b0#wvb{&rdqCSotV|5C`m6RGY@gVnqnM=M0sx@ z8IZU^Ib2Byf)8eECP;T zgKD;m>x(0!85`x7U)C!KppXc-T^G5w6X1262fTv*?Za#2MA0L0AVau}MP=IrVu?fH zx{D*I@&iv&*mQ4Fv$#BTxiShy(V9Ez=-+^{-@9#UQK_`BPIEtT!=`QJW!0Z@>NfpZ zAG^o9)wBJjab$k3bA+_i=d#r4h1EPZhir$$BftZ6Zs{6=JA+Q&AjB3r07;zI(U>KC z-jODsl!?r4TU%`A*Ufdky_>~qxFKT2>EU9 zWJWObBu#j;#qkP+_-@^zy6hq3l;Oc=Y_}d%ZkrKc>VKK@b{#Edk={KFI6_!*ZNCJZ z?Rq?TZB|@gr&ZrL9C&qE+G?ygePEm3Siv95OOccU6MseZg(MQc-f>8Hylx~_%|j62VipvcP2XxgSf%Q zI|@A!t|H-D891q@JI+wdB0jLeC1QIx@A1LGCa8i3;(rglfzk+sAjA~d5PZGxx&MdJ zVub>L!t06}NU7p4#3ZG@huuQgVU&T#2krMSOJ+%oMUiJVqU`vXX(qp~l1!j{RGJO| zX%Vg;kUJK5me0(;iHkP>hsDtb8(u&9K;bG=VUH;|kXh8w+LFOcbJmY&TfZYxd z%cf@-Ma7EFW3o2Y#}7deB%2>hCEufnn}69kTp!=(;LE>AeLS;MIl}i5{33`OTGfid ztDm0YZ=DQm>Hh^y{|XGew`1qu0)p&c>X0nNY|`>ariM}b()RBO4|xBIfYwb!ftV|@SCF#aiM zBmI5!|5egUkp;>pm(K}npM95`Er{GLl*@(}stF-cYHAN`!@MK8hm?J&GHGrQi^qOc%;(c$Ctm zB)Voh^SFx~b6=-2Kf!Kw7AK63F;=QB-{{=lpJ42|-$ionrzMPjva)W?=pY9BAdX2Q zy}#`KSDxA;e|1Bo6z$$aAO{VU=^(W%!mYM3-b8hhQu+KiY27iwtRM4C_}|Lq#&3a* zEog8$(kDK)g6xQJDd$3s&)SAE1zd|-?|vGc9-+R5etcfPMc&m;9$YR}W3t+`1lI-V ztHwbXVJZB`^Lg!asws`Xe!#m_7wa(8!4tbeiQ|RI9Gz}Wf6@LQBRj z%ffu-mHyjUZ$r5Q87R4j^tViL8u=Ov9)rUtR%5~gSEusbH~N3XX1h!Dp%Z|}!2%R0 zwTBAuc#E@;&2+rm$5tra`=wK>>_^`!_!Y|WTm33;*KwAC{XR4d5UBW3;!or_Y<2wqNF&9SZaK?$;LD`%bKZ@CbVFC6B%ANDqf_(<7g8>i(XfD?*nv25yM#mnBQ1B z7+YQI{`Xpdwg6hSpd41Hl*hsQ_x#}>l?%#vi)Z%hFG(ew)!ib!bdWERy$O6pq(;%I>UL!u`YP9G=*d9o8T{GvAJ)Z**BvZ21`gL zPd%QI>0J&hX3k+QM+O~#D;*9SbF(9woeEys2 zsqD9%mZxyRxR)AS#N|Zc{>Gkm$T}RHqpkSoA3%_CC+oMA=ArIor*}9vy6-hkI9S3x zp$jvPDL*(AWx|~6lAz0f8FloKX(fs7NEzwiqimQ9pOeB=fo}@nVV}Tl(qrv5(0^ zO-ingrJ;%N55Mv8c_P>4S%*UaIlXfTd+Qcb*?Ub1{YahDv`TV~ZmnZh^xfAB~D>cYnBUyt~js&zy2cghGgB#n#Yo-O;f;rlZBd0yuE0RB1F z+0RhBjrRF6|CVPULTo(JExvOmoiK2-QH5?t*cu3G5W zW|~JX5mp*C-$kpEsO&X8*LLZj>!RjiDYhJ4K04n2bKdTd&X2ZK;v>->;UZcS!aS3T zu++A3sVEQO`bQ57i1wa0p-9rXr2S=!(kQDiTn;eVy4p}rilM2jGAFt|)>#!P+pph^ z&Lcx7Bw@^918rBVbb$)G8&?hOhtZavv-ql%kb<1M#gnEm)S$Gst$6hPZ0nzG1-Y^W z&?4m3A)yQw&e-O4&B7|X1?+FpVynJY4&yWcc^t3kcu*|wlRLZR*y~C#KM^5*h(5YHU4Sjjp&dyutVuL?&P!>ndb zYoPSpqIOCnOARadT4jKvPc1|Y{*3z>sMQs|W?VBGky26>aBJYPMD{O{l)v0 zwWu&85dVzg9)f^Crmp`R5)qcGd!X)bp{%$k>RhtHqcD`YPyJFtkF<&NL_p%M>@Cwh zxo?TK)2-a*Ye`n;7abmdo38z?|I($ex2MZG_Ot>)v9tnuPhuUp$Zu*cj{D2@0ncr8 zD(9L24XkT|%it?97e zb3s&=e-Oo}DLd+-a(lm?=;);Qj|yhz^>Y2ed{s-~xhAkOieK4`s%V6GElEo0#Ay(z zOMy-dV&yI9;D&~2N-R}a>KU2L)7q|6WbsVlVHY^fpplffWGm*$iwcS^> zG_=zjokpeb{(Um4aZ)u`32srN00;?}$t-?~3`rV)%>-(maFkNkO5Hkc;ov&#!JSsK z1w{>VM8SKTTWLP5aO&!seQG>}PqN{AV)#ehJ{o8orGOKrvl4KljhUu0YLvvYv0mocKm7J2w zn^1K|3~@uq)LkIaBO4ond-=>m#(B{ILv}&4aPy;NXx(`39-HipBt+opV38c1^bVia zrjhr%Tu=!X6KOtQb`=Kd9~vajR{zNz|sIPRJu7luiSeVVELCi&l$qwMiQuf3%i3DHd#QG}l zH|*#wrapZhb}U=e!=Nc;x%)D(fuq>$lG%6eyZ6Vg8-66=>64vTh}^t4Sw9(N6|oKg z06{^f^$qLP;W1rjlK1CLBxokjE%Emy0Z1;qhxfBX6p=@oNf`P_0=ydw!RlLb7|fp+ z!Gi;4BmX|1@>RmouiptL^W-C&hYX?~+0qmAf*Qb84Gr^g*{w4)EA{-Oq@)~}n3&2d zD<^oaN0`f-o0q&Ba9^?h6JUXVgvYkvzRlPB8P*?Nn^{$Ay@huU0l(Jt5m+M>cXP|? zH?p^Neg$#c(rvdCcMnC5z-%NAZMd}XWwc%*s=&u_VRq_NmpW7}qO8h8A>XWQ+IGK6Q(zgU6X)x>wFj$NS35RUJeWY#w z%t=7@JA;ED5@h%M(~U{pxo;ILPNNuE_ZV^UMQr^hC44^n=lG+Us;aU z~35e-#}_^jtS8{wbpb#*{m7@4No zsJ0~2yg>7|*KR||Zm8!(jB>Uqcavf zb*@#R`FSBqEra)-qowH3nkhq0cEuJm%xcF`-@-3oRP+gqa}ChYvV%*q(e3Culacw?<+?wO ze>B|&d8@YA3T4>8&tpXJwHgZK+@c6Wm3}!i+|$4#fpS^Sen0<6i)sgI%nkjJdIPiS zTcO($ds9EDmtEm*uobWR)&1R`9#jEXs4nB1T?<`m6{o$~eP!qw7qL?AV>U7vj_A)aTD`9e;gzemUra(xb%U8DW zQR)0>v+v~lg3FhceL;KhRRvYmUwaFU)Cj-M!MXI;k2AjY&>CchMw6c@h^Y-xC zMUa11Z+eUPCvt7P`RhOAnFWva`Otnowh}a57$(!6r^fG`dcT?`r<03Qi;L^VU#*Tj z&A4cV2l_1y397HLH-$r{(`HyLoOp~n(CKbkFY7$;5xYCpm)~Oi$+X@7FrbaD+_u!V!eVCM(O+vhM7nL(c;HBukDc!wU$xqzUz>b8H<(6=@V178T(Ace8w{Dtt?R9$}&{f zakvj7*EDDx-Ly70bjt89o`qYnwA8DHm~>A}gvv@5qCA&gZgl>=j;8Mxm$zFGI)=J6 z!4u6D10)=&_FzYH$0T81{<5Kh%h!c4B{piGmTxlL4f=z>+O`y!Pwj@#GoYkj+J$t< zHY0d;*ZwM|>aAB}&(G3AippVPvaAC?F2Vc++ByDRQsRJsMemsXvO^&Q6c-n_ZE9*d z(|y0y)iyUT#)3j5d++_5l_36wY7iy0TPX?={J}8wF*D#?yw%I?IjYy@B8q0ymJMb% zGsAH`4>O>_6eUNV0P3uvRqX8Uy@-9b&efqua8`=cNS2f2hM6S^&v;Ooy=)TJu6UCP zY-W*7tfroU^Y({?^}2SD6j{6zWYH#CE+S($v_!ZyUtUq z*2|qaxg%kTbK`#LA4h9CEhFU{8lffro`tOVNVB`;`VIHDqVAiI8pHFQJ#p-dCJbAx(kzw374vL zbzWIlzc&;SofaEGAJi(c4VpBeVpypkVbxzXS>0%cfcASEQV%rlFzdGuqG~rL#Z@p~ zIn|wLW}m6&rl3R2osH`jE1Jsrs28EP-uz z@Fxd5J3H(BvCK2B^~Y!$hLnli_1FJkc$@(r5GiMXBG&of;Nam68Z9xfj;X=>4e?T1 z$&$O=l5~Fg@hXO{p3WAfdn<$a9-RI3&-><4U8NAZ9St+;5?6Oz;4eu`e=m(d$z8<- znqcVM5QDe9#<&OqrV{YM$bp@42%$*g^aSmScP%IdyGY_cjboqEyi=gSGucaJB&)>> z)X8dn+2)jsYp033>Z;XBtG@PWG_@(rrD}F;zziyaOIVkdv8cYO(U}y(L*~dr`Ms88 zC9<|G3^B)Ql%cPpLG29+>4nktq;v^wlrC?H?bf?y4md=L+ZO0Yu=;*dsSQja!PRvT zGvfKGQ`;|$I%X;g44n&>#;+OG@Nx>H+fpL{DlX`uTY3w94DHK8v;y?4Ut+ATO$!H* zt7C!|2CJW#gN^N#c^dEBRO?;J&J+%O@4~!l6+Sy`n~uQGuE^&{9iRjNFTug}8c^j` z@YhUkFJW8x#orQ{rJ8VNtV^E(n3qemD5gt4p(L9)Em{PVLw_w%FPr@wvO-bqCkihq zh~^{{Fre4q&c7&{HX(C4WT2zRkOE+-!0)}xx8Jd{n?&}6_XvBOrmw&J(rk7tmXal3 z`xt5Y7e@en0cb^nd_ViTU=YbECBM|nRpOEXPR`_ksjq40p@3fzsq`+(S6U9#oaRb7!1<)22U)RffV{ z4IM9NE^24aYJ3YI#4P6!+~SAU*t#btrFEhoUey%CW%N>Ej&nc6z?0!i(W)dQ%}7d^ zgl+w|wg-DOi-O8r=ea~l)n7s{Yw*BON!3<@#YNDkEQ{ZLt)6 z2i{lQ)Esh9eSkE>-%*uP;9D*&XX6d>w`yuO?B37$-Qje-QaK{&e|W21H-ZQ9Vj?J1 zz-dMCUVDOBWOWEV$c}c}t{d_3F-F&gXZj_9Aef|!D2Q32>9%;%!vj(EQpx)=mpW89 zO2QI_Xj&9KIrXG!4UA!tOErb^z^u!q)-k2_U=*U`!DcKgUPjZ9@%L2WWZ2P9SDj0y zWzi;K97Z1G-k27>3hHUnGn2td2sF@H;4!>UMYuffwcS=IaT^}%&skQ|p%(vrXQAkS zfzBcYwP>QbgtK=s{A(AXet-TadG_b&^@Lrvq0+l&rx|?VPjPiI!aGdt-Wq~Ob`7SB zHgxSBxy>VX@PC|8FCJSz&9#b#0g@iMwEcLcVraPkd=%BMnl$ExBf+*4Phyl{q6fHq zdz|_st}JbU%}h5K46U`fXy~{;5j_FWd)6_zeyqL-#FBSULiX$o@ffd-11D)(%&K{y z94&}at0pNQt1L8uv*1kxULxAPrO)+`X+HDb1^g7~tCZv5nHMA|Jm;(Zt2(;~{D41t zlP(WV)^ikZGHaG%R;P48Z@TJ@?M!yttFq7gB1`)>bMDa!WPun2_Id$gqPc>fqVX3C zsub41d+!poa2OB+aW8teA!GbdPcy&oLW{rUQNo>*auIk8?>nMSnK4HPiXNV*22u!~ zU}w{fzlGev+k8KjQ!45)syh}XBhD~|LAz5SZ77Ye{8kh=hF4blDFuEiOF~e|7NuIu zOb6H;wy+)K3x@ws8hb$dH=?6e)NW)br19ssXsRC=Q2e+i%mi=m(whwNA)SvO><6T0 zRleOTberIGJs+xZA>o&>x@{+|>^ zek2rviyfKm=U|#w`IR1XE!q|G+%RZ-eI63bJ$cvEVOC{lqj4@B!_g8H+r7|=2z@uV zN>xiWG$xWGAa#D~PY9Ote!b)nelW&OPXx zkcq?G0Q?ZArKpZ$sVk($c{U8UbKc@A9|o4v&-1iVu$MoyEPq}ZX>Z1mb`ZOvc6Xfi z5^A7I9CcEQJlm?0+4wh=F5%gg=L#^Ds;i%Eh7dX@P{=tK7Z>l9KTK!8&6H`k%yGkv zNu#|7{3n&_0ccqZ`0niwZy$I5<{Na<_V?YoeI6i=gjH<>flX2nB3lp!BG2C^MsA{R zPT%4z4_^UKREaeN&(%uQ-Gw~mlAmn__~*XU&IPVO=W3L`1Fm;M2D8erUErFyb;^Z% zjNNcCM4e~2A*#d^LN-EWnL%%FS_1sz7MZ~(_6FkuK`bB>LmWOOqJHO)Mc_UZnS z=_kAFpeZZ2w-)E$UA?3?JT!d_anN4LK?|pD*Q%m(gAM#&cQ2p`Q$UR4%EK0V!!_$k z4_*th2%toeM*q!jnP(R_$v8ZO5*ff#6T-a;$}i<)hnV|;F*-87!ALGsTAr*zTowb= zM7ZYpDkfdW4H3k(hPhTjb>1nvjAi$e@wv#Gh7S&tOHs8p)-A5Jd<2Es?G$)SaM0FneG6&IrnvvyrNaPFF$6 zT6Q7q&Wi*J@bI?J#K>4XgbaSa$TKN(TY0oX!Aa2&!;nH@-~NIJ+z?oz8v#J5H$pHl zu=n?L?EC2dZ*Sm9Cahlaywg2$4qfd%80j5MP2~NWM~^f2m!(p2nFMn4_ImU5#R{u- z2CJoCukpXk)6Kc6w(*x;x57r(aQyG{(&KcCaF>DMY-c}}u1JR);Vtr?IQ zZoOn>mdU8t?|ow1?_C-wk}cD6gEsfmXFkcM^69tLT=70D!GhH&>#p;Sc*tUC+>=it-@e&B3iBr=t?$Wn zjoY}%vGK+p$$ZurC0Vs|PmpZXY-^&C*trh3V*8VC3pu_8rPLZnGLlXLTs~1}_?`0|ux{R%fHSw-zoHt}E24d{(1%NpBhL zT_3-F7x74@!L#C$!g7<%F6R63!ZOQK{X7uX{tVJ@n5d2_AQVX zg8SclMSt52P~;m$@7z0S`wR?`wS*_dXr}ZrlN0r#PCL+*>BYZ|O?QYb7p1yJNXgb1 ztx~Z1w4N@%{77Q(nL$#vynDtNYyUR>m{G?{P}$6bdwQ`(_qm(gf>TXDYS!4fwq&*C ztDpm!%2kHYubWMJrI?HY&*AOlM3rIO04sF)PyxlC$n43s{Lr{JHS)pInw zG+~Uk3tJqMFW<}{ms#Jtm$^txQIUAA5@d3XVfvhStVP%#7FDbI7-rJlwg;OgXXq<2 zJf_a=z${;_$d!4Yn;hPV@@y3y-~AjBl%h&ClQ?`#PEEGJ*)~x>3v{b@>5iB}=%`uB zq=`BF=2$YfjWhpJg)!bL|MY@$cr8|%Yaem!;E2HK^3zdNW0D1zfhU#SE$&qN-v4y{ zCVr_+);(|T%2X@o_QicTnSfgNHt|&ZIr6MZc^v2P_p;ByecJq67{+MxSJyFIZjyJ#4@NV0uJMR|KvC*s7_j=X8 z_GY(a`dKCL*kxH3chq1Wwyh2mCdgbS77VaaX?sRsjJFT`W^1#2W@|U9Gq!liSfMgi zAIv)@?Po5t?^ayolv8he3Ze@{GQv|Tz)Gm;6BolW8@ZCm%8C{)pLeUVk&$>vOzqN=hGvU%*$0@qSft>`vriGi zCkXdfPZ)inCi2hkn24c1wgPj&6Dh-VceT9D8EnIXL1C^N)l|Ia;l~@Sx1A7`B*qg` ziSbf-lwwHpt&?Z@geaH$C?LHU&V6f>g0B+@{?o+v8qR0G@A=KrpC+G;qnMRTb>Px- z_Ve$0&Wnlsmx5Bpq%EZ{tGQ8xndTlU-1;5`q|2X?8i}T+5famV{Z`EPoBc)233=Rw zVZN2nDES7f;V5U?2M({fs=*8oE8ZCQXGr4UA$^Q(;0M|GC&9TE2{s|Y0Uz4I{CLi> zLB4j-Mb)=y*#myo%DO+SYInFcUpz`}``jQDhb(U)efGy`Q@yiBfgm6Q@TcXX4So+e zOqDb+o698ty@wR zx|6R+2>gngOw=T>eTt^0g#nN+V@@A%111{Uwy5k)>&3Y|L@tydT(xA`mwsop4Gv#USuItM1TM1xSSYq85;#UAeni`-?co{&R7L#O zZ13H|pF(%d<>hLZsTIY($fc(T>p1hCIyq;`Ds88q4xiSW>9L7`oy#;ppP!CyYctoD zD|r@lBC;g>!lQS_bL6Ht{a!CkE(@tmDZ_Sh$!~5`)bl*^2tWWo^xV~I^<2xRTQ^o<9oVuZ{dp0(&bef zBp5`Ddn}R1RvJ>QQFNNga`M}hRotAAvh{f4K>6o}3r?xnG9@C8(l@b*+J*7NkaXyva))!kMi;D zoTgP*AROigvmTetvhv*P+{5`|LjZRFRbVsbKQA*w7=j37iwd4OG+$8I`9b*-f`biD{!oQ&a4iS!rFxzh{E?>)MI+dnaUPDXg(uy~%MO7T9 z$iiiLjKFsvDr#yWl+#G;3pV-s*x;i*Rt^TvaYQ*-AN-kW!nbOp&p*-7Qn6X4A-$;OnHucHz+~(CuK7(as|%;N@N2VgkWzbQ7pTTZ)ZLPR5Acq^f~t9<0&_8 zg&8lr`zp!%j;OGUuzL1T<1L${Jq6VgagK3BA_rm=0sjWX$3fv);62r@JNZI+Dy0Y_Dx^tXI{GlhM{pa{!YN$vWcenX z)vR#*AFpS6E4{xGP8QkgVaz~@WyBp0NoePO>-(`nrs`Ctec#Z54=yu+0T4pl;-Sn=G zoxsrq!b+4~Zi0gm(xQN7$caJC5Uk}9;&8f$t-EQ3j=x#5zKbcC9}LjhnC>_!_OU8= z7KmR*Ez&>91GZFo2IlJ#0HKKYWZE#=dWH~;w%X{El5w-&`+MOC3}TEy;e>M8mT`Mc z^Zp~%_bU&$t=EimSuj&K__`yfZ7H_HeXjjnYL$d^1O^1EeUZt52T%0-Fuw-)XUgw} zKXt2c$g@0J0(gCqZXtXo?tS+UAujYIItM__$Rv>XSyVjmG*u?c>D5w0R^L4Hd{Z5) zB5zzX_K@!vXotk z3!i&kr?1yS!Xl{|7;NeF5N4rCf)e>D!4bgy^i!dPV4&nHzktbi76kZjAv4B=!yA~(#uE{u zzbS$h?OB_ZlPtDD%CKGf`M$N|8~+8YHxAHEz*BL`ICI_8X&W~cp2VE3&Z&!X$VI1+ z1KBBXTW>7OMXJH*Jo$-DcJgAU6hh(1=NXgVci*8MJ?tH+Y#;^|ZdnvxZ`M~CLQX?|>@Ijg~lW<&}jvK<6h!q#^@)P!!vZ4v9Y zyCq6&BZ~Wi_t^=TA|Vp*;X06UM7D)YVv~S3$Eh$m zSp_{+WtbG+yR`aEb@Q0U@glI+lH;h%-sl|d`N+v7Z?H3AD}LMc+n7xVwu@@`mMr|d zksLVa6WA~9(P)hCE4bK1e5i-TwpY|ef@OJYl;q1_$&t#9NJUJ zKRF1NYBs-iJ{UpzNZ+r~RvIPu!X*Z?ifMpNx}}C!BGUZaz6b1@g58iYh;Vws_t4HNRna9471@tOo#7A!$;Sx(qo6|*V?#Wt{1|h9 zNwQwZUM1Huvyi3z!^4saZH%Tem&dN@nnfAV*CKEek^#LPWy7-44Q`(smg}*+_YCcX zzu*#q!GRUYJA>aTOM6x;o_)V5l?>Y~QWS;P+9y!#>5$G*DubX{P$`S=1)h~ZAzsY>Dr-t zQanYdmI-og=^5jy2A>qf$ZbU!*LXzW6W{$@$G30Ww7Y=v`phr!A93<#KNYdHyaJHX?+~*l#ehuW8xJcl*7lLQ>TvdqrXhcEe9u@ zEmGSyGvl^5%b=54<6A$tiom57VrM#8gH{1zYk8s{1s*VmP##_^%wO&aoW=W7+;{Gs zg+K@En#%|q#yz1lZ0u+BGW~WiK%}N^8CVq0P(|Qaqn0x{Ob#O9VA2c(@gug+OvOfM zl7NJcVWH35P8=CnK(VUlQgI2RWb*p6)2f9C7~bJ$dyI(i@Dmck$I#I<=6*#bC7zf| zSiT3pw!0+@g1U?Jf72C2RBTQVNM2oG@dan!gA{)sDF>&`&s!h{B`q2Sx<$$2eoU1x zar*5?MO2N=Q#d5Vv+{Pq|6=Q{0^*96Xu+m&39bn)!9BP&!6Ct28w>6P*O1^I+-V$w zyIb(!u1#=v*Xi8*?#%m`zy3IV_Ssfdd#zQqtyj4#ls0877)5Nurzdq3M$|itR4|Pq zt?SH277LTm!QW6e{Tzsm>>xdSM_Twki$R7(NMGivX|#*r{A%ULtAO>~hCE)5+O4yq zswg)Oo}(@+RxX9qdx-L12N|+VP=`poBCW~m>X|I73FSQ<6Rnug}+N-r>*%rDMAjX=61VyoGl&ecs$T4SCc%dfCVkxQF z<=gJdPhRnmhx~TjQ=@Jp5KIAKud;Hak&ZDD!oY4?tl4^khkO`PDWb$dyyZ%;7WYNCcww6DC?9`XprOHke1}0< zWszu&V%Y||WnAMk083AI%hx{&6lndzN8vOwty$nQ)1GRSC*dF{rBW^e1{41x4i3Pn zFD04CDMkpEsR&5wAu;jX!e@4dv<=iNkb=5$$lP~EH6a;;`G0((?#T({^eepJ^YIz@ zRDQ&9NyU@DGU-6nAP)l3xMsuy8Q~Aq1XpC`_ntZtrN6Mza<0+syy(+Aq$sDc^;C* zeJH2g6)o=FY&>|T!DRuxDksx<0br%O{ewj@02tRlc8g_MRlcI3;SKHP*sTKZ3>=tx zUgu~m#T1!$1;IH#!3Bu(lIBx~!&wbfVoQbi2+tudSWVv~gcjhHX_nyvv4#x!rvsfK z&qMNBc}Var%?5pu`{UJ*!+!DlU<7AUG4h$}xRq_~!*8-s9zW}B{Hl>Krx>LXCyO=` zoqZD0t87sk_U9ht2cr_#cq53q|Ka$D;hPBFWRm2F7hYjgL}YBh|E7% zmy3YJ9Egog{3}1$(a>st9RQawY+2eqQZkZ+7tBRW*P@eFx|l~={0XYANA&}D7t#EN z;Q(}PTG}O1DOQYjCPYwO8IKq0tf2Y3O?GU5E8-+BsPng5ShVyHAE+-V+AR)(!CD#) zU4uYAs5(oYI(ZGv!cai}h>M2aL~N*2&K7_LOpDKqrpRUzF@@N&6tss_eBGTnBC-LB z`X)!T#%jH)0ePfDU#)c9mV#@$DfA+dNImhf*V>{8_u-auqYfA5$oRyS!k)I;2P7br zO)aUZ#CMi)$t-;X-EB_JEL~WcZV2t^uO{byl~)+g-lIeWgIY5d-h`{ppr04{2Z?yW z19Kj$ojr2N<0Zn3aVkF`LUt!mnG@Lea)JPHkmh91Zkmf%hKa`WA^!+TMqOd#vo@vY z^rg8y4af+-6I}5i0WtS+jZ&GiaU3YoE7_(7@GcTNa{L3QRO#Cnlg4ET^5Df!%~x1Fo%R>SMAsBK+Wm}PoVti*ONi1c-AnG36PL2g>y$BZ01N@Oml!K|Qb&ClYD~6J>zJ=~(?-hv~^pHPXiVhUImB z?!K@^_C7u`Zhlb^O=wzegL9Xyi$THVYIDLSax8ZK7pd@RE4yv-lZhMWo1jN2zhO9x ziU9$Un<$}^(nIG@6wX-ypvd_2y(^R^+zpv%NG18FEE#c(s?616b*od_5{YNhYq>u> z8a97d^<2!R;;sMP{VH4M-ZlR;<5b_)QxUU4^!W8zqv5;f-qelgmTFxl1ZVBFpSt)_IO7utoio_(Se^`{_gGIEj05;t^p# z+8picmtS!NyB93aka4=@!TSX~4mJ|Jg`@{AOSRugVQvwf0t2tI2z&DEJGSy~2+jhI zLujyay18B5^2;BJmLyb+AEZht{aq@^XSmnev!{swd+69#qI^#xutOhg@6gACP*5^t zxg0hxr>44rK(dZEiX9hywe%T(WqJCg0}d1fbRRZg2JKsn5$pG_<9o3uWSqvT3A#vb5tK%2!A%)6~z-Tfggx zf)t7!pm^rgeH+U|;Y0%MyKMd1{giQv^d|UC!u7LWQkdXNAv_vG?l05`7Wd&)Af~)j zoWgB7$h}M>juh>fHcU#n*{?*Vt>haigQX%m3mNIM`nJ643bKp<8|UY7D}1|ial7_` z2I&C+96skf9Y~Kf?>IeSK08NP0y0-c#4CJWiHQ;!j-D~+_lLy6=xX05W(9s}BP63? z&`oM9&Pzq)x>*m2v`z}`IqsHdg0NmAm-@B2TRQR>JFmjS z0tv8^T@A4D@zkMi{J9 z5ZIlE+`5Nng^~frmsGlfvk-*jJo&YEMi5g>j>7>%7k<)5OUU|VOm8XIwT~Y&_fVb@}dyhUf62;K;Jp!{qp19ISdyFYM+sQ5i9mSIqxK z0_!4hC>Ro*N@aQ`60%ryOviB_qZT)JTkJ_>k#o2w@OYNBnlNcNK8hPOoUY!rQh4O+ z8)ay&V!Zn=b`yA;hwu>uCYG*uWe5N$W(%3~f1$U>z@%2Oz-QYHD&5@sTXii7Y$Ey~ zAn>SYfzU0TdLt~+w?&OFknkZoUk$Zc25a`D+|E(vr-i(e43<5*cUR_WXwQw`o-ih< zWt$TKd1>tOZgWPYetCJ@;^yJ+F34AsaNs-6#B-?Il_~KcN-kC%rw3BvH`5F&5ZbqC zLd5*54x>u?hsvYJKO&e(<<~D}iDPa{)QI?e!Z++41lVy{$>pFx(9Qq^{>3&*W&RrPppDt5DD%!U}MfX}X3doFt+6NGfsmbuD? z&-xU-qFfh;-*(scWJoBL8I6Vc&${lo-+xHv-Cz6@vaU}ITw-2yp`8se{GicEc@fl6 z3%d^&3GSLp+Es0dfc*cs6GhbT0bP#r?v}UG$#4t^#3ANIo8pcv{37V{_sWTaDa1q+t+#kUXQ=s(K}K9v-V(J$d#u= zKnP~47SAy9dJ7K>vV8G=#3!MFP-z{>g z^lzLWfBN2S{g)v4j_Yx%@bANoF(hCs|GVICy(~1lxFvWnGL@ZEXb+|m*8lmZ%0CFq zYhLjDssw7f+$$6EA6oby=b||C;cjq~%ZtQ8F`+hzA}VSligy zy@5sJzgbX)NdEVV|I2g3{B~Ylkq~lS-`W4WH2;lLFk4_Q5SW^pnv|6E1sRjHs-d9) z7ALn1D%CPGkosJ(ddKkS?%tO3klL4fe-d`MZS44w;cJQXHrr8ntzxhjHl=L_|2}j% z5iB;Jje$*R5%<*B)+US$k4YwIW?*3Oyu$dz@c(rl7MaPyW{M-$b?p=?CGr?ZIws1s zcUX1t6$RxAXKMLwS9x1#<`ODB-J|etwD*i)Pfv8}ugw(&AtHoFM3A9S#^8V`S?sSG zev=!L{;#hTAk;P@Kw#dg%&*7LE1$+Le}QZonZAc?tRBb7TN(qhr5+h6QW~;;Uy9sJ zU+L&@q3d#AnaBi&AiKat9oZg{F#ebW9j`B+^eG=1P;w5VT^n@VijGpb>iOIv z>Px&OvZhe!B|T?QrhstBaYrT$3LGg-8daI9r8fI#Utgih) zXeH?Wos^uk-M(zKz5i{g8wyLP$mBNttNyc82z~yxwyjAiJXXc`y9^2F-vEkz+s2!I z-9y`-)5~=9_p39HfBKpb1lCc3pe0&wk=J~X{KV7G=imEEVuS^jwpe4R93?tF~}grjT|s3xy8q5IuQ}XpO%@;YgWJHTp8%#m7-uj^1q&HA&%3ca z|L9{7^rc3wDQjPZ2};0fZ1?aAgdjMz02JP_!9*nuAT<>TD z$0&0peQ+4#V&KmaXEFilzJ8sNzrLE)4^~3z9o>R&52FQ!CVvK>JCLp`jp+Re>!|D_2ckj^5e{`-urjYu2x z;MRVQ`|By3tMK~g$berk@Ohalyl^Qnli6(|luip=%z#C!?} zqDC8=JVqA_d6zrPlUemzrsmk7_&{LM{z7}^mme_m7Pp34!73632Zx_DO&Al-#{1E- zBzEeyoO8;;M;QgqPDOq=Q)D0R1@Fy)-6Uaih}jU8^9tpJn+~!dlrcy(t>TE|ZL{uh zQEQojyVqk5z|>a~C(duu|CTOkY6Ha4pi;VuRJR0qb&z2?fS? z^3D8OgF`}EtMD$l>T{lu;a%Z3BSRIE{wZabPNER?ig5cS3G1?;8C7ku-iSNi@CIyqCXs?^MZWjlQMcZc~u38 zi`v2co^OBpEW={kh3MoH5k|@h34v1?Lk?`|{@;50i;cQ3buO+@VIDE*RjE$vV@+!Y zUM-hZ!{z6G8aL%JI*hO`Pf^2;$rt1?N2t>Yvxj|*BI?QHD?bv{Nxr(@^l2mgm)GH8 zgTwU532|%15zS^+(VfTM$2o9v`OXO z-n-k=Sbn8QLDLVvi?-z%N9*n;Nm}gHK@rpNSXy?~4`{h_9q@g6iPPYvt=(dZYSlWY zA*;YZd>`V;ZUz_Z2YZ=~)}^%7bKk~Y02k1czKF0OqWVUWbOkxw=p><*g;4_S^Ya$> zj(0l7M6Wj=)7#k{=Uq=98KE4(!mWhRxwK!+05I=IoPqAa`Mkg2Zw(43<^TsoJqRD4)ly_+aW%)1yWPNkp1T7CN5XIWc=`+%QJS4Ou&os#Qj*1^!Hs)D2at8(2O!lrR6=<(BxJS(SO5!_b zDbb2O*isKjx%6Q-T})3op*r*X|HTMI*w-`z+y$(78wGXgLt{7D$&_9D6aVS4w)PU2 z3XA;Bgp4{WjX;#KM4OYxB@_!vE3JAq?u`$E;UD0yQ3WWWzowd#;`OXiffQ2_g$sKt zP6wALLREInYGb)Q^I>EYK2<&YS67V04*SGIZ!@LBhZweJ-NWq1U7Xy=^!HeA2l>5P zH~7UuJ80fHD7gM=qTl7>{E&|~-Z@=pa3fcy|N1TCO6IuhhHpg?tPec^_Xni9C$Uztf&&r^H6QZbtGgk3a;uBDm=L9$67#Ie7w^8uomPYJFnHUSYZ0J+pu&>&Ri z4#Koocb#-f0_>ANI%5WNSidOgGn8%?CGu$<$y3lE=6zY7%3g-mryxAW>GKPZ5DGVf zWqNFWloA`mg5ayB3{rXJShggQs1~N;)q9Y0+Kr{IuBIqO!`UGj+U?tzIaLr5E2oUJ@pYTw-^@{ zM}({XTK!TTuHS_7n00KvaMs8iI8BJX?wcGJC7M!r?Uzx!6@|=%puS^0%G_A)e; zRhR9-{E@g4M-VJVOv#}TV$G)TXvh9Ii;|7wNbWNv;I&q5Ytmm>kI3Uum|YLY4B6_MGQ9L&K^ikwdbXoMLLg*AM(X8NdYM zf@);TFr~3GPC(=i*7FUo)RpdO164L|HFlxVy$o9(9vo1=SA-NB+tl<3aws*L%|%Js z)rw04pq1`QEAm6pFH#hDvHNl8eL`fHoXxz90b*493V=1a$km4(kX!3HKJ+Lh^4+GR48PS-^!HD-8|UVlp^ z`X^+)H;G^Y04=2;kVn>#8v(m&uW5yfE#(J4$z`%;Bmd(b2F8r9)uSCJ=w4%%%hwM< zs$62KSA03BH|}r3=@gNqN&#q*-y*B0%fUR_T zChpNd)A=hB2Zu+McbQry+?6kFd*8n{I6Oz#XXFrjFHN34=RNNzP``Ib#JT+GZ5EwQ zw@yE6!t;X1epeM)z#?MWT<(AL7%okQ0wHTb-yM);%+l)9hSLKWR;eXm(Nr*5Vp@ztPOtKU-WL`_tM|F>v-$6c9^~d4;;%%Y)ZQIN^f}dj zU>@I>aoASUIOp3J%5Yp`4*-N0p0}-zz_`Xm7ERT{x!!%=mkhm?{n8m-U&lx1S4H%g z!t}Y?R3bSnB;Tc{KQYJa(TR|4qUAQM=R|ES)B2MNY|1lsYn#NwHgL3cW&*iM`IprY z!7MfzyOkcB-{i!3*Wsbozg2#A*iY7*SBlXByrY{d`tVB%`n^{#LNzpKcEG*ZbI zodBOckh8dxkj3{#kU1WO0)a4*Pm>)86tKs}gN>%{O&QVxaE^@I#i3q~*UCJJsztwB zFQXR(nIZ*IzE=t8(rHA&Zt9sY=fQfWfCJ%xx&~CNtlm0MpVn5q#^1K;1cv2D3Udm; z-%x_Pa@*4-PyHnrkw)OZAPY*@kYsX?G2VEZ^yVJQO6244H}VK+h7rETFE!2uqAnSE z-HgVUb-|^)PfO-6fdf$Pgr2x7*KDWhRto^Wf(1YEpZ1D6g#C8GyxiNHWD|gDG`Np) zOLO+Sah^Kvc~k5$tD3FJfx51XmatOd#Gdsdw3OkBbTcnR-QC@o2K;~A=H^%>nj`^@28jhD$$}hXR1!u}foDb2TJ0EJjWX7DZ5jaZKSki-i zh3t~8KX7+zaweIOZfPwcE5W=S1qJYH*SFo+U``3+KWeU=T8fC4jA+Ko5n{D= zQd%EAzR)h?~P(<=n>}c_5<_2*KTOonY-rD zHaS!^{cV!R2}~$uV_Jcop<{aWn zWERDh(YQ=E_&2AYq;;EJ3z7V2W=CiS*B16q=H%FTD@GHk{NfbFUl<9xLpd7vY09!# zN#$Rq7S;lK;{LcgB&18v?4p={G-C)wE1|Idc`I>oDnNbgEKkq%(`kq6XOBoJ1A)wX zQyDbw@sKL%J-qw5h(9}`kL;iDkaCml(+@YwU7Rc&9v;$Xq-KMaGhSz$lc(x3{oret z0uLBTt###Cngx-U;Ctp~ai?v+6=a&p{e($R+&GOh42b=Xv}Or}K5V#A|E9LH%J-dN0$d92 zAG;m-)9Pd&&NB`U&Kkz9?|;=g{aeWhzpB)3++E&Fn#wK<1I5K=gR?lV+&CM7i=~qf zMyCl&6%;StA4*Q2{dW-$~zVU8Qe#X z$Hsb%CO>&*_;eelkayTpa((*U^j?PFK8`9;)CNmL5f&wUJG%qRue%~5c({kYPi83c ziCojmm`lX+8F-)NUbH(mf4Y1EILlqNsUJh?JJJ@yB{8!Z|QU&j|Us}~#tbcnQXi_k+E zG@=l$Zo(fsOH3SX$PiLpdWjHb`W|_Nj2;r}nXOm7SFh_scx2|g)j?WnKC#!8xrKiM z$A8xyg-Qr6k?48Pi`Yat--Lp^Rm9(K69NgHrcb`|* zfbO7Rh=leBZvcqWne9`94?zcfj+~~{)11Vt^W05~p_JjE$9On2%3Gp?Hxg_=So+Q460*%rP^uZSmYKrrQ9>`BHryE2Br#%I@m*A>D7ixR)Fw zL%aO`fPKing;D;5p;5zE%EFZErO1WcI%>4-VIN8J19G@`lx z(ajs6T+R$-Ne9vkx?5wCE3*QT6TMi) zU{p~R54bBTQNoux7~pLDRLC3)Du)ZlG8y4S#zUyEV0wc`X`21e=DW|Hc`YY6n1VR( zMb$0IsT99eSKEs)&$HKVLYm_6=iY$HCzJ)ki+L2yB5*5=M^EvXCk-A79(b8d!#sHd zAfAnW5_BxAQRAl$q-Pz8zqxq4N1VPc4%pZ>yyz@RE+lBW;Uw691|KpI5;@E-_35M zQ%G7km@RvLRGaJ!I6&<4y!orNYUZ+|)Yu;WvUyco)|I+DUb`&j);>=p8=GZkWmSvp zfBwB(uVd2M2J?~I`;G72p||=!N(Td8OIKHL-2nO(1PYI`_{f*x{|NPH0qH%9=camU zHanGIUqP)~vkXph$X#@uxTvL&3p`c=6KkXvvBN?sGFkgH_6OZBWO683^n`; z+?_T67$$hCB5%J<*~G_(P?NJ9>4siY1S>-#;fjNZm02eU&A)rVffBgf=f7b9kMZRN z?6+Kn0P9dBF;b5S2xH9D{*Rny4!{@aop~T7dM07#OPD{-MvKlEPNL1WR-5 zXaLSi$Zp?AoTBVVGVoIpmD(;CZdfd>Xh`i52y9K{s#2T$rmnKqglx$zKSH)-XczT@ zRvcf(>NRLe>tGM7Do50e!})PWMIc@otvSmrh_Y2JWIZp$Y!|aExX^NqM^Wpu2HR#Z z{i}ggh9Me8#M)TV7;=g+h4F=&6?ZtdoU~H9HvSb2nye%R&Qm!uhv?uZc^1QdV$(OQ z6xOiFKUDm0$PWG`JYq&^@dyc@@9Yu}g{(obswj==SO&lc)iOnYpncnwIUHDyTPpI} z&u=xWZ#-rh{P=`U?tDa#MySKubh!*fkT>YQK}M0R>w?<&1^DiP4x7U;6D)GwXPi?^Pr#816SntDxeGcA*cb z2)qmsa3$z-CdF3zvs+}lze&9robBAd4m!sU0&;wRIYc7QG!=ai4vP+9b6P}OH(ePj z+wM9GNn0tkUci5xl5>b-zwPFiQ&gN=`^`C5a9dNaffSXI1ZI0E4}OAo15NEorgMDF zSoIqJs`;x&`kkgjwYUFMtVYslqZNe3ZzIB8XFmaVxfCb^eSCPWP4lfcX4{OVdwyyD zXNk4_i%q!>`zy7hGtOYAMce!F*N-auST?@*v6W6R+z#qoZ0I7=8_FL_X%Lkc%Wah# z6r2f+KHTylTj`i;bWqT$cgc_fjA)jRk~!Cf5sr7l(!ALS;SL!n9iqZ($nX~?D!!&% zF_zwIh3h2feps|wSeM;&UEk^tSIlB9!V&bWA^j61UkO~PSZ*Fx%U~##rn~bJh+sZ> zZh@lH{|G(INPqp)jh<2Pd5S$B6j#H04e`!DeOImzcGzyQ*fQg7c{Az0V~q8?Y#cu^ z&mq5Rk}qa#H%U7X(#@}Ar+ax@;ko2Cyx8mXj{B7<2Gm;zyaRQ>63}t0ILD^90gG4~ zc9-L&GY)ejUHt+AlH|9p2?eauT9 zkxV2PPB0n@OWUImdDQzfeY)180BvGb>fzf?iKAE@Lx1CKUnmMGcu`E);w7ZBgj1)u z_!@JW_KS3ZQ~34&Y5_d2u~rx@YT|&u^|)`f{(K2kl=g>2e@h6|yNcwS%_cI(E1z%r zU1BKy^9Z=;qI&|T1^5;|u8g3Ek<=Sc)AB}#NM4L^wBz^g(9Z75h)&^^77)|*2a<<2 zEHm$A4^qv95o$NU_9nlBOVi3kKPkgAXxkFAQP!yP>AF!kEoRNN>a*PlX;A_k+y|1r zX<>74#Lg|lzUEF}944aWRu|3XI?5FP9eLrvFPm3M+hiw9l&e*9KmfhgHP#OFoKKVu zxo@~w|FLb^AAr^ew5w`_D{3e`+r}y2>yo8S`JnPuO4h%4)?2swz$$wHhIit-fUMq6 zE!Q~>L@bF&Y|fKSHp7_poBMJ9wK360TOrrISXP6U8AA_oDfxNkYY9OCYvwE8aij-6 zfcJTm&*R>%eQoMx;o_Hq&FAUH*WSXh3`-(?&xX-Ci$ox5yfnRzvphuPc~4dE<>DcN4mwA zLg(wB6*G=^0vz%=Ls2TxhG~(=rEqvUS5~*gE-I+d< zGAoRL?tvJv|Ki=&CsuoWWt+I^N1HNSjd*=A%U}leBG%y&ekOzjeGbwy-*m&o^9zi@ zZ)!)d8X1m)nh^;rFP|&3y1DKwaCYPcp$>ocR|V=lu1z%Qe_-6vg9M>E#kP%@pg&0GW3Mq78%o|9YwZq zl->pvX}AxP7npFA#N7CtAhniQPlmIh{U2jUaRIr+D0I*Qi*{(F705j>7dfTKA5$?0hB(P85B=Io|yFs!srDKSkS1X%WRB(Cjt~x#rI1 z)XiA!s-+olgaZ--81D-plWTt`Tlh&Z+JycX?a-a>kYu_wh4983;#it=&s%G6$)aj`$R*{`~@G6wnBjkwnpe?rl#k zfAWS}6jvMIz(dpZ4Ko9S+?6!=!d=EYgdlpTcBDeg zXr>Qw?$=d75xLizq0htDcWSz3e5+pzKBv=#ycb$!8fH2kfW8*&esFUuj@6MhAPp~u z^6h3d1O%*6sK$=9?Y4HzX@sNJsWe}CP9yR&wV-GEWxC={8nqwk!vEe1)WC*A$oUpC zkv90YQOoOXNKE}~CUF$G%^Mr?Q%2DH0KomEq-dk?Bh<^iv1#)UNCMBI{R^2JSk)`= z8W`{{BA<1=1H_J{bWbRqz7oR8xX+}s`ymhU*`(7iNr+#Cmt6d{|S zHMh^6BO(rj8O%$dQ$DPgr^Js#1h2b?T%L+fcrfm|YSe{W4SBqD*Dik{HzPSiKl%E3 zA@sQn{tW;K<2h;EG2NNvJ2(5Xy}vi<)d$qjGquaNP>>mR9LO#ID&GLoXYXc{VuKn6 zO$(>sBGi?mdAxdmzK+jJRO~WL@NW>)TMc}_j(IJM!D%2vp2zw@RkfGZnYc0@zu7sf z`FeA@>PNM08VPv2rKpSOQs4yTU6ctakeG_H0iat;{xrHhyY-2R##ujM5i~1tt2vRu zx@zy?P4jL`6HOex$oc4jD_ZliZ^4bywdEcm|r%eTIv9DzO+M z7Z?}_0{Y_1y54g|3n~&|6Vta#QS}FgqqQ6d`sTSKl1clAmF^DmQWFH1v+{{PQ`pl0 zlQ^Ma8x~1iTBo?&Un+{mZ9T3YD=boN25whd*9BA8QBDWG2_ZHR+^o7`Yp$zseykNP zFk7Oda7llgN{yE_wDKcNRe0BAA4;ZKNFB{%q7L}gb(7AJUZ$~52GUxrfj$U*tp3AD z;f_$3oQ9BJ*n!H$s-@4vF{mtd`w;g@G=)VpQ(@+!Wih zE~Vz0h#@^V3Juxs^qp8;jPHq?&|}ZN+gX6N7c*b8eU`9kTl>XP`pvM5!&3AptYG~K z0%HUYXR!bOWqpf?D7#D)$!8a&_;jl?L?Uqs%bNLKo7o|=%Snrc^e?lSUX|3$sq4jG zhT+nk&j)J=D?o4^tL2D#1?g22x$ zX(cW@B3Vw)C3^DbkYIAcuZf8%q`IqTjJwzg^xY(R0X^gg(3Ex^Wt_%eHy95si#2$q zWY#1ac00q{JXU+<-y^5bHjFc$6{9k|dy{>PD-)>1=}Z{R>GN1W?n>{2#wGnGPI9TJ zvqe5SF(ZEODh0HGp{uE|nk1xc_OJT%Wqv?8b+>)++P%YMiO z5D)`D_O_GcbHrXQd~vaV;ND(_(rtIli}mIP@5oU}pGZXi-LZI?&JN5&4UH}03{ga_ zf=8^rkF7|IOD&ca705(3`$O#=&W@A%O&6`HJ0-BG*Cc>#eiE1AWKIIv_H}3egP-_S z#P9=t(XcW(^JTOJB|i0qB%&qrhpANtwbA8bmrt)D=-42))PmZ?+j|1W14*e4%re4n z#V+9~;`5*4#f{2txZgi+ed6B9r`l2ygVH$3r72uR=;F0$k=a2QxnizE20z}150E+@ zObH=~cpR8#JM+TXzPrFMmWjo}_>tgF!*PaqFo-=i<;~^xQjdA0to`fSF$!Lyq;xUh z*R6x!tax*8xHFu5J_Cf`P$1Pbad%1boF-C?6uG@IPb!WMSEtXrLf?W~rA;Uw6+0}2 z-wEP-Y-3bgqE;k`06MXJ)Xk>f^3EiV8R2mtSGq;F#@TOb6-z;}Cz ziJ&nQ#qb1utwhEq7V6E5Vh(-Jd~u2iq|6HVYGgVw>V>38BxSG|j1{c^fjBlvOwPtV zT3eB);UU+*DyTG)g8sc)&75`DiccV-x$~J$-o$x+D*>9a+QwFn1#4Sp>`^t=Y#UZoJ3E#PMNz?LOXM1O{m;+i7Z{Srt8nDeqf7DN) zI(`O8-hT7TqVD1~v|BB%Z}REGs|h-2YOidT03wK9xF;1r+!5I3hE(iUI!E#b7fswg zsn`2WJ@XC?NwIVBRyBQrGJFXJ(PTJO&@4=@sh?Wm0k)2EwkDmvvxs#2lLC(TGc?dJ z5-NSBb_qAfpC+)xLcs99c#6+RtciZ%bbYZ!Kf=6XXT3u; z3b@O)_&UV)QHibX(IIh|<1-JMW;o)d!&q$Y8U3lJ^q}>QyLTn~FIq<7{YY4!3WAlWI`T)+! zn_NAMKPkqZo}PxEs@mFCU`3V7tE*Lt5H{zhL&RUct(m8HD?RP6@>=PJ9kW6m#zkJ@ z4ZdE|v0WDVJ+^Vf?Xabld<&v8)LWn3O4&>_$3X+ z`2qL6iy@V|ABagGUMXMKhbP4dT!J*fCv1iRX=?)EBcGHXa{l%?zhpKrfWW&`M$JDX zs8c+TDZH13^wJGT)P7-=GQ??J{KaJEQh>{n&+QWb+XjXcA)ySY5oh##$!6G*Jk>MX zI!@jwP9lY4yeP^pmmiBj`0m<#v2eZgtlN~>K-I@#2?C9a~9$@xQ=Vbx)Flbro4Qk{ne?BXGBh$(~+*Q;C*XN!$>bDF{=@fc5IIfYca zkOuiNkM=Tf(^;{L41V|nxJos811*s@0na}hE*++b-)FrVlSDWJZV~Xs?WpZiP2MG- z=m)$Y|8SXw_b;0XevT&!P{1xAW&;KIaZ?O&{$A%-ukMR5G_Kobbmr1D{Sm16+jfLo z>>M8@1AdB*qpd$QSSPD0a_pEZpS^m>?;WU%(_T z9yGg7GWQ!z@k~BUlOm7P%|lzvPy5Xz#)XDbHRpRjV$>k_^ZjCn@1tc@NR9jVuyR~CJ%v}d zW_!cj&9Ml!Dp81db~};1ryvmc%izd12(#xt#Gt|Gln}&o2&$N~b#4iJyMdvO#_?tK z+w3enie>x2y(NmHfV=pib43XG5w{i84Do<>(w}UC|^q$jCJzh~Xt2AL*=!CuB zT^7u9wpf=jH`Hs|*MTbcI((CIRpd?=kO#!nrs%mPeX3_ake*z;Vd3&4KPDnJ|7G6m zx*h?r1GmXi<#*;FHzFCmfk!gviZt+C{%`E(k3al(lqWNo^BoAiDdMm&MQj!OvrW3+ zK<>Hus;H=c4)iI4jcWjKDU1Yf-!XkZ>mqj@q#k?kvYg?)4qSOMvYa~ zu0J<#EC(=w^KK9k0JbRKkFXERJMECIus6q>lqJ9`sU|24U(Hr&;_Q%xz-dSiq&hB! zx&3blEs|_!Fr!fSa~H(^V11Jda6tH3#i;vxBHv-Kdy%C^BZCS+Nh#uif$cciwjDAK zf9?C%0Gh-)A3{Z$siE$>QJ1x%U&(S-A=(-w5! zXl{I5F`mzn?pJ7#iUu{}a(Y~vD>+Q-1MW`Wpq!1xXU#Jv(F&3pynDwiqz#%aA)ibL zjPbeQP3NyyZxpcRS<>VX;r?9jrMdk4dL5ei^&HrG7GBHR$uW@SwI!wZGG%@I0lN?* zqx6qbcCCvdA(#AG5EPAwD^2q4eo$>zrxI>)@Wxq3sM; z@KJ)y-Xi1d0z;BQSt77iZ1Ab)^H4zFhddFm0Rr!PIxiEABKisOi^XaBXp3vg355wQ zNNG7mkRalIfO1m%Rtq5KHZ_jwmy$yh%q;gn+q(75!jaR&KloH3X>J}a8!%;g$#Wd(sz z_CzsJ2E_-~dx=+`u3`{OSe&-nK{?2Y@wrVO(}gKb;Q=TC0Zik{(zyu^Q<&%)T#?G( z0D^E`2yc>rLBy)osm$&gGl}sTm2K*gh!C?!^@K29uyRw}cCUn_X+F)>AD*3U6qUth zc4_*VImjYW>o2}iV$=2jIATiTcG6x%6foF0AF016QnP;a)@n}wQ?htgkqKC;mhJ3m zg$xKylkDtM?vLGgjqht5B<}owSo^BBxVB*1?#3GT;O-JExHe88Sc1C-hu{v4yK90= zf?IHR_u#I<-JQ$c`=0aNA8=p$q1Re-)~u>oHO43@MQ&6yI#bFY*AZ)OT!tvm)R*)HWPEY)00$o<0Co!hj{r+ z!G)WX6)Q#I`~3IXbt8<7jLVSym5|Pt)kWsmw=Oo>(;!JPm6DNMN{g+?L%T@*_|t-r zOJA<$B2i=KY;lLdV4#sQG4k`HdX~OnbA3ugQ)m?#DH$hXdNdT!#H|>aeeTdUPeT4< z6SveRzj$zPQlRGt!Z4ay@@=}S01_BScCIRDIZfnQe{5RJ?8Y@)+5l^`{W&c&7eS*% zkMEdm-p%$3Y<|Sxz$QXj`5>rY{SCsvvZV24hwo*IyEuWTE&5 zQPhSwCEIu%NNcgWc;IB}q8czCPkO*ScDSM_aXRnRX1Rt$tl+qOSN!I9^caMy6xL0Y#Mdn=C?Mp1?>$K{lyHdLW82*N z-up7pHTQIezfpCRgFD0~FRCTE3h+ii;G-+P}0hKk}brJskEJ3VIr z&`NUoE(nY>{H|!Za(ar*pw7q_bAtR0cNnGbFoX6@l?2` z0^rx%CLo#VZ~P1djj&tZG_+=~ozp3BsX{&NYwDc~3k{-Oup5+}VQ4k9Ji_rXbt)c& zScO_YH9uJY9=2;5V8M`MrQurexvcKDIZngDRmqvC2TH&yqWfl|{g+t={R^UeC%hv8eKwVaB6c8Fca0dz3%T?)v^3cqL*a|3x22oUsap?!GI@y}$W+ zi8zvU2?0?yjtB}J>oKm=vpeERhj2KrjrZ=EB zs3M!xY5$w(!?a`%Uu{QxW})m zgIr63h2zY4@>`m{@IDL(RPt8Z(O9z$Ap}XtWq;xLiqFS~J@(BE$Hcn~iiG2slU}Mh z2gbng{#Fp)r&Iv-PBx^3^y@ugQoM${9i=#E747jy1{B7*e1<@dMKQ;kHkc0jQBQDk zq1re$;c+=3=Shi~r$~uNS8pItEC5y%!q3QUsPs<9$1m`dZ{@XkY@BOa%bs*Ic|oxdH;z`PrP z!vvkB4D-_)u1xZ`c4RoCAMc33_L=}C6nm6A3g2ZQ?#Xk96AHrxW~<9_{C$nxm`K9t zg)<=*f{t+(8jPY%X(O0*ML?;uz0YALgPYT!9!1G&3M!npdJ4@|<9!&RNrl^br&Dla zMmW9t9R3?%U|0c{Eo#spiHEf<>4emQnv7!XNlczSWvB#Eq+Owr`vi(SL$Xv)ESqw* z&t*tym=rtVXtqq0+nLEd$LeKP1@?l<5IjvsR0jC`GCyU+V*SKY3Jhz_1j5QZ@1cS# z@h);DBbeW)dG#Xx1WKx^rtB!EoF1eHoc+Se<-X4VWXsIP>5$TCZxg)Q12< zlDaA`Pw$!p;;x6J*Uoy{EegJ82q{qc!PJT60XEnn1~o9RM>=0h3!P%o<>MOp%{t?{ zq>f`6AH7O6+Tl{bpUm`#}a3SZDhxw=(A{PGua+E2QLwP@nG%!Gv|N(OWFX4dU&9 z*Xn#%Jj<2tbF=1|w?i_Af$`pR>5u;6JLLnQmI0+nbk<=L-nStBk5+J$G7Xq3fVAS3 zFAeiuXx!Vh`vT$h$~tj=2E-HWmm*Kjsx>0o%)Q4qedDh>`wjxC>8!oZIENhj_9u6U z)S*%fljs1kw&U#Chbp7MD2%i)ZlxtK#=v#@A|b4Jd?^CPL{sY}F2GL~Jvto&BRlJd zF)ZF5)nzCY$pcG`x?Oy?pR{u)tgcMk=2!OLX*uC?^6^85oubpTrX_64{0CBK>%MVq z+fd^#OJN0OF8c!}o``)1NZr-~np0eLyZ-u@M*534r?dr2tJuEzp}ax{cZG&To)C0H z#!X>7>eo_4Htbx21O^qQNL%4-k9xZm2>-Zc|nmuMUm(#i(M=ak}gU9=Xf+EwrvKO z;*g%%iP7RYi6OvTRI={p{6vV;DaFh^ltT6_vN1043-j5wj+tIpaA2G$1kFYAT<|lz z?cC#QVgR^B1Sp>E3jq|uH`373F4CmvY%+Mh4VkEOIo4XLG7cdTEYzjtWL5ZU@Cd0R zX?Y4pwt3NXghkud>fVrQzNJH78kS3T7Xj{%H=4xNhV|Z_u04}2mB06maRN>g+f}3w zU3Odfy#D851OD@{wm=X)gWfdC`=f0}Tt-TWq#@FU@^@U>M~%NpW)XGcxoy&oZ?RBYwR!J%HuG7)-&gO9j^927pwA!P;;B!W4TA4pHVk1*A-_$k z_oaI4_+()VlTxWPiPEgsun6$|#4VeTR!zwJLg68j1vEm8h8M*$6{PQ8JtQC<%b(Wl z;h!&P&C7MRz;`YT&f!>Coq+W)HN!r3S`r9)q7E9-Oj(JkImEuFGGX?%uCP;Bm<=|& zAztk_!cb{nFyn3O0ugUp-e!E6%q8Ac#vbM^WrZSo3ZCH5r5wASYf&(uh~9=n1GKe^ zPYzgNr7^2)Mu}8KTe}BI*(#IO40n83G|k?)(}jrhl1qaQW^H9?_*U7*_==L_mum zpcbnIqVIl$PxJG@o2t00fw5^e1*?_mZeC`je_p*LVO_&({8~SLEB2T7%Ql1j(x);t zS*gE2-lS0Lu&K&gTUR1NjY1*XCjCI3n_N27^HVhfqJ$)lZ{uWxv84Lu_>5eSR`1*C zrLCc+Hv_GT3ymq67Q6aw^BmQGj*CL{D{&WnVoAV8T{?XfvX9U94{yG;a+%~@(7>U# z$V0Df^P}RW7*C}_hZ~hCpd%wOC(1~#lNs5ifAACr>^1YH0=^%E{%W_>_bO`@32g2i zDbE0OD+XsNZH@zEF;5-l-58 z>)LqJ#;{uUljq*eRZJn*S{2&wZX^I>kfEWH@;B$%TK(xjLB^0fp9)9+wx5-H<#nkr zg~8mq<-1o31ZRXG2b|lFbfmzSkfJ=&HYZk)-@w)*azG~SIF_wf-)Zpl$31aeCl|m9y7p7EyAKTK^ zW2j)3K)1ZHTW%t7TQ3`ma+$?WZRR_7h;EMJ-_^XQgsydFU=1^fT#0le7WR1_P_qz? zmkh2`FF@k_lER=qcHQGBvR#K+2ZoDqS1YcYp>~dIl#|aQS>(Rt4Tb^;cLY)R>zGZD zH{XVXq*NPKo>r#7JeSoOXzzb-EBj^5=Cu2?^twoZpI>78xhz~QipKz@6CFPr$19Uz z2V{{~DR{%|+p~)}@`tht;o|xeItD$tG}8M{6ybv44ugLP*W^@G-EDWhtc#7inTL{a zhC6Y^^)^e~F|*QZ;t~S$0W02E3D`D6Bj+xoWhoW~enpF|yV=jT=qFP*{%O`DcSg;J zUwD?BX0D4E*UVlE{R41KADQ)*FoOFZ#s5WAZE5_6sN#Y^kO^chh@A{ND5CfC}~Rw z?Cu?J8%k9E9SU?jO|1G>w-!SJhi2icx93NXWWLw9hzl%!9n$xmB4n($P*!l-&8h*W zb460!Tub`p0g9%z%J+6`6QglHrMqxvOLdM|2_ME;7h_-Q#`fRMN=6EQF$oJ5jm||L z9h&LSF>TKH72ug~5aB-!;CoRu0+%YcZNF(pw_gzd1_FV9zka1R8bd=#!!7E-5Sx7? zuSfqu>!V*oF$NVxfrKRh(IQd}fAW1JKZLvr!9om@0YIhaXR)0H$^r#UTLjo`jJLv4 z$R8k3GJXLF=!I$Uk3+O!{}PlwP~EN6c^t9<974Cj{MP>+^G!BjStj&+8oDs&+nL0E zOHNi}83_R*F{2kgfeiWwLf^S{8FwW-XLD~w3HdiwzJV#x2AR(#N; zI|BK{Bt;%~*ENW{=;!O{;5y#6B z<4(rgomnEbhicY!O@z44C=p0fAv-YFxBIZ*Y|m_Nx*r8iZ3;nPGh4ENCGO*E9KUT(vrnRIR;l85rIAoH!}dx{ES!i3(Iq$-CsI5PA@x_Ne4H|`@_M5SW1M)XPp3PT5sF5P zPHUk-79j|VKE0DuY1l~YnQAgU<0q`&dMxjUD@Xmvv&<5@$h!B|e8|-}N137MU@1|J zBGjXdnOlyrtHjK%DT@0U`w#4so%cyWCx5w-FI#PV(jWLd zzp@ka7{&*;MH&VN>or%IXIoW%u%u_)(i?h2;|FicNESni7iDD@>;%lZk{7#N9rAwA z5h$qKWNCTTB796o(<^VZNnt%=*6si`7Hu(S&$*;-_-FDIW);4@i@ipX=9HR#NtNd$ zTKEriIaCa$_Z2<;9u;+lfhVge6o9i>ik%=BO3-|fjS|&vhHi@1^r@PkQYC_E{=h7v zKT!?po6&!kFZ|hk&-DYj@*~>m%HCY%$_4WRjONzPom~g;Td2QKL#si zahj4h9g|14tS+IoUHy^MYd2frKYq$_JyZbz;j16tWY*8Ovf8`9gGQr9$2tVaA#EmJ zaie;?-OeXF&P&I>KG}&VK=^Y+JNc~hFw7UX@&B|^24oenA%Gfe6X##=eCmu0H-0vd zL<`_Zz0-8KfY{yN!cS)3m}An6zrKe;FK+%JWw!C&xSV)KRJ>IpYuAx%OdFgBeJ!i{ z>xI;UaPs`=pPt^P;7IlIzCSn=;)xNHWWxYphZ29WY0$e8d~+d*TjoF$rBZMpVNa4I z9wYZsJqDb?VKTf;Lhw{@{6}TyC%88u_z1f;yQ=D&`q%Zz!&F$lDgGd^D_|nhp~pA! zqRC9}na@>+Ay9?3pjg+*Db^RMNx2rEpI2(|2STHIRwD4P(r0bJ^G+`qmrMU?^0cW+ zyyo5Fwmk~a4}*_GCv?K-3IJZO1WmKK&=W^5EcO$sNnmp-tZa28&q->3ib@xk1}##0 z4)%wVviMmw1i3NUWf+gNSmExQE_GtX?8G9=2oxp@igAi2QuVEr9s*#?9T_*mfPVT6 zDQ7>)c@)PD1>-2l(Jip)O^}F1p99)tRLlb`=_<|G)mbRNNhj!NK-Vdx81{!Pm z51`y!Tc-MNOPvONUKqZaYEY=tw9GyuQgGakq)^6N`Vm9CgI6o80((SLHiv^Ouck$a z@>^xbm*PkBcbnrITUW$xvRER=<6V80%J;?Nii+?4o z_Cojj8hDnm=~x)jOj;LM7o1MNRxikN53;5medQ6dKW)Xc4q)%QS}lPEBVLEY=6a3$ zjtTvd)Cr__sPv9T#k$SBsJk2+`7k~*kS(O4weEsQKbW#HL^>-E__)Tv^QMw7dsxL) zALSo@3cSN_!T&YT;W7A^If}IubOEknH6EEM5=loeK)W<-hKzxt%66Yk*Dh{6Z~!JI z=^a+)+db>zTfgE_?-4Kla?#y$+?uY9eqLB*8KUV>mWw6_Vhmtpif8^pttj@&cR&V4 zqfaaYO)%i4mL@`YncJhb-}eb*y34YwA#);3q(1e&)^0;p*caQ@f!a(a7YMP?RmHyu zT@)WLz@Zo=>5|5_4{hnF0nFn)lj502fgcCmFtz-0^r+0>FURg2$os+1fIG7n#8-)a zQ4zuH&vlirku!8cn8AOcnyy6aekX8KFz!Rk5F15IA_~PzKR=yc>B<`);oNB{us<4U z-6*FLx&ys#EW%P5?u|ZR{dP%T=BId`xKiN5^(d58__2*?Ea%Br7+s@o-Ry!?YuM(- zBSZT!Oy3C~l4LokzseJNS2ohTgF#CbDY~;Lwwq{`_Zlfs#)xHwGfRU&<6aaGR1!6X zn@6SoBC)o$=%(sO$sFUFom?pqMK_Xlj7+Nfd+U0({=|V=gHO3Ng4#eL%fJ@#BY8c5 z84aBTkN28iNZ`)K~MZSF}`=v`p17$Bzh5rob$D-TRVCQ|P zZF?|XRGy#TGx{c5+yofxH`o2`ANcIQ8x-6@#oXu*7Fy!rX6#(d-H;V*rEk(3h0s?h>V^*d_=8emJd32e}VXH}`eG0YO-wl2w%Y z*qpsx87-*7!JtHTVumIW`#hcM{p+ZF6by4raRB5^R1owSb?=AO>ycYZJ}vYhVZ8!Q3O%C8{-yPkDChk<t%a46yq#fOoz@_3_a;|*+h<_R^d>+Dj!IFLkUIm$A9(P-CjJVsU~iNNVxf|hUwkA4(y6MF(W}l zQFb`h<80KYbF@}Lq({*Wzpt{NJ10G|!sI13mU3KYKa2@Urf7VY4KV#UNk7+|P<`e8 zcFI4~-e765{4Db_jmu9DtX&_x0{BV8fjLdV>4X@23)KaWH}&nu@F@5Okd9&2_M>;K zdR_`2;bNxA><1Y>+TP7~o?IN_rYx|^;q-!TL-dPFQw6aXo;@0xPg><`;~yF0*7a^n z$o9Plm|TvH3A^LP0`Q*h5+gg{;J|w;rtSR+;UPE+f%Rzd4b6;n zD2SVY`#6N7yggLfENXo=gW_%Ab*gTEO*=A1>|9Mu;eyJt-%Z;`W{COKHU3$X;?{=g zMSot}ALG=E3zTZB(J5Br@K%DpCBHH`Q=C)ofD9$^!nwr62--l|N8(^y4%Eg8g^M3L zD37qg9(`NjI6p`S6rn0zGhrL0U=v~ z7wBD(E7^!*C#Od+Yrp6}@^vkQ1atW5jS<&^RGVco!K=E*6Bgf0Z(;xWb`|wm3JuEv zDUY15HKvS9Y*VBDfO$x-dul=%{9&K6&decrNK;n$T*#`G(<~s>$4dUzd}xt;O}-fF zr?DTh>S1B5025DeY4`gf;nq)3vGT|*#Xxt$$B8S_Y*saCHk_GcoKK7K8}>cUuwq|o@4L#}s+gsGv34yn#@V?XkdAP6e{ z1hK)p?!4OCDY3EZEREao!Nj0IBtYL6AB?36wnmsMZ?Pove5xU|1-G>64_3i%YfZGd%#v?H#DrB6udw z`f52~b>@e4Eocbpg@Mg?8@57j^k@OjEa|sNNJwkwV4wHWp<4?rqwoLrxTr96s=wJa>Mhk3J zw^+xbs7jF?+%v8UcPC%RN(6%NY4`}5vx+9B1US8t{BSBBNmQ5gg1yIdK9)V9v4Wd zP91Kcs~YDnVEI?|fW9-(HN`~1>9>M`vl3N|f^D$&kKo%n1d#SvX>G8)@ z)}UV5*>m`ud}DCZkQsAkGxJ*k2UEcn+mI08a}g z&lqk3RHOSO+=jXc6JEpsj|M&M4M7CN;cOA;@yliY;}U6_$SWvx{h2pM<-l;3dlvha z%(q|h69sEZif>jQZaDoAMiL6AGJL+MO`ujpZgPbzkbc1p7i((NC-$h>vHYnaNvg`K}V!G(YvW~ z{-B1+mxs{?@t@5n?3E$Z5xvc`2e%%z>RUAEc%I!_txSm_5}2G2$Ofhv2+a9jKqd(o zkJ$Ej()@1Njl~o}SvFd>lZyM?YOQrjK3#Y$2`9O*C42Lu+%O#Y%E_26M#<5s(AN!+D0ANXHO0UBcv$4?ihxrB-?uL9{P0!UbMrZ?`!=&S@8C7KKS9*yQHfqN z0|ld;9j5g>cc6Vx3lMm79r48v!KErgPR3CC@5R2QC#pjdug#6!TDAfD<)Zk99)9dI z2yeik?POorsou+g_YQlXL6}=0M4@Bu#y$gOqCf=yo10m!x2C{e0lEX#RQ9FuH?pD< z6qwHj;ug&EJ{}!acp>F&R^x!s=!7`%7XWmTY3(4!yJvPG&Hq{Cqg76#3EO<_&i{nk&SQv!c zP+`|_NcKvDJ>`XvjRD$|$ZWLZQ^aG!m-W;u6vlgU z?O{2ltAfv-D5sjdXRguc$Smy!Qse+wEknlN)zxXOOsqt#c2*p)Y?h&0V;G-NbtAOO zdJwR`NHUXwzN7X}X!l-3Wj>N1uJB(TY~|FY(kBU05IL zF`Vv|oP&~lyO$td?X}2*y*ZB*(V}CI4EJd8EHxgBu#nG;HJQJi>4h?aG;Xn01XQaW zYl^fWKs{sg?_kToztKT49;NWtdAor`k;P#Sa2N(EVu*N&_z=YSwWBX-Y|JH+ozmZl z87h42l6qh`HyUYjyN#9TiqbJv91F9wR~y$DK^TWf`Q@7M263iMN~<>XzHJ~IJ>Dod#FkJZ*w&D?LC4~2L6q}gUe8u+;z(4|8ok`- z0`%`JioU_X4_?yIfZu*|md{Sf^_lZi)IcJ)mtwfFp5Z*hF0HH4=!;MsB%P(7_$%?c zOi>gDNPZ_%dU~iF=-t!?w)BT#bf0op#B5xc=HRRle}UYApK;)0F^p8{31rMk;>uepJu;c!ecJsTLpj}2-S>FO{` z_)ts7E1W^~jRFK}@jQYf{>pae>65^)xpIX@kn;!m2_^vUzGLH*=*6|*!M)g1l7Fq; z7v>wplW1{McY}c6GQb3x!Voc|8rB0TopvzurU2xZt&-Pyc5}O&kQKC%=eZX{U_p^L z5cxY+G(fOge0PH7WVCVBIWiBA-)whJr$YBZeeY?a_rXs&gidw0g!QGB@Z>bZ?a!Kv zunmexS5^S#(Cvex7@1qJU1`baizDSK>(lB3$+I|*)m@F@k)m698`@#sb=sj=h;H}& z53-kRx@>)WP9Ywrk6Y+F%@$cSel0Hd<4WzOIK`MbKHUQ<__@0Md|q=`Kl-Ha+9e5N zzAoYA*wCe~oe3Fy?*iV{oABG5FG{>#d(PiI*ld{P-<-MMdAbxk@{S8UwegGzY#Gh% zFR*=Z7k2Dv;fyX3scVW@L*I$L(R#cWtXaj^e=N7pa2ub!K!agwn0?*y^(_|x!t5a@ zc`kG%#1TBH_oA;U%KU!n~a`8#;Co zlHxYSmUA3zlk;9>)B2ggD&?Rya2hj&`T06Aa)I-RAde=VyD~Doejr%Dp+QJS|C5K^sWxu+S-_n2Q zN=FmSe991R{3%|2MfS_!FfhR|WiL0xWI8AIXL#_UYOuNg;=ELtZSFKW6z75mpa-yw z1!HpZJ6_@bcrAj*CwBuU7(96`Qg-wL*%{9$)g#yel&hZczeka$8B`r;P`Vj=Cyc*| zkx);4_)E?pgdiEqE_y$NZ(kHSuGv(vn8(%g0d2ShW;kC%m1#gYO1d+_Ig?F71}jGT zH~&0d22RAlkFd`iSpl-vP6n4DAXv3x#YdZwCe$C6Queub$i8p?v-guN{qq|GsBMjdY+EUm0iDl3aRu35Z>D^>`ZUYWM}QVa zknOTm=Yu0uHjo<=!e9`6P zBk=T-gp;PAd^Y~qtlBe}2?JA)hA5WT{t90aTHg|dLmz_%tVREv`^gxl{Nj?Z} z>q(}oFnmk00bYK~-2cRP%75c~NyVpnTJh{0AeII#{SiVx|?Vz&`jB;K^ith7}TiQRd6pE8umh5o*gzCViCC_H`NA$aJfxlzCK z+C$DjmVuQ#3*CXS6tY@uf7rJAA^6@)P~krP%*u`S)$uplE8(bpcc;)bLZ2LhvYl1Z z_r-Cp4(C~z+N%9U%a&EocET4MGY){yT3QXolfvY~QMg!SBd z^T~)&qaTe6$Dc8IXI?N*-mep%3bxztz9h6sO4mCJJ(?h~h5v>PP{NBLPL>Ycf$J~u zfdxUbuaf})>e5!jIq#{TCdEf38d7XWE=+zbN5#Ps{$+E4>tmf@SSpN22pgzO5CkNj zK!Qon$XGejRZi7TqcA{)@P(9{z@w~6Z>CTxd0z>=F*Zwk{znVIAu{>wPOxQ2DT6us zBkArhy}8f~>ju0SfBA{Xl!?XN$(G2z(e@d%Oah-f!~i$pkFGMD;{LhJ?j85hflNfI z2n34o!4^H;51a0Td?6zEw{Dg~{OZQ(6kC!4=FM3d$&Ou7Hj$8+Fvv1hjcCQ_$opHG zj~G%ZG;q_z^9`B7UrilNIoZb7Ys>%xg==5$Cs>3c@LA*nso0>-PKoRZf4<7_UFM4r zuRf>xt~J!e5WQG7i0r0q6j(X2rot}I?XX<&d2jgKWGotY$joz*Vqj5m`|aIX(yfQF zoIR|d$QZ8@Kfof9@R#b&qR$qao!@(JG$vO2t9E)hmamCC9JA|FYKOU?*M_;UQ^!4= z*862$iKA9$p^i^nws8G2`<6BF*sGO&N=>}|p+cARS~cOPZ`MKUC6xa4MesJTlGrnt z=d>VIiiOXjjrm5|D%r)|N;gr2;i7IfE&7YOt)}+KJ))!BtC(>|^F$3nbCU!qJ}a6-`Mi10h`5lrE`;Saw&S-q86H@BrV^z)x*Y+iK-cB}J3B%eh zU#F+m*sU{kzS#(PA1d;8TT&k;)RnqwpmkzKLd^fM5#!T^AF1q12U$OQnf3Z#jSPk|@{=i#-aj>G8hg$Wmp-ZWHfw9jHU zM@7KyHsj|Moqzw=^2wSp!2rLQl|(pHG%51`7N`OG-?fDU1X+JVXUs(GLc&T?&ZKr# zn#*B|Uyiza`6`Y*=IiJ$0RP|d=>+SL|ML=f0}`;K;Q#rXJB{dntKKzmZ&jDK)|p{Q+KnhuXdyU>(u(LW(*|%+@`#g?b5X? z@@{J3rZjDWAMe5HSI}XpGa=?O7rx)SsDD-JSkruW6(+`ayzV_83RM&Iu+2{8!bXloc zaee9^^A)|#nU7xk*x5UFTE_c}v@yJMP;FG1q0`4huGC@-jHW#wR!SR0woGgR|6Xp z&uJe7-G}V)NU%>AduhLS1^~sH571{C@)*63qDdzC-d7qaOc|V*K1aD_E|%Hn6@QLk z{uO%58-mVdTWZRsbUZO%-(zXDv6VVpcw^7fnC1&$olt0pJwxO1R)VfhffHUz{0YGmzN-Aq6Zapu;)vUZ-^-|( z{tsb`B5Wq?cl-@5_Jb!fx={o+bhf`Y9KCdY23hHb^sunxSh3>GvC9X$hLnHJ8| zz3u!msw6}USU>ATQm?ZsDH&MWJ{UriXnS#rLi8Tz&+*OhjQU0r-|YVE0E!oL0O$Rb zR}pY+Xqrws(%Xu*^b)ot=)PR)r8Q?ZTFDv0G9(9yja`FVk;4d{b!BJS=BhkJ(0LO8 zU%f78TemF3ZyUEjwofl095&JwPP`0HRM$xotm$`(+*iLSRzl7K_#@414>8Jm@w84pE={cf|ORvX=gRr&H_gOE{OIY8CrKcwCfVmX>-RqD;-LK;(<9ICPc&7Pw~#K7Rx))T zmvfrBIj)u#cA==slgj0CTH(Wc-%ma_yKpokLk#s5+Lo%^Q)bg{3KXY(taL>V+uvMv zX~@Ym-d6-@M-c+u-7kCCPv6eQcTmRqrjB{^<<3Ovm%$LTBVve3A{5neV~jsK-g{0BIY6cd!kiGPxTff(!+#)MhAgX ziwESq^4s3}Cd{`?4);`R%jLa~)UBs_FihqS?fGubO-;n%o=0TU^mQhudS5n#^csQ6 z>Ga{=_H<}Yrx60T==DH#;Z>;s_yn(ij$SU8rA$cVCuP{(#U|O`g9M#Fnr*)j0l~{& z)hh7*)Cqq|A2_!1Y4NJC`4k`7dgTYI|Fi7(K0?>VT{QF@b9F*Sk@xx;6+HR3=$W?R zDrZVJWtB>I$%Vw)>(HuXWf9N!Z@6nYPN>SlnSxuNoA#XR;xWkl*Z#5uOk`?8fGONb z_hb78V{ISXW}1k?O8MELx$)=QwsN_4`*KR(f)f79DU#wpcT4lqCjyZm2;1z_y!PwN zVw=^uqwQ;x`$?q+`sfEgt=aN3?w9wzB3^~7KV9VP9m~^Bf};t|vmrH+--t8uS0&+S zPBP~38n2nS_isNF@et=m>VLA1Y<8P`nmknUq)8C|E-t2<>++h{e03iGHS)*#JT5$I^k5^de`7xbPVL5IlePL5QY~Ws3q9C9;>5nG-+XK4S%V2PM(H(=x<*m0hf>czQzWpi zQ0nfg_3{^Q$@iRl^F5+*QH((*=b9ICI?jFMHSrB=yG#F+aZkHc>~cPI(!^hiJs(7y zr|t4sxbKBGMVy6SExN>x^R(q3vCfBLRzgZq1;K9ckeAkgtO*QB-NfB>m1#-(Ae}>H zykji9pL{lWTe`-lK6}wGF%R9+pA4(KgXFGI@+dbcCQs$jGwoHRMklFqZgmUXrX_`_ zy6)vG&|ka{FdHy{z#Hhau(8f;Dw9r1n{f?o?x=VeBrzKq;Tq-08xw{g#>bN#1K`ggt+$EQWYXx&`drVnP%C@-srJ`j ziGcS_;w__^PM^|uF2BxsPnfu`p*Q_R_f>~>pq1s_1%FMyk~3%FtTH^d^mum|>g>I2 z8ku?wulqowUSk}zRB&5kvWw)YNL7y8EaO<_jI&ggM#Ob10DpG$a0Yj68Z?*kC8(KA z@4=Y=*R%75hGw3^-EeasOz7R_)!h6C-Va@m_FZM#XE9m?XRQcV4zE{R6%FMUMJEQ% zQ6=;hF6<;mIw5F(qNwK#U`9Mmb39)r=Z!ij_oQz3yY9DiaO#2<*e ziTQMy&(@FCR}&^*+JexhXGpNp$VXT1Z|e`-h2*)_RrmNnxJFm$O^f2Ty_?P_-Ed6H z$<9mr>3-OGv?$Igx*}7~STKH$Z2kO87^y|q0ECnvbAk>%`N-KhskiA#B8T8*B>5@&^BhG{ zM8wBW7J?Zs_JuafS-Ye-x|gAwbeh^^`#Id%4IA>E;*M8rj`)^qe4K&8Iia*pqw$pS zW%mjbg2Q*Sm&HhqIzfUT=zslwC+?VEaPWA8$WWfpqDO)yfQ%D+@zvhnM(1at-_Ot7 zR1Chm6QA6}HaTxO7$pd}6vIS#3K|(Mzo)ayaE{21>SnfXnN`~=UZ%G1&m9#h;U>gm z>v$Qp9Fj|Re)uhP3R3CHh3PFn$=-BwF0Vj2e^h2*9wfnj!$NWpQf33Q#cbp=1Y-5K z(GImvj>&Wa;-?sD^W-MU@?Jqka50`s1s(m+j53DK=XE%8cPTdG?xrA=U|2*~A3Tl&wm!G^>tqzZ*33E3-SuUb$0&|+7z=66k(=F=y3MFs zjc@uK*~a=)=gO#@GrhOx)d_(@x0UPXfE_Ikf}z1A*{6H2qq2esE-jbo8k^ zgxmW$jJPfmT6iLcIPc5N+a z)~GgdJJ3RpoOC;Ezd;)A7(O|~hS$&**-LUI=Rx#bZ^jRzPvxnvlQLF27)7uSnb7K9 z=pg=iL&8eF4L_%8qjTBi+n8%3$EEi7AgxdR7CpuJ>M_($fTM-e3`%p&aS(RezX5&v z`e{!9;V{hkkDBB3&sW&F!`wquH*++MN;BejP-<`6jw9BFPXx#P(KF4a0MI=MHorN; z4a_|I^k>zjYOqcrHYWrT23(dvzwgGMlXDu$Wc-8cgpgK+8C!5T!l(e(tGtR@BS_XS)}2k<_e!%mN{ty(A6`Ke)?(n z_5C{LbEFLhHujdD?}_ehkG{Ur8f@%GT6BV$HSc{Q*9N!2@%M+W4MCU5#ryp$XH@|! z`2<_ku1w1%<1NQ}n9YC%5sO(~*L|+36(~jPiWWPL+I!7iMqE8M&8!&w4+BllSK<{- zxDjg2Mzt$_n^bBRF}^vQlOMSJIF3vemj%0 zf&T{I$Z0$=Q+z}zI^M{BTPcHyb>6n7(H|ArIzU8}T%v6SF)KIGBr^4{)XJT=It$@q z=HH5jXREcyqkGg=#z~M<6Z-cP`0;yxSa$(zUT~&=8Cg>cmmPAgUU{Q%h=~Z812I(( zZ-v}r+tl)Ou)>^(Wy%S zQ4#$9I~Jks@2OiH!DHXfcfQAC7VaL;%-iapg#z$!G#FfI&2h;JG`gaN;F~Gby+&zV zMrRvIP%ze47Opp{Z37B3lAnshI9#}oFL!dwIzl#nHK=dfeM!%cl=0K@@uXZ;w?Z%m z(OC7=u6_II$rEAu_=9P=?yhv!rpHW&oXiNi<($gtm`=q1ySjw_611O3NvSAx8`f-bi{>qH`TGh*f%L9{84w#6OZ)*5-qh8XmD6m$8GMFr{}qn!g9TTQuIRY@}Cv_Y}p80sDMCf-?3)gr45+q zb}xNFds92a}q7Wk?=SGPhFgcSUMvshTD^5HesekT5s_8lpQSn(<6Ldu(zS8S*{N%UdI016noA zDvV&l1roaSw0Q6C3Y#dB5uU&CeZ_kVIM99TYb#xKVXiwS?{0^V-CfrKlU)C4x0x*3 zD`R`-dym+2FvNL&TuO#{&g&G%PQPh0&jFk@Fk3%)H|r`iHUb^EKhL6_jI9p{zz|?R zEZDTjRjR#--TIipT2m&#RAY5WfC8TThW*tahqmq9fLV9CUgNH677(Cq?c|7wNlukf zoTRzwZboQbd6BED7BHzecVh7|I7yVq8el&s$3l$eWX!EUblv(-bQRJy7XRfNmNOw* zfQK1-IvW5QqnCNtzuZw7+|PRY?^+0~?UJPR=BgQyM2g znOKDu#3ZI_9jBTcCBC1vc!<7NAiH4DHR>3wNBY#IuK+ZGErg0R2MEv~k697x`px*f z%N%}5^MHW*$T~#_Y#-lQ?Mg9uUCTOG2nHZiz2=-X#yVk5;ec`4k74)p5-3oyf170I zGKFqz@z#=nJ>)R?4osIM;icYVm@SL}Mn3BfAj12jcN3j6^gd|;d-JGy0FaB--0|m_ z)`7jZ6$S2)#_9-;51YH=_C4<`W5;>Chj9XRIOmY&ko*Zahj=z~$bq~<-gN9J06Qhc z#l^+RXs>rUInslxsysv3&OGzKkXZ@I@ow<&{%+^iT%-Gwtgr51of|AUeC_R*x#6P+ z$q=u0OBSwjZ@sv{l}gqPlR^IVfBu3?NQ!swy}8)^?q?5Kn`U1#)!lvXt-5ETTfAVo zd-3r%P5yT6-r3~y6*tVX90TvZw#dEw^7GE|$U=dSTKx7u@ixwF5@m7k zikHn>%7)_|r+Psmec$9WZDJlMp^Zr!aXwR63GnvfB~nm%l%>na7NqdXNDqIesQO3CS5zF1?7{p+pXmofp|NjJC>l=i;uteWUTQ+WJa31~S@wdchp*Wg2qSMJ zKXKeq06R#aB@56n!P#%D8L#_=Rujiqvg7oCfVGP;vUYL*#%J&yN?gAgpL4w?T(56D zB^5)51CKn<1?gY=!Y^Iv?$u%KY&!4WT%I@&cAJQQ8EPJy%Try0A{(p3T&aDeFpR#; z6^g#MM~VrGj42alNHzAS@j~v&n^$1VyuV6` zDUgtD1O!Z>mQsbs3U5+!dOyWM&TvWc>f|ne(XD;{7xp>x8S(Jf`)T^^y{DQoc>?;) zywjx!q{>t5DqbxVv4$+mksiXmHP>Afqd9u+cU|GmRchNSn!8n@F^k+bZ~gKvd8`n| zE%FgI@1g#9JQf&pupNo?3m#C4a#UgR@REDX7|NBb-ah{!^9=Tz`FR7wWi`7cZ#-6cXN!swb5V@)3@!Q$^*=^Ny3e?>XCNH) zKL+!G?aSPH(co*ua$}$BKmD`PQ--*G>)v(S^n4FIAw#=AR-t`GZRJ^j_E}@EbX{dg z!sa84zz*$uhpNlP0$AsAmp*5C3jhx=km)l3X{|s5-Pqc}{n@MetYC{|s=$b8LE+tu_6CX#HE&_Zk~>KBsNmD^-2&IsR(b zu|%|1D*`M@?N!VN|+o+H;~?=XTw~{73<`X)-7O3n%4Bd zOYXLJrD5&by7lgd+%1+4v~SHkSGaYt0Xc0owj_lddc{|a5mYa5hc#8MoCbO8=DUK8 z3rt_}!(7lcJIKM2HfV~R5wl&ALTkbk7S@#JyUlOkF9ym6u^3c6L4D~zQ+*vZr(r(P z3t|M)u{Np7P?EFWZJGCH<#;$?dMaakSip1l?%mzYnKRv#DSCgivt3zPnfv+Af9}?- zSz}>q=OlwQy*N0Lb-r8&pzog9)s34n%FR~HKfwD^$;FqSnkTw`dwKN7x@%;_mzP$! z1#f=n-jcCCYT{5gZO%l?MG&oU8FC32h#(*zaN&x%vs|Bny-Xg@dr5gj6#swo-PgFu zGsn9`0SkmFy#LM;_xvNTxxAbLchlY1y192;=}L>r+ynpjq?iC}Tz}~Zx9D^3cd+`P z$>BG2|ChxoXs)sW+Bl8oB_TsBn4M4aBqW+1_6(k-HhWNpw@HI|(@wm%p77-dlwc|G zihaWa+1AV2#=^O7@sx8d(CSRD`B0~y^m4J zH^2EuZOrl_sO{DdNgn!a%8^HY|#F7jk`?mfzh#v^9Q@Q{!?<_e{_5mKTK%QNzp#$%8A!*yKByfYh~Kw!>LUi^8F z01KFd z@U=+85V%&RN`e|CnERsCqAck?;8Ax0LVYj3Su|e+EP%j?3<1W| zt`UgBdP|iTVZbF{(3%-;%H+Bie`)WHx861Up@Y8APx?n(D6~z&5onWru6L~g5VASZ z`=M)5W=G1X2h_@0{*oy#MvXLjAj@9sg!u@24&$O*D2BI}Q7Wqn_qy_ZQsUJY`y%Xo z4UYcz-d_|OJW&83csQ6RSSf0le|sBCyN5nuO&T>7FP_ddFQi%>`Q1hFM6ql{#XD9S)1dd{nZ3=l{#R5AFN-1Hhq!k_(~_nGPxWK(fao0nKF!chQa1wquf=Gc=E1wmw&oSzjLVIE6^E z7GVyQZ;D%oFkG3X?#HM7t&ljT`bkedtuJ zZB;*z^TLt}YTiBF2EE2vNWmb5JS1tY*2=q27)y+jXeM>-ZA_6;C9Jf>mjd+KN=^*Y z`;jf(54{4Ni1(>Vpb_CF@p72JoY^9viE0$}a+Yx3p+kzl&&+g}Uw*lpF=K}7-MhCd zEiHBb{_p?pmM@nhiFJ(tJIjN9paX=NU5{b|c3PHRJwGu>)2KC_ zGtuqZnj;VW2X6JUjqdg@TyG%;gzzOK#<|jxa<^vb2KV%XueebYhPdl)zufW-JbC|1 z?tQWF2t~O0&TCv>$>Va#@)RWyL>9mH{JWMH;D*m$;jX%QwlNI;{OiXo!Qq|v-mDOU zzIK1Wc=q4dB&VOzGc3oDIhM|HAU*+?1%N;+Ok#F+cC&Y75q^|_K!zybSz|6Uy4QwR zeytW(i&0r_FVbgdWr?=0XiKcFm2yu-Bu#JnJ$;L}!oR}oh(G*XKl7)hW5<>eh z9{s+A0|I2O#h^bRlo_FbamaW9iWo8-)^FXw=0K}Q%HdT?bn^uP0v|RH2xww3FcD77 zM{IJM6qFJv4n-E1hyoLS_y#LK2VeeG#Y$dl!fxeL|0aa{eN!aDjZc2Z>mbWZv`;AP z^0-K#L0_#cCAUF|ts}qh4bRef<`I(+jT2qJgOnhY78H%c2Z=+auQDn{!(*Q51N24| zE$EsDwl9}L^}J`O(+3%ume(L`z0kI3dCFpxhzcMFL66Wqtp0mz@#M7yh(LDWv?0?h zt26-G*0&=80u4PeKmZV>pS(4v0|a!`8){%^L1HP$dO z@ai2=t_-qC6OU_0XimI#DZ{T66sa|)@Wmu{GDWstv8d$MAkW50bFQ1v9t_}E(fcsg z@y1tISKCk9kNn1*;ZHIe_ej}RXAbIf~!cVmOfECC2CmluNr`4Ai}AAt)Q5XcfB&_!kIFm8|33G5E-x&FHe z)i-bL+b(y>vwCI7$}eiK6#Rh#7^7o4$Vgagp2$8j#7R1bLAB|vKUtZ=cKRNp7TWX> z?bpcOe1XLK*S}|8_ilqGxy)g+EDUPvdyk2U_PX}ha(Q8|Gg%lb`uKkB>-ihsGjDu~ z!jb?AFzlg5Z+hdm7Pk&q55V2s_Qe}y9QNa7)*iH5GV%kja)8>Ns6Dz`;Q2wxFxX@O zi2%8j`O6w}xdFLW8cys7Gaxk<02-W|DLn;HBSyyV*7*+z5crco1@w@}?*hOhIR`q* zkOiEmRvAI_jA~3esf-=QShxNc84Cdxofr3BsU&oB1qgi0_M!taZuiS*t`s#tRbxvm zdXhklT(L3$HmdYF`=@qo>+k6R0YF_G0z(y&kS-59tU_`P0PHZ&FwbDP!OAGr_->p3 zpuqf<2B5RrTM7uk5MYh;*SwQ!09mk8`4B4ew_BOZ0kiIsQQFJ;zT&Zemdq=49eWP7 zkiZPJt4g}dj`yEb7XMWSjKpicDdPu7P@#5tMyvWPJq89sXX!+law>I9AE1!IKg$!n z#`Fi|GQdoOgGnOQ&&pq_GMZI|Iku(&1bV37nF^Hz*jOi4$Zi2$eqJkc0!a3pcZNVn zXF@lF@xagGT`MJP%S`741nE2FRxwQmsf6S*QyMlw`xrR&}8V{95CY! zW7O>5xKQunLNUnV#Zb7|DlY)4;rQ65KO6(pj%lJ9`_5Pnl3FbnVkur5Ks&TduU zfDKfs{-6WE5J*c)GcaJLSOR_f_BBA@XFvOyTeV7kK^N1X^KsBG{!kI%qG@B?4f4>Z zbWV1Q#Ik$-(btqGpwtZ--p@_HY?2#0X@pzx;W~i?Ywgk3e@4KblKTMyj1m~nJ=Uz) z=pO#<({}FM&s}Br`t8pjw6cWPf947YXb(ugHz&^x9NO3I5o=(+Sb*DAQt)zx7tFkT zvV{qfzW{?Dhr!+)<-igAlI+CjiP|_p;16tFV#3do7D>;TUuCKP#S)xH=)Z+K^#5 zu$k5>UcE>jp+e;csM7dj6ncjza8OT3I&?ZffHtEr!6typ-a$ql6f@ezbIT?8cPrkV zSWBy3pog3Q2#A3I8V&lr;>mw=2MiDp=%cx#od_Eg2?Qqb^c7+|#7V)7SDYuxFG?Qs z1M*&@ybUOR7^?h)uG&Lci(>^+wAVVpxHJ#F=C^SB5;MYyr%VzRA3;vGZoCsD*+Pjx zIR!vCCWDeWEZ?_Hp8P)jy9ql6T&cX)}1!z^#YgZcj=zZR>rAJ-ay*IyTZY}sgvG0 zdyK|?fj0J?5WY)8E($_lRaTfAen zLONd3cS;r|@Qwp&eMUxx8$W)$8$Eio>(;HC%g@hufBDN_+`fJLY)?E}#l(~l#Ro#U z$J0-UKwHh}VNn+m{F6j0oFV0a#7fKFUu9*D*iR-*9qn$p>l!;B>f&=sGL+pv%M^(z z@?x}CawF;$Zt*6ok^H2RBoWKlS*4n8)^jPlM0JDm(n{Tbsd5&)t}RA6PuOdM zqs1d|;R6C=)E6bSQ!-i)5CH7-z`8>M(Dtui;P&c$L9Xyl5xSHu0HC|}Ny5}>B%9)8 zRAI<%7GtS0f1CCJCC$@b+yDq@zecugeEoNB_XkhQFo`p^6Gm>fX!02NyFYwR2GJ@v z@`i8QzEUG2dfB5tusDA2-BXgT>%T3~^=g5}#crkc{X!)|^!Hp35SVL}?lQ^ry<&^y zi04;lNG{5!>|5-rZWHt0K}SC zJhV4+*X9nue*gqOK_cFG^q6WTbi=qOERT3^stmvo;Qfd0zV#hFM>0KDUT~=5{ioky z-r&8Wk+X*(6OmiUh~@zS^b^S*=}%*C|5t%GVOq-MDFul~kZ0<8}S_&sU-N%F$>0pQ|hI;Qs#yWkb+v&y9*ow&brhu)KJvUhEbLRR<7 zF~GWNuRS7LpW`ekP`D2cFIYu4_or;jTyFL%HF?Qh+N4I2!gZ)p5E z{(|EH+XkS0%Ipc2GpDq;TrzLIk_67TyN?xUKjVtYZrG>+ZsA)?EphL~lFw;k4lGrI zzn30=!+rJJcex&t+pCtXcYprXV{U>%4{pBmYI*kK-T(dk0R!j1{o}8?S^@ssHt)2Y zJu?I{RFqaJY+$L|C5OOFJ>w!>w`r|%e(f)Eox~s*F=nuPSG6KtQt-Fa*x=1&DNcc6N58j~hNSV@fYgdb*MTNq`g=D{+Vv)$@J$0vCorkI|R9 zWF^jl?p;pSbQuVCgaiQwNp*3Kl9-g3fax>!Rzu4Xl$#|qG0Z9dk}l(~_r$pp41=vy z5(#FC<*j9t8*|&gn$Un+j==#UjyHlhe1sofUBCrA>lnGj#1pTMK}pFOXpI;Upqu~< zP}5Lg8sg35EylBp$AvaP-G|17GJ&Uq4V}#%+7|JLwTk;D;ag`>>tf}#$KWO*60|y! zCLNXH#l{caZI=`%yrFo82VeSS#gX@LJ3o9zUWz|!<44PB&~!{e;GZ5kUTewTNXFMu zMi_tv1~%u%r(~KDiRyGCM&ac~IFf*ec0rManSp1_m<=eiI=El!Fa%H*j|tcq zEhXUx#(t?0lLc@DmH@O`>TTy?7|4rPnzPp458jO~{l}|aD&NI9@?6;ZttruGS~r@j z!tE=hB#> zUQ9x5SU)J#P#636S1jNaSD0dwm6c_QjqbbeKDTx2)^h>`ynax2knja!TTyVG6oxwG z2Iwi};9^TSSbU(wk_f#&Z>j4dMgc}YUIe@bP#2dhSm~}-Y$No3i%V3s0DF z`|zvg-M}-E*{i!{K_*EOo{XCnmq@K+k`a=ZVB_j7?nNa%A}_$4>u0#neCY-$F(vMi zKRj!+$t!QV#7&+tPWKVbv$jt2aa>-MW$wY>K4tCpD-_rS1%I7(1TJJifc>|dK@S+9c&jMGd28M@@L4aTfzQLQ{zsFKJ7tXH5Eyg&k1Qks@NxO0|7=O?jBTX7 zV1Vue5Dd$0`Qtydd?m=#Bg*OyAkb&>jRFG)nUTFqG7=zND2I$B-Z^y$!#QNcvq!-Y zASaIp2&lfe=;9|NR@Ax33BXU1{UIapoNsyi&mK@6x>wUhz`jM!1wiR68EuK(RE|t~ zg_Td%H8?i_DytPLwNE7iiH$cvKw%eTjXx*`-}d(&bvXjXEh(%96InA_p?v5^xsne% z-+NeN4|uA*Quk~Q5MYjYW)9xiWIUZ3**`yD%pPU-o4euiuGnhm8l& zOXy;O=_dl242;ym(!tt<$=6xnMz09~0)yT9mwzKbV1=z?ONbaYKgewQPpQ6+8U2m+ zZos$pf0%^r)lZxc00O(kXlMw7VC-Z#pMQpc`hY&7evp3yXHr5JayobwdvIK!(*O)q zh)OJ8x?#@Pw(eFS4)z zk`(UPnq%xck_Yb8?^O7~Sx}*z1%Lg`ldiMC0rCxzGw8)9-gHm?IbaAd^#LGo4llr| zF3rx)KGj$D`QHK%$Q&szu43dcjL3Kjl8rKfqK?82l^Sn9o<@W!LIo5%d&0HyO5{ih zdBtdA2uqR^5(~Ndxu3a%#O!H9K{yY;;XAIk6bXzqXpTkOSDKOAYuuHhOpcL4Q7fw0 z|7gQf?3gyHbTJK}&#@tvDXx$juLu-ku!y;&fq2Tdz57=)ENB;i07+Fqt1%YYxN9T? zF^Gx;IIzJ(S@Y>?uo3W-K*#T@BuAN2O!7p_+9zOyGCO$VK*%wULA*1R><{WCV8ylt z54$aI{NAW#<{^kMt1tu-MW0NQLB+mWbs*PO$gAH*1_>Sl6sVLQ15FtusT6cGjPG;_ z%(1uri;Z>FfgA%riX>#A6k;f2{N{-I1t3yO&IbguZQQ2^1egnipdrQ*I31ExWuUE> zLBH7OWt}pInkN{bhIz~dy;h8+2|?yk!dZW{2oPYbp|E8Poo-(4{ZdK_H4jLkUgNK} z7)lKHRZsuBE0U*)496K#-U!`*O#n3$??$aWRVXZ7W&8pvpuEwCHkw})yeP2%0C&15 z-Y-k+ltOtZaupj&;w|g1)&+*EB~Q{kVa)cO`Wai}1)JWNGMsOprHV0vmxP$fBE{3L zl){UW$lBs)O+Wyn55@y^wo$}Ol$3~P$0@@%^i~oJp&)Hv_?X+Q1fPcd%P2r$Aw*@s zEF~3`LIWl4-+39Od^zxdtd@+1_C_CMEU_wC_!ZOc`TflPNq z>u}ww&F-<^Kc~`11KdrYmw~6+$qy@YF-H8wmxz5ZXR;|7dASAV+1R(Iz|DJUfmIQh zcG+Y%SJ{sDNYMdQ;2Hn)Z(lLGB20#)BxQRSopF&o8-Mwq$3qHSz!31~uq8h)bU?tX zGVqdOlvQOwnbyt7wEbMY(@*4<&!nNhe2-B&@X{}tmmBc8LZByL;m$=*>U=LmO*>X2 zAfP+~Wn!W2SopZ@=j6~U zeWu+mW8@kGA6Go~Lklr%3J72rZk305=lhR)#_}m9$p8TX_vuP(oPE)?7W!a-03id& z85|Ni0LqcQNeAfXf-Yz1QG&66tKqqFps2^t&pBUlC7rF%320tyY3(ds1?yh1q^RCZ9n zOSyCxu4hjL)J_(ye$b^~)c%<%fF@V-t#C;LMYZ2br|}#B0#G#8BowAZt#25gF(9Dz zfefLPW0^o$n3aTl^}ZN~&Me6YC1!izTS`i&@C~g8y!9kBW{-x(4=WR}f-uVi+m;#N zRHZORE5WDMnw-$uB=-Qx{u%%Q(e7dB`7ATrwA4MQ^4%<%;%yc_iB3g6i^KW}IFleJ z2@H-6N?r&cU~4Y)90LR--+2zY$+{PRZTb?`HX`X?j3eP0{b$}~^N%xWnb;7OYCr3h z!$2d=8F?}Kh}A}-OTe9jY7-0?0FU^T9yV8mx-5I-2Lc54>-{2U4tniz*F&K$=!As= z^!7-87Rx{f5IEJkKb>&jhEQ{NJRLCN*He6xJ#hKrS7upXNrMPEbzaR^7fQjS;G0RFSaTN|EMYl zv=QL`X+680#v%wA*nO@`;f${jLI(5#@PtWtW9G@~j>lz0pRO7f6gg#<{u7C&d%$}!+M*aSU5;Cl0rLo34&GlN92Yfz(7 zvqzZ+GzX+!#@p~~|DVM^!3-b?8*zth>clUPxc*!AEMn|eKJ_D`QbD(G00h&gvJ?OS zKmbWZK~w}(khrB%UgvxnNR&%N=%H9)Bw^U`2Z2W0l4P_)TZB@TD=Hw=Y%?Z7|3mFJ z+Tz$N-7qN&21aGfek^DCOpKxVC^m?5tar2-Y%t%WIA5`+A{|Pddrw3Ruhi{Obc>UFn;}JiuNVt zL#x9)AqQmmQ<4Wkm^tzi10dGF`oE&Kt+4gLI1`q_nnc;)Iut1WAV3oY01=u&Vo1w^ zEyb6xsQ%Q(-th8&OPG80ni-F_YTvM{zOM7eSh6qbUso$>7>2*s z?~{c(iVr|Ss=&1oN~i?*1Lcvd$h;S7fZZ4GotI;zm%SUXCI}HinIL=yr3C6HRAjta zgm(kF=+!6F5*U%amJ zSDuCucg}j*S zw!3fr_-p!ilFQ4@ciUB!;G(Hx%RMlWs_|+yUs~W${uA8A) zN98dPYvAgeW{Xvjq`JxRU!Zm;;m10 z;A}94fMjoD$iUMw#@M$T$G{IG8!+>38S#DHF3IOD^ZvqyY;DqDg&yJWb0qDpHQ-{{ zRrl&%$1QXJUNJBTvtvvs7dKLRM4bTBTp9hjVgmSp01N?u0+Q(EE_>1TCsq2CK$ zawgPdmft78%7FAAC6GN`l>u@H3^G8VT#SlGEgQWL2=tk9yNu)+jevm0!=GQk4#GId zFM$IB;5SwwDpAt=%utsMx9~_>$Q(AHGTfgviX`x^^AtFNul8uVF((xWsyseQ-G zfWFKaF(t|&aA3<)%f??VJ&n*m5*or*W9^Vw5OyDj_Z%?D|#*e!h+hJXORx#4b+>CvuA3|1{-)1gWhD@4 z!152)x)@Z9-7e2NRJQS-`H6)809PO+ zbHyX~$w;cUjRS8Y0fkWtq0|F=)NrXU%RY3VUFMe8{7HxJG$7IHZC#(Pw zKwP0;XNy^Yryi=KM=zJaL$T84ZnVWQSIT?vbyKE1K;Tbi+@5OlH|<^5lDv+jJcK(~ zQW+uC+?O#-Ri@#Csz02kTnoGPT$F$z9998r z3p^u?C)tyeL}4X!GQifdhre$g9N$yXnt%ZB6p9MUG^MD>iQp;IZ7d9e{*ixS=i;Z_ z##jE=3~yUs8VJU7*tOpj%~ybc*6$w0!;)RtKm#-}{)8VIGhfMq8G~X>c5f6K9}wVs z)++e`JP%v6TPGl|L~I+9AMtF$jd}@u!@%DzrG$5l*ku3#lqeEsE>l^o3XLV+yfy+T zDDMPVK==d7HkA!%C+}r^e7pgnWI9exPIi@*m2SzBB^J}jyL&zkln%=@-Z@Ez_%usy zgu(vy%M0bPSni-HGF+o44!7+8&=p|-RF_vjCQ+~uzdn0?&U%R5dU z0e`=uzx?h2zIe-P%!nB#In-6z;$igVDSt~>8B1+N$tCQE@EurB$P46_B^8u+@UU_e zYx*-jqt@t^sz)!Hm>cR~Z4si;OOB1K zQJ3pp?cIlBLsTkngFhdvt7L&5Wb%jQP%IWEOg8{1yy`e^#^3Q%t2984jpfRx5e^8j z-T(xKE0m>JYYY}`zVbl?$MkbzFTzn@f4XL<}- zIjGRB3HhMZC1HQ$2uhP|?Kh1QoXXHIeS5od2v8k}&>%nrbnlh|0!IXXckI~F4H+`T zO`JH<5vo^FQQ;nZ@Ihnd0TP_;!CJzG=nxmS1P@sI_ z0x<(NDlDOsbO8YRs|3Us7L>R*UU=8N{gM)9D+w`u`7|Fv$UrO1es*?tvv>Vl00Mqe z!F57i5t`IBMX=hTpS%bN3{UWRh&2Wb0&Aoaqd+@kbA_6ZN86YLcvU3?L1qC2I1i(n zGBniKH7cBp1Y!^SD3j}uIbRg*QFUnF`KzdOQj|ac3!&3J1yU?>t0g>8giwq?(g)1G z$MY`hzDpkZjw|1@QJZ|M32{OOpnYT5Va#H5r~&E?z=2{#X~Lmbd`+=$De|;DBHH2~C1~WS4V_~rhW&+5Lg`BFdy(raPdO!%@ct54 zjW7XeM>y7$9*`0Ho>1|}m8YS|WeP-RR=(j%RZ54sLm*ikBXNY&KchrGlMPfsnbMb`mW#H?oT+_y z<#$R++_CV{vt|fbmfnm(Zkr7BA}Ir!RzFEp*l)(? zl-+u=CFO!T%lhS>tS^8X0I+3`{)+)ac)eLW9w3mVToP05ImJ{NpzNR$<@vGjVbgEF z()JUp47_2C7w>)Yso$P~4xP0BC3nlf9%N(Bn&X+wJq!jEl%4X>Y?3#gchXj~ezFFk z=^H~pU>u$)%8L0wM$g zfoE}C@PL5c!2&;rfIO>a42NV2?>;~~c{?zE$v)m)waNR>{G5!IDw7*9qS!CVMF3#B zZT>^%J!S7;|LG^MzF%bk<9Dxs^25qYfDwe;OX)Gll9T1iTa9rF2uOGjGL`)wPb>yf zLYJPB)i+zBGuV0SU-`8w-L=Mm%(DXoj+lJxDmgUhlFyr09$=iT`^bB1zxF`J0{{ch zD0u_`s-Zpu-jj0(1DZH*a-#r90%{yT-bM_j8)U$LN%7x1WmLUrx((reR5c)^3EDoC zb;hF+5Fn|bS7iXeov<~=l;m#d@~U?gTMIA~(6vl-e(l^L`LDf8276!8wggT9k^ zHbuZOArKqH2q7Pn1h(c*CGM1~r5$Al&wwF7yGWYI_|XO!8h{M!`CSA&K+{jt+S-TH zLdGlmxd#YHDoTd|+yEHP)LJ6MkG;KINo>(KNYG4ZCcr>X8S?-F@$z~T7jI*u_nGPw zB#k6wlevaLx?Ahc2Lx!7ZeZ(?(wgWL2ed}=*S{w@tt7bmn(zZl0vvj8>>bj0!789_ zIApeqHAu-loGz4`rn&;ueT?fgF(P2A!E|H30pmN%;nh#?0u>oxG%T0n!T^D2&-uc; zm8p=F(KmkA94h-1GDk%abYt`hewq%6?x}nozRbsY6DM$=&=gp!yp!brpcEi_2KOcT zBMG{DtL=bw`!~$D1i@71NYndIUJOqUebk&n=-K_nW`MnOCV&8mb*VBiefo4`=Jo5> z&y|#vxS#ywCvN3RB_1^ASyR2aWt%WEGo?!>0qc|96eY;*Dg%FyQwqMeO_#V zLkbP3l4riGMEjg_2J|1&$Nl3!f6+<@Vx&L$z>BV=Kotm-jPUXs#8~Xz!+r4XGWV2{ z@Rq7nZ(KsG8zVXW*)Pp?@v6!L08b)7^lJbC7A6~E2b07? zSSN-b`GIzC+hZ(1^7r)UonasWVGY{_)<>zG$mUP;5dZ?MF#Flr+0EYdZvhB2lpTCc zo3v;~(6F@nwKavk0O2nK2DUa{O6U!jf={hhHX&-N;^o+-IL2tvuzBIb0RiZZMN%Nh z+)H9K->Xkd+mK7YAi=%czN=KCw~Ida3lkJ%dnd;HL_pvR0t9Ajvuz#_SpV{`Wl$?2 zh>Y&YhX)8)Ocu1U20-9hL#=Hy4+$6yd9u3>n*Am7AVag?^oDW>ARNNSChS36Ln1=T zC6O7Ldd&IqdV}oO2^FV?EtJN3DH8icAKbO*2?GQ&lsmzzGN2l@sz6YzBlj zfB=0Wso>_f{-Ci5V+g3dJ!NbI2%snuR!}PByAcqGkq25e(J#46N#cf@@r(dJC_|la zipIkO2v7v;@d$^;0YQs`(^7_j0Rrg*l}%Yn>JHUXr%tb)lQs4lPdVtEW`fqwR;>q_ zfk+l!40aS7Vhd4D8RvX?Db~I4Us6`6?BJo-D2`Au(>2zFQ{c(i@t(@MHG~X!fB-Z? z@)UHHl0#?#AqZtsT#B|Ww~|VDJF+L-AZ2a50T;v!LKQp#5D=Kcoc59Dp;&8pivWQ` zVj?sT2#huWB2`rl_O5>YL_k2=3|^*0<*^{A1a-3yOBpVe$Dv3G0eKeyfncxTfyt54 z4MPA!!48ed34nlV0}#L?NcklL1hfV^%R>oukr-%{8oyMdzgzdya-JR&1i!th%^{)&MV?}~8{Bo%DjozCR93my=V{KPoK0K^zzo%+fr z0A*S3M#+u&W}p#EPbP88v7)^_N971>lu$5TCCc#9;x*ihVIm{9OnV6IKEO`^0RRP( z*pbJE%07g0rN~2yEZXpzN)B&cWJ)y2<%o^uy@q;Er4kqigfI{?}?o>0JJ^aQK4A_EJc7JZ{z z|B2ck>Map5VGY!>CmC$oz=<}7tEDg03q!UsU$Zulw6Rb*hhV=U_b~F1X(VGL zsbG#g(iSoxh5%I-0K{u0KWI|!X7Abi z+0R;QFWombB0qhiR61{Nh-2FOxmD=afV%Ab; z5TO;zjrlIm5ZWsQ-g(!B_V~CLCrSZ@`Qh+g0hO!5$g`!UPK7Vab{X*?D(7Idn=j( zJk5>jUkdy5SW$A_@jB}A%*OQ9dBHRq4|a#O8l%9muXOD@X61o?Uy=_jrg>r-JDx5N#3*EzB8Gh{ z%~8A+_h&NrkJC}Mm)T*Oxf%4T3R=WA;*5{-N@p*;@eso0H!VslCIj2&cG0C>4}dx# zFzG_yhD^b4(n*ad>G;MjY7zRXYh-V^n=E~1b+9*gxnwQOu!F1KDv))w}Bn5o)M>!M#54665ApsY; z{!EAvbDQzJ$|a36Rfvn|ce~wE;azM$pViVso9g3zZTmR>iT}V?l8UY~HjHBvk!4^& zg@i?sO)lsF4dNPD=K}t9&dw@Jt@W9X|M7@zC4S+0)m(j3*HF0(Da*QS@q0Fff{j4K zA!N~4DF8&>ef1=k>gX(#oqDuwF}~J5Lyx03e_aF_97$HFk@*ikFX;Tc402>wV>S$& zMLvx-y-KpY*gl5pOni46ZV^6*JzIt_?yeF2#a(kH!FK!$@=J0w&5DIV%FGGMo-dRs9x_am&|J4kiZ~hD24g#PbhlCO# z-hb*pHTNd6nye3<0wXQ`Ka7x*{s5%U-7&DJUQ>tSS+XGcwc+?gA!Sl}_NG|X6_Y?j z0D>jP08c{<))hHV%o35fYsQ4cIj2R)BYlB?OlhIMf7UPFTrRdptv?hwPP9^8+vTU% zqKpWKS}wYd`46M#J^(nF@{w%pNXUA>3o3CO#^p1JBjqYAmQe+!kirwopI`mFn%1XQ z1h4xIIMc_#Jwo`PhGM}CzBBA=3r01Us;y>j)|IdS01`~01j=<&onWSw-w2y+npd`} z==cL1DQcYNez*}}q6HI5#P$VZ)GIQEH`B$=KtT(blaz34M3}9c8q~kC;laYGVW9^H zP=wBndmIPLr9cp|mvg1a1iUOnvCg-0h0rpfJ1yU_`?1gK2*<`N7aya`~tp*Cfdeog;G* z9g?TL0l0^h;7l4QklQ?~A#JyYPW^C{OfUMw9=ugy-+l(gT8ioDGfSOjmM9UuZJN>J`p|k;KpTGbd1a%6d7q zpIHcZk}MY>Kr~U{S#X1 zx+P$KUR6U~{Sb#i({M|%Y$4lPY@-8WvD1sn9X$f=>-AB&{$0 zQ0DGEcOJoXub2|lJx7ilxut7_9nRe8*z7`GT3z0R3ax|+fiWUXRPa|i+-HHpbAtKtE)O4QgNMo>z%|I|H|C=s2eONk}E{yQ&hErtYf03lNLImzUaoKsq8h-9T5Ge zRQfcIU6>qB-YO-Nw%{>Rbhy2rAI0fcU@s5iVW0Eb)vjHURm33r)$y{6sbw0KVKNxS z{0}(8;&_u2snVTf#`O-`li^43J3wRf#Eic3l34p7VotMtepcIHI zURftz-BMm_DCG}0l5qQ*Pgq^bcfJA7R{KX;_$c>ou>HvQ0HR}-y;9>Cimnn(oz>Wv zTku=g@6A4oP|g;0Ptp=>J|66Ir}-&VSL~aEcMDGUyRc>cAjuBP1*zo%>30Qe^xvHE zZWoibH&Q*cQe8?d*wvf`tT#lJFomh!URVoocn7-ignekMeZ|4Wct~TJy1cV2cr@ST zirk6Bomm)yX11K@leU~foAS^^67Tn^2RSJ3ta2^dX3aEtGhL-~x&?#&LOB%fLTD6Td^o9g=E1V+$C{ig4M*!LG z_Z$Kt0B{x=4!uo&moW$m`K}mBDsQn|Gy&V7 zupOO4+w-FZ#r-%V`DoIhP9GvwdVDaZkBWjgHs&kVVhF-$yXcIFHQOp`jWX~OvW_zj zjx#01z&;}Y3C>jUQnPfPtcoz+zxP{;?k-d7HYB%oYJ@Ek`s1jg@9rN4V1T%MU^QR= zJ>3Pjw{`Z*l%LN^(Zi1>Pl#g=yXf0&TF5Y*C+L8G_)xPOE@Rg@ z9#dGX@TvT#s71T&(R6Im2OmX{J81tX7$s;WjPJfh;IjZZy$|(@{zUDCw4cf@3@Sz{tuKg9C z*EL2HD1DnA%$;Z&fufCK0m2OzC@;?pUOYogB`Y-2`~J-2BjtBwN2Sodl%%Q&^y zZ+j9jLEtF3gBy8tL4u>s?_pPnjR}um!2p&d(TH^AVo{v>m5^cc^T#^2wFJaO~jm3dv?d+XT%ezWH`w&Jm zXd$szM%42o`4S21r0xYr?~BBD2eO;TJZdg>XjL&XT~+jc+uI61E+}fzQWgb)!B6+o z!bkjK1tuvQ&D zN!v?h@q1JIS}8)mV3DqRf3iSFlQ7MuCx)aP+ZvGw5OzF5B%)L&WBOQ8yLBnWPucXK&QQ{Jv(xL~rh|#`8Y+ zA-FAz`Ul_T+EI;(qzHZpmiI+b_%(m6jdu$XZzg%0ZHAx>rdBuRgVfKrr=qNq^OXD? zW{!P!{fxPL@8bQSzgpb}el)yrN+eL5lo4A8!v8NH9*qI!>8_Sj389WZxy)sEbyze> zOOyN^wdU2^Z_MLxe}EOjor}ezDla#6KuSWD*8QoLl$GF`X&I+DeV)dbZ@+z@yuz^9 z7gaKe7G?OZYD3iN`D74D+mqIJfwFJ3YM!4JOL4Q9yAl}G1mRA)Me9G6VWtl%gDSPK z80B!36vp*4b%)@pvK|^2BswYu>lg*=)t2o;@zp@^}q&tY*APltpz?b^(@9t_Y+ryash{-_f} zhK|=8^n_nV5dqxx|7h}O#4`Z_3}G|E2$-N1Ep(Q2Y|LmCeq<3iTjed|NhO(~)5B7j z#Ax6`4h^{5D;sG82o`9tk*A5Yz0O`FV+WV7zb0bGFy6uwo8F4J5`gf%B926rg4#g0 zy|%{xxP&$c+4k^`Uor~@i@m6dSk#ljFJ{QBLtz155}+OcuDNd{4sp@)xACr_*R)z@ z1y`(~L=VWs7&it9TD)3jlR=tXLdeTN?rO(G7`760(x%E+hqNln5TqI(1kLsudG_#c8*;k?$^&DGW=!ZsKP)pqK=df205ve=Q7=tP>rQ_)e^#9_}D`k zWk`V_FEI3kiBnL^2I)n6gERv30>q5|BX>ChB}bVhzvAy%z%UGQfUP^te+H!CdFbQ> z8d@YWu?QY%Urs6NpLEbo*_(?9GZhjZ2Nhjfz5hYjALu6h)ma7LY90-@>dT)pS{|b>1}W0c=dizgyRuZ`yL;DvvoOBP{Im zFTsNu$`t9WZ-=BZWzp5OCZM{oq1B%E8hjewvFMD#O!1^)eTlo# z_}`nUyr*(0c`uS}i%Av`^#qXmW4$80{=RFX{^-xmV)Q`@sf<)mvWc?e^EkcIVp?BK zxRBH2BqE0NZ(#5RP9!V%YmM?~{i4KavhiSpB+w{l6LN`swHanmYc+uYuWLAf1rE$k|OQW8)YyV2UUuI>H2A zJyhu%hQMOrBL2+VXGMlpNVU36d6hiQXHj7xXy9;Dxg!}E9r?YxLVzyPjW>?h$u3l# zpTZ_Pj!jE`14T1HbVw}viyI#$0c`^^K@Hy{6W#kptgHY?IgMQ8TdKeSz<;G}GdXxP zFn-H3TEVI`u*l*cxu&*DcAK=wkX2ieMu9+f=*n2$7ynAuEpOUid`2MZ_(OaC+>(G!68SjHE&n9e?D5}DwMSROr*?@KD^{isdDF!8R?w7|0CK#rNVJyu<%&E|AGR5#sAJ6gc}=hs{X-0mUTwHQldtR6+N1Dd3ANKbIjCY4%@}d zTP%UKbV8fddBp1=Rfb49r4XFbRA~K0niv$2^8U^v+to$mFxSeH_>jC86NF$GPBFgB zAeHlsG~2*aNM*3{_1|zhaRDbG9M;fpZ23iB5~%5l*nR##!yLY+1Wzrn=#bM8{z$34 z?PpTQYn{v+k%H9wxmJ&$g?$JMQeQV4-G2p0@rV#%z24gdB+J__0ex-aA2%+?`{-);FmJ5T)FF}$+ zgi1c7`QHafSD3tqI7inCR367^@OJ>LJ*}0tdm?yo_kZ|JeSd7JuKuPQ-in!+m}EBy z_ej9nr8+_Xa<^OF8Y;Sg?e@OrEnVANx)9}>zsTF0EVIsp>xC!=EWx8S9MC>BJcxk? z2e{mL4gF^CJWnop&U^~RtjewA%^OI8UNKgy&Lq_mNu*a~^c_756uDL+Rm#W!O7j1J z3;_NQm&6-umI#I6gCdMM1Of0f#uVZwmyFdj&UI)KqPxzC(e9^&Kx zL_e(}sen4~ug%>{jkW_6E)y-J{==oql*F6jCIkY90J==GSRlzV4zT+2OSEP@J)3TXuzq5;mkA?4teXiV#|S*Dcj7CD>Ne>Y^QRi?H=c0 zz{|C7STrvBSB6?cj$rz^PYeu23%4Q_KO+=cN~@Nwm3ekRbB!O5Kkag6^f3}U0X(Hf z)X(-D2a^iPN8TIp%D~Azo#E<9RV~jtO|lM@g}ld#4GT`Z4)~=zm`BL&_3sQ|M5|$C zWnc3ztX}7q|C0@BY-P-xfi@Ayq(8#EBHKtJ1jFNr_VGrXqH6`5i?Gt=&(erwx?~Fi z2{KO+C3JEF#45x*3^lcLbnprGdnJZ37I-W}$iYyP_UEq#<(OR&Gtvt4X0?#gj{Bb_ zvr+{Gb3&MVR#$1KN7Zzo@Hf~t2{*q#8~y^ovoaZo^CpF4Cy!!XYG8aMA8#p7 zp@2#h)|%!@KPYZb%Ahi$&(dg=NNjNg4q!QM<(A+Iqx0w}O z7$@t0qT;)~*!VDZ7C;u+gyGtctS|CpK$*mih$ID(Z%)DF`F`<7)y!mrK2}Cyh63r0I#+)jVTxgn%rxSyrf={$sC z<;y$s`(SA>0CFLD!3^D=V9Kg3%2ZAAlDenI-mmV5T9VP<`I*Iqq8AG1J{2u#!;TD@(5 z{7@`W0$S|@7t0_H8aID@QD?SXREU_>Q&Ylqq}ZNQt_lj#LQyBomXExxCUZ#0lD)c- z>817^2*{j9qMynmh8%SvE8`n!Mvs?z?u=&>UrTIqit8LC?5b?QtN+%Ly=wRP9Nt}- zz4OsHnEZa7jXf$jKUaHiQZ9WNX{0~0v-;nhic|4WuEQ)I&vco-jUe0ZyR*7E+kO&hLjBfcNK9 z!1&e+MbAJZ#o@8d!keV_Cu8_+n{t-Ww>6>{o!0O+%kEIJitZn7`7)6LcQBw#Xv-LC za&ary(=6gUni_+G0)c{iK!hYPEROv9G>k*8(>(828Ixm*MF?6{hNwGT+fv4sd{tGa z>bSXxJ(6Mzx9zs|@=#otg$l>aBB_fx}3$PDM>38Fb z=3`ZP2N587JKYlJTfhOzaeTI+PS;z7yT*f?ujt}ck(86zm`y*)e4ARcvHhx9vrIrOx~GY&)<9CK2!ubz`u%kC-KTjPcMrP<)2dxO}T-- z@~^w^$B{=BvNs%Rti?sZ#>^KANUF#PS)$-~3l(YAz`FP&c$T=Yh`Y}BKS+d48zs0N z`GaF4kbbPc4(m5{kBPJ1owhy`9OOluy06?j>1|%=7BK#$;VE>wnB2NlXIvqpJ5bli z3k(rw3_Rcec9jPUJrGFni7~3v$P$FSre@#U%MQn6BEyIkQ|1hloxb$yr=0&g}SBac5tvw zx@=MZbJ#OB+<291r);x zZr{NV`JRUg8Y>ha_7@o!74PJDH$J}1jkUhTwRm1_Pd<~HbwX3ySM+%b9k z1Td`%#(Y=W1~f{Kx2X&yy~+}4b@EDJe|y`3%A`6c8XvA1=MvP{PxD1B@7=j^X@w-<$OVX**JM*dsf<9 z4L8ZIo(21Suh`JpPk@anKxUa|C(`Ib5`nXGoM;QcQ&Ly9<&AonSi^^ugT#Y{8eqr; zImSPeNsZ-Kok9EY*Fg()`ui)76h_iirc{+bn0j#`$b~Rs0i)jrc99<7Dbc0L;zY;- z(AxgvX(Xf)p}{)6sw^Qyzq-Ng`s;U&GBNaXMvM=3d!JsJX&h&GGQTk%wo}OJSvOvs z2#M&k_YLdq+mY|^U#ZGeq&BBNw_zs#a_EiG-vt-6;Dv_-J7B={`*_!mkBsK{4n!i znv-;o^ek)J{mHR1MSt2DRBV7p2tE{c61w_{qaZVF9@S62l&T!w0j|3s%zUd7@j)s((tDddI5OUku-kOL6f^#rl>l& z*ia<23au97$kG+L)CVaIWJRo=3j{sb?X)WL`Ttp z$K9&f_1<*2WP`tfVR6)Y6Da(4U-k zqcxKSVtGm#e&CN|{Jo7Fwrzu&j-EaDol-gA*Y1FPr#TtJ4n#tr_oPK64;?kfqXU+p z)JEpymy4|pH*62zp^)1H-T`6)UA8fA^Wy<9kp~JWeh;tX;}2<?Pl(Hz9;MaFS^DO>*bHdE8{|Uo? z+iN#~{O^Lph8p~xIQyOy6`c%{5z1}1X-k!`PiwKU8ni102mjktx(YB0H!@ya-U`H(SU_$5-*LcGPV4J3o6n!;{U`Ne*U+S}|KCCbP``cB#u7)A zSdqf|i!ANq5Mlps6#>u+>YwYdug5$)d68m63i_LI`7y_*^(1)#vIsQ4c^6LHjtYQ& z@BVKQwsC#{c;_IcAeH~$++38ObKAfdNxjR&eCsxq())dUhr#Mv!;kC-pE(U*=X@?z z0Tu^k9iIQ*aBFvzyFF3dQjBUS@NjvS#MGsY>xEPPKMx|7@pDU}rG2zepKsy+`-lnu z3!L}XQAA&qHtnnFjOlmj)ocPEHVC^j>nWtx zJ*w;|vb>4f^_l3XHuuH3sUCRg@QHcJd4tz5bJ9hol%xtJ-3n(Cy}XW2iLuY7rf;9U ztQ#2@2UxXO>^57Xx$60HHZr)DM1W5IJLLUJE5ZP<-{Zi{jJ~Q2aP?V_Y+FQCChhCw! zyv&QmY899MI}p7Ty$-2Qv+F9n7v$I297McneP#52U)BF4@mLb!jz+{^x`-(KxV4*! zj%m~1pCa^B*F>+0KmTtB4}&$Z4uPrJE}i#Rv`cbzUU?(ow>z*f=ahxdSa&W{1Xjl47t-~k#|v90Dvd>;{2I% zpslb_9CuBsH~HcttaotihE4Utp?SS*46gp;+3zpLEJVEBaN zr0rRR5-=OF`b{ngY^dpmTcec~x#6D8{~+QazB!i;aEdzLI!$wSo}fi-_!0U7#+pcE z3TNh_i4)PFoK6HloHc&=as(Tdeg2G+ak{&ImvXtbi^$czNB2;PD}uh~IlA)$P2Mq2 ziBV91r6mK?Iyku{>XQ8juMRg1R=vEQ(K3|wD0Rj;bby-MD{X6I9VAoyl$5s zY@MvxI%{TXU0Nm*C{WqFBb!n(FZcCOkpn>~6O}W4p&^gU7bFJt&oy}s-_?O>>=v7B zFHe{5?zuIxd!~lG#`aE)s4WDXm%o+VyL>5*cAW#I{c{ux;xPAWYftBEIj+LKh{oM= zXj-@*BI2oXY6%^s#Zy@NPoL-|>V!%Kd!myW-Zj8e7d6#kJhk~e_%d7&%N||6eH|07 z?EQ;aRD}^R+oI&Gycl0^d6t^^oKbCaWCbQWPM{XeumTH|T!{{J@&-2$`IR0nJAgw3 z_}IKDkyPyEhXS$-i04LW{$3XxZ!>SU*<@$Vzo4_WFqGd4;mHz5-CVxMhs)dn4`t?b zSmws+La8O}MB8s2kUuCJmZ|!*v!iTU?=?A-5rh=+ECtN+QvEv5MnM8Zy zDSYmk;{;8R(jkI`1@~g^YtyUG7dYpcCVr& zs0es&9*Jk+qUbL*GLMGeq1y5HSNUDL*?y!i-Qy2Cf!=Z6H>&r>D-Jkc1u1$mD&y*^ z=d!bcZwXTpPG)b5+t+DRS`+lFHZH#TEv(bF++o@=*yu$b4HNv!F?eb8JOnUJ$dI4- zB(Ndd%Z!p7ut{Z}JRn-H)NeCKRN^)RpuIyxlo#zs>4u69V_eb-rX0f|;kbHyW7qC( zNV~$ig^$SXQgbHFjCG&CQ!ndUo4hvXII)J8*-rdWsbBja7C?~!`UpC8?J?4PaEDf@lp+9a@(YC4Gu1vn_+cOo_r@dwnQZvKEyKj9tm#@V~eO?QPhr(`` ztDD|S80Q;O6;AFDQCII(Li{TRZEE}Qcr30r(r!E0PPz}<41&05$YJ5p4%o)<)|zcA zg6}C$)rGYagW-bc)}NMB@;}STHha3?{a=<#P|;va#C@k>L0s%R{>tuBXDb0ClEmM@ z3Xq(Z3(qs!V`zc|^Vcz+S1AICEe`GUo+~e~WVf!aWAVXi9<&l5nvIg+tXyEs9J;D{ ze0G{gKsM9w{Lnlce6t^x;M>EMjWWb~DP95^XIE+b4jwR5 z1;qeR*Up08&_FRY1!hr>AFGr#`fT~(+R!>=0dwC1vSHzCyQABW*{geqs)a`17|^`- z=>446HocX|c@JShuchN@j%7c_h^(!4m>^)R-k+UxJ|=dyyApyTvQLX>m^`+`Cq_5S z^!|oN>t?v4xzv`S&S^boCP6QL1t3m&tg|{Q#h&1GRcW{UAafAv*-?q_m#?)tfC#-fXqbw=l>`xvqaM zK8$fgy&t3R*wz+>Cg?m6IXexg43|r#>saOPg9~`9P1hsU{RUGW(Dc7pp{T{k6MpFQ~(8wQmd>?SrzyGM=t;(yF)aH`yV@vf2MYg9kOW`FA&6IF4MZqm1ST z%u+8RnyZ|XVRQzWXznjI674l7JY5C8ybW~(Fj|9)IY`7;$>Fg`a1#f-T4F|R!{_45 z3wm``h!Lx;ZlYUZg>P(^S$BHaFH{yn0YaH>H)(t8nLo_hel<|Fy%N8y$4qwU%F9;~ zeuhs71sH~BVJ}{DUN(j}6GVd!O#u@vo_u{Z#4?|^TD}AYTw$co8#>9TaUUeB{kF*X z8!Z!)dH_0U*2UGdg5O9!Hsb)N))?wDF=9!%eM`l9%L*r=i$vOWGS$HdZVs-khhowY z%Cnc(h-C@$)~zdtRUf@(692j55;r@Dc>Oh-exqxQljbtYOA?kRGaNq%d!udUTOmq4 zkrbB8V8D5``|u}ux>aOPswHbVx@16GoYHhE7lOIA}>gPE~ zovu97U5&ejgxNL4TUvWj`4;3jZUxqcF2bkb83dlbkET#6J4s`Wi8ZO2MajIh`0ZY; zN65=LF;E;~b96MJ(x{{g_MPN| ztk-4L-R&dC8&cxKc2;`?-Fv@dlI!PqdCUg{#Yskvo&~k!0#3N!gdrf|VBjY%0qE0H z$MPrkmS_X?Qt$RY(HC#I5U5ctgF{c8G5wB?V&-~Bl2cvszX%a*H;{T<_%}T!d}EwD zwR#*j+u$xR^uA=p{WBi8^Eca4Qd``;o9qGn-R=edsf0zqJGFD6JT1*p+FOd8&N}q~ zpB_LUBH*{Bvp1~A;ge#B878m2PwhRd$C8NJLZZkGNtbv;B7)+179_3$Tuy=Ry$ZL! z?}|Kq%cM|4Sw|ssrbUKx`K|zn5BOQQBumy)Yi{c)MkbdyKtKyA7MZ<9hCe{+YlY_I z3(tmAqq68}MdZOc?)XC`a?X4Y9L-0%Mgr?zj{79HT(y@*&*?+;bB0wZQ;Qp%{qQNS z_=Hh5Fwqu8c#ev{Trfjsm}TpW=@+p2se*}K+rJE`Y~tC%Jp|?BEK~M4ivg{=Lc`)R;)1zvX}?YzShUP zRS&K$+PxJ7OMi&_F86_U_N>7QL?)4MGWz|(A*?IQtN5rPVM$nE!RvBAVD+kMi~N}1 z)~N=Ave9w-!wELFInCR&Q#H2;V4jDT9+Z5(@>6oHTaCG+;QJ##tbD7T&q^wu;<#66 zb1Lf%1NTKe^XOx4n1Z{>t83=xNj0j?6mGDQ3GRe~jxMdX+G2cb=UO@?BRA50jXtg* z&WVDqfB%&`PNA6hX}69mknH1ERbhIO&-J&fJwt6f z_+(;r+tR#fuHG^dp_YgXWQ-GWlg*`uf~?evzHh27caNo4{^^}VzF~6cGc}7qR}`5D zhw3(uuK9N7mvP%y-%F5Ea%?l}pXb<)8U0lxsY%`c*U5!TzG{!Huu44XA;8o7DvDk& z*bI_SpvHP!=e6g7EtF*9CLqpV z!T*|NH*gKQFtn4^k{D)W`#G8qwxmm%?06HK`It3y1>P~rv%+0(D#?S%?M5J40%$Cu zeui~zE-<*3627Bm-^sM_Jj9lmStW3i(Y^JR%-=UGfjx)+je^N%goig7|FDql5Eg>4 z7TuN6M?D}W8a82>Xx?-3Xv8q=ZmhJeC4)p8{A#BStWAgdF3OLEM zQU5|N<7miF86p-g^5V^khdS!f)TDLB=KslTSmsGZS~ucmo%0jwW3p{NHPWrxF+;!W zN3Td*9ajC&l*3zy0!EhbT()A=zKZ7q@MgWGPZ;GW>*gPsg&Orvt>)$ym+c&Yhi@bJ3H^Vpn z^q$K$f=SamS^!=z0y5ko;U#Q6!)Dzo_POST<-pxlA0+8-@_UH2f{(BhF0QHQsI=Rc zqxxM5nColC;Vb4O_X|cu>=I?aQ5pt?O+yuK_JY(Zy8G zXU2p{|11P~(xJuggo@iT@Kj-bu_Hea^FQLJFPgO@gF_Iq&hLDE*`&6g{=Nvez=zU^ z3eI`fvoi~{X0J-)Nd7g^Y=32j=XH-u(B9M$OJ}61n^JQ zZaK%j0lzL|gaCeM^y0_Av*jc^h$Ey^{%M-2{nFukWU~lE9HEiM>^B~3`Y4ti9vm~F zl)Y~M>?oPI^U&bNQWB;up278#v@w28{T_fBtKy+KcBo|2g!L{NhB} z+vQ^{CP3og?43fXd5JLE;WPg~TD$s7RcZ@(dD`VQd?IuwP|B6{wTL8P2AZtlxu!>{ zX|Ia$(|qum<IIF5F zUl5!U>YAyCL@GwP5vtp`_Pm2Ss!kmmdxH#-D5tY9kIVdf0abRDHbsy)CP}z{n!O_L z5gLs{x)%vpC`_Aet3*lPdABQap3`Q^zsx%6`sLS|8_)yzC4jTaRSv=WF7CiAdQ}YH zvkbJ6C#_#e_maE{1x)YM2SJX$iP_;Mih^`r2pFXM_ zT4tWJwa)q4>oYVGAVDqiwF5g)qtMlwK?M%!r5Mw-#3DKt26(tF-l~nmk|@KjPwxD*R--q-%Pw z`zWLOgZTTH#yUxz%~&IIFD~I}nw#OsM1@|=sZ?)j6_ygT<`AooGHmPYYZGLzzWpZy z&DSA|_%m+fkPOE+x5`b(?H>jIer2(sK=i^k`#pccOTUg!x$?Ihb_l$H>FEC2)`3ERYL zVqx)KSsi^0mA?e?#I{I3{Z#R1_ekclw%UqowBVoGcgmJaRWE9|1etfq1T! zh3y;$0*CWe7pd3cy+42ymnVZTQd zNL5;b2QP_`wEh-tZhkAPItiRJ|ACh?Z7!vEr&XkrX)>hI;ST_b-6nZp z6O-Ud(#_QL7fzseCB)~F{@d*GIK$7!!{1|i%jd5>(Hl1rXnoR)>}5HMF2-|U#{vK@4)QzOY=XAdoQLaIbjtP^ZQxN=$z!E`79CS?7a|uP8mgHv zsumq**ksOzTiOR^15ywhePs4|s2!y>gVp)7 z7Er3=?Xm~!&XUtMa!=bD;TJ|~gYi*LwCk)&t?RGlY?#i3x z5f8_y8j~d31aI?n=z@(>z!M*OgFkznOF9NFv3~-KTnM=!$ebeh5dLZN8A!aSzD8&I zEbfe;=oM}$ejedg8UZt^Ag%ub!5oB(qrXpFsdJCqD4h!U?-tlX?rFAyBm+rr-a~}U zZ8aH^lgWP6*lPRrTn}8_8(Va^t^5T7uHmx|rKQWGM>=sOY5_4hh1X!5Y4v>K~R z1MnX{x_>zSGobxQl9i@MnH6|MrjeMxe@+=Ac<-@CLcx)U36e`>?SgxUEBP9e`ZL6F zbS!c}>*l~{I~{tdRW9W+VMV^mSnGoC0jtmfh76C67wRG+plSn)h;fWc6b>zVyF!vO zSJ-Mljv=bqnbyCVOv;5^T~wiV(vAR-5&4zx9U9xmy$6i2At#Cvo3RNRqbDuGbWzJ$E#WmW^G7Jt-bPD zd<&mQJ1m|>R7DFR5EAF*Gr zXbUJ4BH=wzIT7jbkI$lF-^8b`Mc%q36%2)2-ix+4As~5d#3K^xL$sX9xL7xc_&p(l zk|2@i!yre=Q3fNuWRc`K;NZ;J5r@B(^?W_xY5vR}1>-sW6Xjjwll<7J%x??}QwmQb zVk9C=MczMD3nwv~XJf3#8t9V_m_osxRf&*ti8@+eLIP5m*S1@@eIcIA6x4$=@2pAU zJ!ap#r*T=3JPMhO{u&f$TbJkWVx6#zz0c|j4WH`_;D0U`0eas6oR;l7^Q0Y__kE3* zJ)Gsy(2ZVsPD2+mJmVZ?h7GPwtzg9YbMEt*cEt;NCwb?4c}RIP>b|drJKHNN%{vt4 zVSh)eQq2nLNBLgCY0H)W#)4K#(dU*}hqZ;_kH~vAeK(H9%BQMBWkNZVL~6ln!9N(y zc0-lH-tPCN<4TJ64Z!xTyhwy{U~6Rf2LX%R7@OLVW%+1*Ui$z|(n67!d>=Vdw6wwI zvO6jeGU}QBG|ugi)3cZu3Q~6*-Dh$x9x1aO)1QwoWmTwgqrg^T6q87H^L zVY0D696x;N?;U>z*2OfqvY_FyM=Apu(q7!GSjpzHb|A(oo42mOIx4X;Y z9^5^+yDz~Z!QF!d5AL==0t6=z+$C7h;7$nc?(XhxZ*y4})vGgK0u|=-#G-&8 z5PWFHt&<{ShtuM(u*Va+Q5)p_f@|LS@O2=5rPh(rLwb5i;m|s<*sVMN&G%6fo%a3f z$E({y^gS|;9Rp4vyIb)Dkfa-Hj(JyOVJfQe2%`#abb7&fT}$-Y=9M}RFrS69|)R{XTuNU9t%f5N&2lIIR31x#t#p+4f!^?j*Pa)sEa@4TPt0=M$*?ff?V6~A?9 z{h6% z#NuMyiT4@@-NaQG9)EhqESosV+(YL7aTesD%Dz++p#7!F4l;^pIXydG^D}Du?@=QCCO`})f#1TkqVg_k@?zm3Hm&em;bcpxfex?TjNK8j zM>{z1&S=)@%hRqn1>%_Oima@7*FZ#clsg>4wa4tL`&SZC{|5bb@81VkN6v6A+{?dQ z3LAQ-bSZgx`wboE1;4u`_#9=nH?@mhRY$~^-@t*$3~BCIVgdg_FeD@9s3^mM6W(N_ zhm!XGGTCe{_kGpk-%qWuC2}v9LH#I>XSbMLQU$}C+b9%hJ8WAa`%&=T^0{0HkcVQ? z!3!XRP6okpADF`Kqab}Yahm?ibL`r23$$uKrVPh{YQUy2@UD z*$I9yPz|sLpi%C3jXo#m>_CAWC^}D<+DxfA&pBO>dyQm&#fcG>bgG#S-s#&BU{yY= zeA-Vmn>XGQV`vQ|CnmsNNu2=IYf5{fBnU5X1yz`eh6|v5uj2Gx5l6-9QxX1&xGb}9 zuQHC`I1m?)mlxha5TWOhq8NXv>tuomSL3TRDkoqnea~^np%F%W`QGsfsM0fVrZ_7)OD0XK!emGNtrC!Hqi>7m-MHDa?wM)osS+9Vw^-3tJ7W|ttTII{9 zIlC%k$A^0olG#{Ql^U0V$W+8(>u%kiFw;vwAT1DNIqyQ{J%ud^H4_jYxe7ylm4|lB z+rxoGF#WobhEjcx>%lhfIXgn{t;1EFfsxeDaKTMV5Ii?JgaH6~!6N_)ys~N?&n;1j zD-=!T{%VTGLGSZTPw~9dDO|)nT10)cTB}2bqE&x!h=B@(zyWpo8xp7-R}h#xw)4Ja z&e#woYPA1A>#DN3PFqfKL@bxhihQL3 zF^Ns5Oh5S=@KRD%Va9%Msc%--{@8FZVaJ2@X17_z)kO_KXR~jbqJSMLcQJGuZW^@- zF13MLt*BSL)|EM_B=Wx=v$-J1_MMZJl_TI4ML1T}r$IpZ#S^XhXO zAPEF^NNX-6m46lG@O=1zPz|ES-S>E)B(|*fM^;X9*WPouiWGOzK*SYqUuP&_#4jrWt$wG`SZ|;J?+4DBn2bGc zXr^26(YJSabWgS0IqHra_GeQ4XG}?SCil>EWmF_cu(n2O6AxG}S0i7Qf8&E?*{O&z z_5Ku2pYS8X;onN>2Ph;I9mX#~vAFcA!z$N_f0) z;qn!Y89Ik}@+~;TbL3~UpRU)NNvdjI^L%U(2_wntZ6Ju99|)Rar7Yq#po9ez_o|=u ze-)TVfn=k2ei5CNIXJi29SkIGdO)9IiUB!W=N;{J8To9VJ*PC`?>oINBan&D$) zV;mmz(taWBPUV>TE@j&_H>9eRrLCjD>LrEw)f%`Rq@bBRkK(RwAR8bZ{}^Of`dK~o&B zdtGEhMxs7a*$)QkGHAxZ#_~>s&xoKkq7%sQZE9zvK`|-DCPL-M0CQD|*2{EZw=*#R z%LV&FI^}FFq=!1hKw$={-?vhF+nvSx4|M>cFai?N5OwvJ-w@TGra&B5gg|dplN!S~ ze1<$XVhV(QD#2F(h``v_2^F$7+x}7u1icN2>gBFJa&kSOm|=~KPpF~2{c-BwvmHfx zq{Xh!4p}qew|V05m@F*E|H|1dUE0&3T2M4KJ=5$H@L1$?du@S0?Rr4nsRZ+*DFZXn zku;h-PG3r9etZjGTA^Kz-{C8Pva_BbFb4?vY`~vnU;Q~Kd{y*V8H~b`gqm8@nL5~O zuj}WgKvBGm?PnzS>a_o9>CSL`n(fLMt!66ImzyUk zwZ2ld$H+_^S)SpJdJT9x|4{d&T6+^;&Z}Z@dN+3Y*+~-D%d*wrW(*UI)WX)`84Gwl z)$t}#y8VvWZZXo1ctn9yx;E&}UYVyQ@`7`yvjqpz%Xigh+GB>8L;|qYwv>pmV#~!U zKL_gQ*fcZr61E2CW#yUtQE|)8sm!UZ-PEh=WV+HL1o2TURri%8;n*DVG3x3W2>MK^H=@R%`Uk!C|_ z4XtdtGcT`^BoY2{gg}!?aK~BI^gz5s2h1Pyy{v=WZM|ilLRYfUDed@dq;fodP3Ma3 z&UZy-t9Po2cF9x$fWEW>%_HZ~4&$Nwn@Q|rA?#Nj@17!;{1~yBk4eCj!qqWrP^}mv z38ncB)(96L=IpL+hfOwgQ)yo?V8ltha{Fh08%>l+eI~zMq8vojRA42hN!bo-M7BOG z=llFQ6q3P7E4wck7p_|4SFB$=MRfEYg4Yy?hNZ(NbxOrc&&TX3k-^aMt)JpK(Jm*j zTEf`HR&zBBeGCDATQ}=P{6i;00d|XdQ>xEZU_kgGs3X4GvJ<)LdQV_%dia*$P5j0( zYgY5j2k}L-9dyFvbtdMLnK?IsOWsQ-N@H@#blb~B(t)lOm| zjX^U@_5F`qefx7P_3Qml!dfPh0W>ozCN_EOuZ!@mkxs&H#*ejg>fh#Y)wc{d3VcjM z01AXmO9Ij;3?ou2bW_r#{Ajsog40y08}r#K4r=T+&L@7`-F~c*(~5a%$|zgAG3$#H-lMeqU}#^^|3DuBx?jko97X&-`U>2ntp#sP+nhvF^Je z^Vb9)dj?MYyR7@ToV_?asqb;sF9qUzOU)u?@0D0bal22C+3B@+3-@s0OT$7wKG9wc z)&_|~X$4jl$)BP%x4Lyq5BVUFkgp9sH%pJ-QoW^S%dzClhp^O?csxQfed48e25?2a zPTK-5!$mpy&HwIOrQH(FUJbmZ7*AW}+M`81U`MjA@;Q6$q+Cap{MfQWvI4(Cgodg{ zAB)(-2%nJ5OtZB%%XAC{$!y7A2tE%0aX7*`miXJQe9~qm@mdMXwUmc!(?gz3Qyj&i zz8vUshuJoQJpF2cDgd=8E~)SF@ykc^zn7O9U6vc1HY0h@npdAkTA!*Jx&VTPb1Z5( zdH~%qeZy+{Q5At3FE09MsM-<7+%reDp%c2!QtTE?lEg{l(Flj+K&Y2slK!Nl?$Nq#>G z!#-_$OP(8-lU^o5JIX-dax^&5YErcCGGG+OsZxuaC~{_hN@ymIjHNQLxK^y4Y}T@I zPBFM{X!A5TqFaW=oTW)K)Dx&{OWZ^W0&s=%)ScNY~uSQW2g`SPc)k z_kU`5#5O#dY>>v>9V-&{VF8NWpUY2vs)ZwU14oawXXCqgHc7o$cfZGvzj-Sqj!T%Q z1W8I=E9N`q{K;tv>CYizv&-3+Zp)DGFwSB8i?iPuV&Z6!$&T^-jLY!NZg6m%jf(>oS#+ z+uV(ebyprabqlkPI+qcV=H}giezQ761TYeVkLfv_s?5RZ3y~rf4P!n5_aV|xDK4ac zKN6;xvAv`hbjJ?LHPfW~=Gn^hg)>*pFHO`Ip>pU>=|+0&B-WC_cB7OW0M6OMs_@(P zN9l6#PtE=3KOeIfL6qRrV4!Tp%CU{&4IxKJFl6+QmkFtfnN%|;TBfe#OH9+5yEX`^ zz=<3e3qeOBf;yZiiio=>!)-?Q10x)!_*12Rja3{laHUWA#CU|H;*X4^%vO`WxKEj) zf|6?*zn#Z49`EP9qSy%as!rhmr}mCO#uI8HR`l!8rL31*iQ77FYWku}NG1H6JvQVk zPsmzZKyA83vZBC&N>0B$MuwLmHzi~M+F{yM6#Ixl7mx?o@&z^miuVL(u$op#@!%{8 z7~vEcDFb}-Il*H47$qiD7$`NCm{@(>Z?j>#sJ2lfUq@1WH*X_fV*Cp+6w9tyFlbaK zowWTmF}7ug*A1Ecrl~C;N(@aVRna*iShmzGbgqJwps&dNU7r<*un0}89rTiNr$a`R ziRSKCjFh0LuBNmMaew)u<&b-OR?fsD$Xuoha+!bXXGt@;u|-p9miz}OcmwWvp0KtN25)V<<;-X^kQO)j!pJR7cl(w%oH6DcU~7pI!E_V z$m|ReBB>~46N4Hf;ExhY-9hi`>i~fu>DTdqy>XiGH+k$iS#Z_2^8H*UP7roL$ z)zI}y|4-sERI!IekC1a|osgMYiR(Z>-3LT#@s8t~B_~iF{6P3Q@}uLW?JY5CjTRqK zF}k{ixN0ddvA-J8LZ6YWEQwSdxx>|gBAgASi1NpqLchZ_u!{Q};aJMg-7e)|2Ll`c zb-t5oT8A2mbOrr!=MJFyJF7$qvR%Jt0f(K2kYbLSA_=Y|B`^DFI!T!i=8=l?g+~#$ zBn~B|FtwI-(&SWKlDGJMbxu*R#4=sS&8BO`O=wl$^O=|W0KgDItJT~MkW62BAV&nX zmK}h61@V$3n1-$te4sTWDj9W7;DWvw!@x4|zgYM}w(@OXSV35K;(kYXg*&YoZjYle zF#WLw+z|^4i^h*#A&o69BBk5EKQ9Z_d!Cz;`Ct4JF&_;%5q-DVS>Zoq=zVOUt*?GK zQyP03l(ga&@wekJEq$%L#X7SY7D`2#c0a4YY~R9fspPN{-uuRWS0Dc`lBa}nU=Fk5 zc_0wgzpc&)v;9?Rp4aVqZMaHEjcY7Vy5SR(vh2*hi7UkwU%{f!x-ItyifxdZn+znT@!Z?fS`t zw~dEy@FKYe;{DMiQA=cfmVMRiYd@mE0G}Vn&pT8bxMrbgLM5BJq69QdYk^y3CGo-pj zg@boWjCu`aR;SH5wb1ri2-O5_My0pUVc6wguIZXKUT(D{RKZ^lC-D=ANmaZUzX;0x zitV5El^oAO$5&<4xorxh6j510MnRoGOgXiK$pDqN8D(%ZH4sTc8YAa}5sOaGhuLVj zhmVKZ9iI`44g<|Aorbk;lUBvo+2T7d#`W1;H1RY~VAdEZ2e^shbgdF*i50?uBH%@4 zaF03ZmpxcaTF_IRU}=cTxYTfz13wDU)8C0*?bpYl$ICl}2QdI7G|@x7Qg%R@P{91} zojF)QDF^zPh!&^?6G7q*AB#@C6;ync)Lu{iK0DGxMAO7~Z3mbs-9D>$Q)yIm1vk-G zgcB=h`t#~gqLg3bXUS2`TETOM;6ur5keQOVP70yl9BO78fI}-mV_Zj#ge&C3v}kd6 z+6?o-?bthvWs3-hyErq;*gC$;nOC0Bm=oX>OHkZye?=!$;{bo`^LZ@FoW$zN?+ti3 zIY2A&n+_E7WBMf05P&4SY?O+&wQ;NhHWRYYIkj)Gz4P@4+ zV%OArYlpDhAWD;*YVABAJJPzW_J%d6%oQm)vyTX28y5Kg^feGuVVBKk?-BN@Kw8&m z1#FHFK9KOqlQ$|FEytphyV)B<5q;>rLekd>)denlP)O7A3_k^rKEmRkIhUrFF&76u z(Gb7-cV4&B3Q?4PAg_2fxH5|Duf!nXX)hS$QtktoCC%wjIYBAOc0W&e#cyarZOp=T zJMKFt5eFM4<=K^B2La3baFjp9%Z1r!k!r3xs>69Yft+x?qtngq1@jj7sr32wQ{M_? zdyC@;mOi_Dr|ya*YNq_aTMMJ&MF)aXK8AFB0|G@ggkQJ%s492%U-3l` zd|CY`YaGd3^rdkkl792(pwfktL!bi{Ra_!(88()c;b9!DtZ#^)phY|SQEKS107?j( zNnUu7YDbtE!xQKSw(BCpquL6~z!v(=F!5(pzT?QE)c39=vQ9l^;+k6`y?XFv8ce{E z0>RtxnP`nKUk2I)S|d&`fj~8cHcONW^IIm#w*BLXH?$L?MhYDIJYF`0EI8P;Q5=YUe4kA3NVd>o(^=EQh45lDG`<510P?{Lk-x6glBig0a?6WsxN# zIJKBJekBAg{?U)yx`viyNbqTRO6Fe>I+@Tzt!^; zSD0qEUqbyfE>_>W9|k4YkCE^R!sD(m52$W@2#eApn+U6;awBtNN*=Uh%E(u2aTQ=4X<@%5L>_WNq2N4aU_%0Q zcCwF8-!I=Z^!R{5@C5NL!m`O&URiEj1%FXe`ys2 zP(YO+MSdIZ@&B5IQih~*1ygpe4WI$ZY zVol?PH7C78Z{#`S9Jf6Q?KYnbQkwSTY@yLU!Mqc!Xa=Qe$^sFUqeMB5edj5q_4Jz6 z0wk7Yb3zvl*C6T#ZC#W_AReEX9J$}TKfU_jwmei(Kxc&9=C2Pb02)>UIO~`r1Qf*I zC)$kmfv&$`U^&)-528OL-SECo6VFqimPNc_^xd!a0|YSErB!S=)FAwPM7wfJ23bq? z6l;xWO!nqWC!T2e0mhq=znENJsgcYr6_>ygoo(cj*=7)E0$T@^loMqvKq^OmHoy5p zkhy?VG_yON$>757%P8R+f5lI(1V=#$N1O-g5R_c)0L#+@c=y$@mr~qyF>2v&SKN~X zrbZV}$ag9PC_-Y_4&Pnv0Z2jIWkBE#1pt}V!P0-j5@i6bDpd;CD1R?U`_3`Azt`-u zr#Idrqb6FN6B8OT9QG%P@fnMs0f+DB$s~d6 z%gA76#sdW1i1845a&OKAXj3YbQBMyeLJKdlVI0b5QiX4AtVnS#gBrg@7Uw|APp5@v zZ0OL512T7BxeDUgs%}AkhJ{Vqb8>z>Nj=8?p?E3zFL-EQB$=3!MI4h!D0kqhnG#zY z)UMh0*tTlPo@V1g;5{zrGYa!*kd{5->s6t+TjMe1=wT6|M9m*DkChbXr%`7~4M-)d zKCaBLYTSOcdT_YawT^`Ib5SWnsq1a==h2X9{lC;j_2-Vh|D24-e}(GYYC`>f??kb% z0OJK}OoCUqF>ooY1jm_6e9mVN5#BRHSaPV`;Gc>)EcFV#c;WB9v+r<%aXVEOe@OCb zYIy*NUAQSZ7LTW=aF(o}z6fn@~L&96a0V@NpXWCRt%$)W?Z zs4AbvDNwLHC(RFmAPQ{CGi#RzffbnM_13q1lNKlA{Sphvxy+u+HwElY#%&#joC0C( z#VUp|Sdc~)C5CFus{4Bh#%F%XzeTA+6p!b2h$zrbfSigEnKk2#kB$qx0!uMn&DU^M zrL~JtQ3&+$UnaFptz{rM-K}hdPNBs{I`%{YK7hipDx>QarpU5PDrO;r=|+pcdW#On zBO=5Qazhmel%$>X0@<)}njv@9>Wqdk5H@DPl8ixai~wBS+<{3L2)TbqkqAo?mKx23 zu?+O00Sof1#A-ev9T`8CpuG!}41b}lFxX~%fH48{?%=c*colxvyyCJ9AH|x({e<+3 z5AKcN1xxYv7#OL~sZUE)MTjxs7!gZloV8Uu)$@BIOmHAJZWOB{E|f||TNW`q%!{0H zP3Z~dc1>}v*@{1_aU)w2*UfS-KP2o6-oTXXJfdd^)~f`Pom;3=51LYh|)iT=>1sQ_wki5XGc3 z7$1obeh%K#vX!nd)k?T=ucjZ)B&7387vKBo<;kg@+IpdC$Y!X*h@Npp5l@^;x{2DX z2|H-*@!}k4W_92SmDhYU4!;8qZJ59$d`pZYYYC*Zt1vHe?l?yQ8GweUOLWig6&lTw zAT{~LTzb(Vwvwgz;8D@bbjJ}v#2RN;(W9WwYQuNcaSve=FE<&+SY*p);($b#%pC8K zt=I~+4vQ>?Lj#wvj;mjsE>o*wT_Erh&E_`(xNIfoO|Mg2$JHX+T#rUETaiN^-nR@| za%&+S$ji{Muq1i@2~7}vk`<3(QqO=AOnw<40!4GzjJ)EypwkSb{u6QXl4{QSwm=8j zo$NWncWf1a8wrDGi*=D-Z8ystsUEQ1)kfRdd7tEqp$VVHYdI1w7E0`PSN+tXxGu~; z0%IBG^F%JXu}%LjCJ@fek+}WPyy@*?6R#oSQL7WZ_?IIL4GX}vWh3_K&@(v}iq_Yl z1eo!k7w%SA-b~T=K*sx?&nH>4!#SJNO4A9NP?FCu7jtIU$6qq*PB$}gM#;~aQ7h?S zHusdeM0U)m`} z4=(!_80a!8I&0|MPxrYel8B9yb6oU(EB=JP{XQ!2Qe>5F-`G(9cbD4f+fmZP^5?&J zOebka2UEj^xdwF|u`Jq*947sXrAwE}MK}|IZ{SI&=hD4*I`QS!r2hH0IPyiPS)nil zUyP}02d9WVFL(>-U88;hgUCRy@s_GTH|at(Tld%?21^8wu_j zp$9fLh1ej86cK}*_ns1f&KrYUu56kPyWV)^o%?hX3OTe1`rU1;B~)jVJH()$R>f41 z0Z2m#^Z-kToTfFlOB!BZ{ZA`{Qs%!}Q{BHm_E2i1lhF(?L&>_sJ9$+j!%K2oZ3-@v zx7&aX$?Ai(T^jtjfk~Dj7q=HA=vc94{5uou-cTr7NtE*w?6bN8Fa*bQzrMrUpkWI zv@^HKw-fYUtwlp+1jlQ%({oxhoUi*^4N9H{#V{)n^g$ZF7PC7dnOREVrf-h+v|WLWkx;v*NQ)P&@im=kN+XTj z{bV>5kqiJMHe3IM&3K<^>_-|t?u_*d)@3CCuh6V6rE7CWJIiEf>f&vYj;-fi7U{R^+YR!E5al) zB4%i+do^xCK{MLEcF)m-o1;GhlY+8r%7veP)HlsyeBV~7ZbXA@2k)LU>lv?XDO=)0 zvir+^XWEZ?!0d^8K;kkLsiI&!ohjX#R9>N+N3N;p191JucBtVXW)X z=$!)iiv^U2vt8XRzbPv5BUT#lA-j2JdrEePwuxJ%L*P``8jaJfGM0Ki#O4^>0Nk_& z5|lBQ#nijc-OQ7B6v>64D100$i%XN%L?X84s3~>lAQ+pQDW=G2~Pk z63`pDh%6q3q?#rGFbR<=al+a*YX%6hF3UPe_fY!FrG7=Ah|0zo&KxxWzpN47YNOEK z!XZgH1_}w(Zmb3O5h3}V$@~QnFz+Emi}_%0~P5PA}}NZq(y&*p4FfFENUnUNGQH|V zVI1ckPV%4DJWA<$OIW-h3c%2gogBm;$2zCEpVRbBsXSg{Pu;3JUzb#O32LBU}oDkjW<_kT{wOE4Fv!UI6znx zX8ea-$HKr z1Fib>G(Eei?8hx2d*?>um*F*Gn;LL$&{Q)(Dh@Dp3lv;9xNUoscLPy>Wb$@a-dZph zzE}8Wz@}^pKahr)z}0w-C&z!$ ziR0B(g8N;Vv&oQ}qG`L3Hl;8wJv^4`h?q*(9LLLqMeJ68wqjyci{WUVMh{*OCpPU# z90rQiN;R%T_QM6fCdSWlustQPE$pVl3i@2F!3+EELXuT30(Sn+4v{G{uU5X&)-yIe z<9y{DAPS8#zSuD0MB}i_p8h^Mu$ru21G2;F#-j;DiY{b}vgG{qZ;akR16j7g!Gn+9IB?Fd0b~Jo$sl?rPS{6qFCrZhx4r z_%#SYO&sWFv0JD=ANweH%Q^G1H{?<{=hN=Gu265cZX?Z9vXmY%;yO8nkDT|~*lXm( zj9-SWqC$-ow5RdUdm;aKN_MnMx|WsUJV@qq?*xq8{`9MnxjRhvE5FSc1*|bn4d|h2 zl3S8N=OVc3KyMo}U5ovGUV4%2j>AHUr>Cq$HUcMmJz{#zj%$bD%1!g%J@;k^g!~W) zV;~1u;kMj^nS!QaY_Mr?N}C|9JotEv0;kRM^7%f%YPWgWXEK?_!-hQI5>~>|+93W) z?&hQC;2J#PaQ;Dw$Ck}|_~fh0<1Xf4-Mw$`>y)Vo_M;E(!_FZnIoX#eYHQuN>xd-^ zlahRXBmEC`QH8k(D7HZO$uFk8>E(^nO5doyF+~RjVu}V_Tcsdzx5DPUCrR~101Qfb zXL<7Bl~X*m9#*9NC`(E+&o^uwp9G)^M6J1&Z0Gb4Z4zHYbg9zS8lK(GtLq6a^7J3R z9lu(s5xBcE)-&ks*~Sx>BDhT)d8-rnA{))RTi(-|ZW__Tf689heycj@bk4sM{JMSW z!X%XBBK6t*|Rp`O5N_Yt5zZ%FFCmS$9VSEk}lg zPlo~p_5KPOEY-Rk=qyo{8Pz4GiavT4!ekHp{nvMczz58MAW9WudEPacpxi`!=J6MQ zUP2J{P}M7w(h~w{jG(}Ga$*3}ildA~u3LT?RVCEkyxJZyA_!&0=V>|)mXlgxyV%z_ z5S{N@Ui!_IZbep>vD3SrURpuF^z=1stfJS;fb&`@{mx5Z?bwMeREF1td4tXO$^GWQ zFZ`=5yV9oBp69IW`JYJVI}xQZU^u3diR!70*h>>brsXgYm8+KKbkPuDNYP_n0F5hS z6=Qs$RYoxXYs877IFHa_(9}2TFP|f36T%y0`g|(Ol=Z2*bFVTh;~r zkgQjD_U0J8wye)sf(JZFr~8SHFniAo_RS0*0k7h2-|>2B=U{8Zf_vC;6PP!W{OIjK zo8@G9pJt76Mqj#-<=^LcP%wK-{~5kWB0ujI|&&v&OZv5d!@AiOI1mzPt#zB)J`xjSgX@~u0y2r z;m^Hzx{%vJLV4p(Dv!lLLYPhi{RIplbbJLPyk&gg(D~CBzIyQ5%@8^A`~|fqKcYN6 zK_-&u`%U7pvLZn_v|1;TtSW;)gHXTSZ^zQ-v%8fEI&^ND23>2}Sp+^zMo!Y-FFKVH%|87LL9^oYr1*0Od!OoaQZuF-dy;(xq=zlOz1ckH|= zPL1!;GD?=*o>;{uoh(|)a7mTghewS} zqj~=f<<;&<&sRMRw;NJ%yEjS=yE;W<-l9%xxS>NW5yz@^^ui4R!OdlGS!|tUsps{%WW>o&Iw0~Nh_ws&t9f` ze19yJW@%jRdg@*8YODw^hNSj<{ROT*DkL_E*zF-)XPaJSy$wqaeId=#1meBOKZ@DN zZUf-${fIaV55peS%~e!>5!u2HhnwG}@T0bWR+Z@Q9Geyl8b&EX!6?uUqP@b2iQh-GxCse{9DaKFlCPH>}DV z!u9CLVF>A)heqZ2UN*{DOC+>X1SH?AgBx|H5WbwTBCztd8_mql4=+!OQ~K-oO}EZA z*gA|b9*9jL-`J*o;*;&%*<19l{LWQylN}3tvluE{_C$jm#2SR%ML~4ic3ayhs@KR8b5M{P6 zsrqpa;SHfbvdLsY9O_>4p`3o$m^a!$^MOfKccYtSa2t*>+#Ht>sd?0lAMTpoSziEm zTc&cEiEAV+dLD@nXPVNQi_S$}ZaXAiI*FA1bCz3ddZ({{f!R-V&1m?jA^rsUHJ^tQ z{cObYjAtu>+iC(KIJU@^6LzzJ{Uahm;;J*@y1C$Fc)gIm%n!_yH538Fj%FXAZ$wRy z8D=q{fNDVQ={}B&+wo-?R37p67-@6q_&Wj|l7P}77`*b(NT`obz!`pmhC!|jbnp)%HenXvg?qU-lpxnD%VLFHy_tSJOx&oipR(mq)l(&q(? zNO7vN2wZy(aWt31G ztaKcUaF-uz(S0UT32H+@@4OybW}7Me5HE%z!oD;am&R$9qAIp0vSv%fj-OYjcSdVe zJHT(xy9`}(ISi$HSwGo__4#1dS8!98cI|Sr$ZaVhvMzdH*kpLU?C9x9^(*`yCyz|% zQmI{jumWMIG?zc;m6bB&f6|z_t!apIJ@-@DGz&1tHD^#j!_S)&(=XV+z>WUZqs*Y{ zLL@yCBPEvnxbn&Cg^CJad(1GGp7o=2&4EhL(VKvP9P;SZzbU|0ucV2vg*t=4KV(OW zxGW@zTlO)kX(FSOm78$hLWLR6Pys!0VRpR&l07mN&uOQ&K>E{C^&>4YvHBhtU&_(% z)@y{9x|yX*q$FCLBkh(Ji!EO~J_iOK+*4UTB)7|e{RtX>BNC?VeAI)C-zF80p)nO_ ze}A@(V|!E$8H(1l%aHCYR0xLGm95G0aB2~Be;#^?Wi->Yv(W0tqHOK<@rvGLg_9@M z*QL;N>Ex`Ax&pVO##$K&@7kq_r`7LSf^egYiwfcn;V#J+fhwL3yOx5#Kr|sT+eZ|( z97q!a1bz<0K~FK=TEWXrZi;ktbXCpJS$4xF9{Yuw;wA=?=gZFU;Nk{-`Vz9+4`f2M ziiQef*jrrX#;u(8dhNXS%PpeED-t<$nQ7xbB+o^EzQQA?tASoUfPw054@Bafq_5Pj zMIGL<-X~brFt9Ofc3|Mq!lQPFYW@&H(!to`J z&AKk#+Nv#UD8uA)QkUF>@`O}{3|O6hUPdSV0tD2lM2E&rp<&(mN_p_BPnz(lqGY%% z?j%a$yJOQ`i&h8Mt*;@!B@H(H(WbGP zhNoeLKU_Eo5g6rDPI=5hoJM8|^EVGCx^7;#57!~Ji+@+|Rzb4&9^cwjLIiwd=9ekv zeZ1K%7`j)wUBrm9GCm0&wU&#sL3lty zrw=t$J4wfb3kI8FFMqBjj(=C;ZW1|&u1t!dIsz)+!hvt30_7rTHOJMC^^2erM%Jd> zJ+;yq@5sfnUcM2dj^Ml)!JB)bNaGfhP;yfm^9-^gru{CM*%wI2U;$3z=yjm%O?|zJ zO_a8NW-8@ZZ*7*Au@E5}Wm?Lk3{;oT1|X#?ysKDqaibKHQCYs0TmGT^TUg1XEvOfl zjrG5a1m(?L*MAxU=aUi>Gq1{t4`oV6x7gt5?K>#eLwAe^xniltGSi>Sm_JqF4YfOGeM>;A5(|+4!6Uc4L&gOJYBO}G!+^Btdn}&J0w%2Fu`uia`7hD!G8B5; z|81G>_J#ofvdmU|Q3iozkVR}{)ql5VW>)+d4MUu6utY$*l8;|~!7Ew|He1yv0wKz= z_C>~TRunr0YdVIDc+mYfZ|E5Vi{4*0z_5byP<;Q>iPsr2(;1Q^b zOMN7%jP(o0iZ%G z6*Dn504OR>Z$0(@<}CD&QI z@jr{LCqK=97MzYc)uTRJpb5n=8FTTE&??qdO>@0+gufNiI2>B4kh+b&n8&U=uwQ5i zv(+nnI~=}2Zsal|pQ(9^4qMEVHSn{1^1aby!=jJ47~TD!Z$e+th#0fXWcOo4f`j-N zNgfNnoetcFz_HIqY+G~>PmbpyHVzXd;N8|Kd!`W5?DAMUKNRR66IC^<`}L|A^fvR` zM~e@5^jyf(Ocu6p&y&Rs$4TDQk5)WVaZ;qP(~IPs3@Qy8=eHUM4!f(<(Q?`S@kcc{pFPvd}X*0cCHkm@4`WK!}!z^Ck+u-nnso~S? z!&mFsg|8ngEwwnc&GgfQ*H^3klBRNc*X~wY+=RtGr@A|zWJW2fb!Xate81B+<-g_B zekj7To zG`^W+54}0<4+LEY1UB$L>u_zodua9$YH(0qXtA;>nX8A(YxR0|&{*ZpYfnQ|nM&}V z{V42fLSg8WN?Kdj}vc=z(m2s5M3 zAM-5&-K<9Uy?uyg!n|;}wzGaFOg4**EanNhCvS3hUfBnzUX`dYEu6fg{s+H6K)>A zqE`4HN7J4ytJ9_hQ^UwE-?iy@CnUzyIjK{>(P_kMK9brN_rd{h8j=2e81idpKa$o= zzmF+FWG$k?%r5TRs&h}A_Y2d23vNm+027=rI$`TxdMs_2_f*=wc0o4h>Zu21Cls~m zl*Yg1?^Bln6VvWZOViAseLn5qxgp-|q#bjXeQ19e{cnvd`<-`V>e6>qYSFes$V2u< z#ok@(dX7J|~`^Qrm8&IJo_oPc75dkndI^`mfCCRu?!v23&kg>O0{zfHNIp zY&HV`6YP57N1sXCm(NMfTeYohzRtD)z{u-9mikY615Wn-)V!rY0?y~grD^W{-%Ps! zO}xh|JG28*YEGNlcJ0sD8klyhemRwGS(S~elib{K)v8l>^y!sp;6-muW!qM#mwxqc z>A;@N!CX42J#muzo|PXVBTOEq$~o!0OU9>*ubiCvl=e=oTD3^!7Lgg2}9LG?wh+Iv(xX(zg?5ixRTI1@Z zO>6XrjwywumaP7Mr?_FhZ4J5R6t`^D$F$>^^CtHS$KNA+uRqwLmY0(aJKeIv0F3vl ze&5h5C)OiX^vPUb+di*Rubl29-ktkL`x-d5s=w3eZr53Mzl?I~ICc={4#d^O{>5Z5;fiv4t)9UZRrS+{p03#%&DwDYtPXG%_q#A#+J@ImUS034%uid_ympCpt4;j|gE*St_2cMS)Tyjh52!o=T z5pSHM@;zH|eA)&JL%?9pJzph)`e+Sjsm60o@Jk*L7<=QV0+bODm~;16qVJjk6hyj4 zee{d{pVLPtzUCMX+kw<|(4^G={2NmzqVOvKGL}8{BOJ?CxjxCuuU3O=^tb(2H^Ax` zlugmO|CrQg{A*H2p0VJO|G{~CDPxFu-3fG`W3f$f@6>JBg=x@5Z%OOtKa-aH?ngx6 zi2~>Ps8*}8aqnjwC++7-gDLlZAur}zt@bz;?9W!6dZeLOyep#KI=O;$f+pbr19+KE zumc9of`|U279dbH24h^=u6mC5n8T-d7eOfPRebLlBj7 zAp0%*nj0T6MouCtK5q_7Ll#UE#(Lj#U!Qsmzc}XK^q>BH+P(rnfN@`S@V@+C)V??X zEZ5)R*M2A!_Z^*fu3MPqJ^1ec0!vN|2;}-9?&lml!ML*j9p5rXdXBy#^%!wUT0Zp` z0azX`2QczD!L^R7BJ^k1L6g(qOKwJ=u1haJ@Xd5+AJ=JH)peci^2PX`&8ND@d-mX} zKF{}I?QxZzcl_7MLWSK2G&cJQE#a#A~*HBFm0 zY)j8R{z7`>zNbk+Ym%i8H26u`1qDE$k%BwfWu>L1C;K=$^be9Uke{r4uRQXT_5?~j ze_kj<7G&v&&7dAhagv&*auztp&<#xKadMcY^e>;nxU^G?x*HO@M% zzr?u8Dbq9c9G>BS^v65p$y%%hFcEm^z)~ z?3IkIT*M^CRzr2$Y3jOH>oyuag1zxQ_fUteYgz#isOkj`*LFDNG6M!)@aAMxfAiw! z(wwn($804eU;-`L`*35o5 z%j4y9*WA3kT}PsB0FKSjtKJ)tGuP+EPyRScx2mfWZBAV5Jeq+%!_i zvkzie3tTj9p4ANS=OUbnu{V7>94aG)(|_{WaHM4p=uAb81D=u1?J5~)H<){@258Z` zBN57?csGF%r>->mELc!=4Gp7BneE_Tm4(sLqISihI}bxEK8h39#1sqI5uUFeq3QAb z7SO_d=3zjSBS&}-u8q9+c*Hs36b(a02g#w{j^njsCC)8tf(}#bj@@8b^hj%G{xBaSVfkwwdM_vf;sq}(9rUssBZKK+ z`b>WSw$?gpyW6QP3`*=8p?N`%vyjJ_w@!kZsjy7%e!*iW4 z9=?kV9p!C$jeTfJfb}J~E6t}i2;j1)9rs+TXhdKZOTkf2*UI6!_?^mHJQ(W!o52{^Ol|md|P4wsSg+-*VVKr#-$)Wt-wEuCtG;rF|=l z=FLgvK@NV_*yF(d1F5*AIDO<(?@S}d4NW_@?@muVI5lnFxHa_~*gIWw{bi|jo7U;6 zN1jV}eCOxsPyhusuWGI|umxHvHgd%cM@7uN(MDIzI%8R+hjn{VYGZ)hk7dPfJ`rL8jf~k?=cq!jWtCcHGHTe^AaA)iKws+mQ2u`nuw|dl-)+J9ej+XDmnyUR;t|wP}UXghA4HJE*};J{uVV z8mc|VT$Ki0@;2B3{nLu)?@i05-jxnAKAh)0Momc*h`Ki;g<$2h`_h8neuwv#o?RS{ zi$dthIXy>To{AWoI`^Ak5=ik?r%U^FoT@{Nn1#d1JQ>Iu=~``cdgb(ASL*$PP@yd( z76l2J@75yF0nzAf-MJUncV*ljiCp1w*a|U@b$Gd_j=z9FasP2RxvSEA90SL9E9mM1 z^E&uatq*hmIC6SFbPBG!g+TXToY0Rr~=<3=Yhb#7mW8pJ&ytFyY5pUhOci08e+AH>Lr(NW{(-+!6Qr`QW z_eSW@uTPtoOi!y`xHoMka-BI=I`geK$9LMtJ#ZS(K|1D9hXE(EoHPk_SLkbGXpX#k z!#=QID|jcJ?K~i`A00aXk^iQh2Z@&V!5P^Z4v%#s?7vvQ@@u4a6Oro{ZQ3KJ_OKO7 zVm-Cy!+||p_{TLCf@9qfSS_-@m}6aVs(Ry4wJ+(P*1q^yTE$pug2QJUbwsu8)Kvl= zUgy2F1^w5AcXAz-Y2rJ__@KX)X?AW~-mfFffMG;&FX9;k(u(Kqj(Qa4p?jWk)*+3< zbp%~%j(3ZwU6DD~8F-NgLuv&;9E&)%0y!;X?01cR*tdOc$Vy=6&;iDkFYAG7X~lSz z1!15=*QX`2at>Jg!LcY9b{K~gLnym|{&CLfq&iM6_`o+)XXwjZBtqa>i z5X|RTGsBu4O#mhYp{eA?xax^sYY{+_P0?zvy3<3L_bCjv= zQg@lU;yYQB!FD+YUAJXs*jJ7X?L+|_Q%XvPOitYfotxHD)4(}-uzXMWN9q&hru^&^ zWvl(C{`3B}&-aog<2VSL+J@&3ui?BR(h~F?Y@2;zs*^H}HmMJpPs-LgtPX8~u2Z+1 z!|%=cxefY6`^0gsPN;lVZrrhfU?oG&JT#>dc zem-rS_jD9D$`pyymV@h-w#RygcFf>+Rsi@m=e?gSp z>z78ZUE~AWCntEHFoZB1x(~kuFzL-G_wH%NonNFF*8*geGwf=#Dfdf__dfoe>$)WV z7T57p?e@^drXbYC116;5SHB+$ACG`@5IMU8#>O^D(C`k^h(JG?>FaP=**)_De?!&PagDZRA+WnEgh;#f; zXQ)H35k$a7Q84Yfv-wn#aGBmpf03C`zW&Hu%z8(*YchS-<>BfSm#Yb@rVX zopA)@Hofn;+KjxzxZQ8X?BgPI%Q(k*f>NlWw^7q3B$-muImS+C`r8M>N zX=&p+3@50LjWtRd)8exa5HKpZKb4Z>I{fMnFqfOBg;1@R0|;b}%>Go25j^U;za+{v zD6O9L+w{^s{~TkgKe_GZJ8S%UU7ii4PIo}s7khDF*1h;BbM$_koC9glly{~P*L;w^ zz(GN0XgoX4^2V;$u6yb6tcCz%+x1vI+K1fYPOPWq7iZ%&i{@=xF*_}K;`;#88^Uqb zQ4tFs|v}ezTCB9X(SEscj09)UQuj5%mc*n;gzqm7h^IGL0&|x6L>vbAib?BZ3A+N6J z)}nTuFu-|t4uJ|Iz)PS0N!muLg-(6vencdRkd_b_S%U*&VKocg2`omNl^y?-vFn=7 zZLe{!Nxf;mp#2P@{kB)&!1wmK{U*LX9EgRFelP5(qV}EBm^XeB0D3a_urfGK0gj~o zZa)Z6Y+m|8TKc;?(D&thmPH(uXHU{Y`cJ+g9KF!H&UMI{kk%>q5qq=fmLAip0@2;zX(>$@6#s6qinLOC_WArQE%tfdGGmpjAi>_ z{)68J5Lh2Tlxw55W+&JLBVYGX#=I7GXS3Z9q{hiroj$iw+Wyh|t zb8g1LofPlkdgc682EL16&4!mB=hd5~ftNCNh>nMY>v^Hq&*6C)i^I0~zKehN!?f(_ zpE7=mNWZu!^&};z3-)!eMVvRz9{R(%x*1!1H6WKoN3&f5qUrPvPA~Twhz;MTzJP$^ zpKGigQUcqhEn6KT3UI1vck~a{1AEXV_Y2w0IU0m%ObU+1HhEJ&i>d;TGV3ZQU$=)(aLpK zeR59JZW(s(IJ<5`J8o3#i<4D^c03UkX+qm6Kr-j$=naHvs_<|4vl< z9fI*Lh^4V$u_g~A8WoIX4JwiH)kOBBy0RLb_NLTzL!WEJXvh`sMaGv#lziHcJ`Iw- zEf(#%u4(As!q8@13WiBt^f|uwv>$&e?Zt36a!~uwNY@~14wy3G=Ff%mvW@&zjX0}T zYf!wRgE64tsS_gT*?a7jY3WlxA=36J^wXW$t#i7q_H)#AzKa!{`=9^Da6slg_??J+ zs%P^$vG#R;jK3cxLgq2$x(m}KSDl~wlFN9Yydv!@D<^n%Bz5UZ^={sI@q*>)2j99g zZQZovv{XH=udL2SK){IW;LC8-ul-O&Ul%;`T_V!I3J1V7K+t?BI;|ILFa7Ep z=*+$GcOz!%PKyy*a7*V-C*3jcnp{q_SkTJCck0Hju%EgQzbFi6spHlw(8<$?H@fBA z+p%VT6a+K6*|bHQ)Nk?|Qt9M3#`xc{ZV>?6N}kgq7%xV!1uu-8y2c6!j3F<+7>C+r zTc>3=>_VL*(;1BRZCmwXTJq$N(mv+0*9iO#zWiOmaIj{=PKuEoAd2bVyD(>rcstLQ zKKeaS1Id^~2lvB4 zm(HzoF!g&M3ozN}t)Ry6*Zf(q77t?wz4+^YP3z}82Dpf<-uO4M7Akk0s$Ha6=!6vW z-m)0>(3WM--WBW(oeS57Ug)1b*l8UAWVd2t$%Hxz4Owct5$Cvuv=NyF0^>S|MSvXc zUg0%GurPM>?)I~5iyft2UC;X)b#+__%4&0Xk1~K2dJ+J5aEurAnNHaHmmZDCY#V|| zG6R&OsTA$H_K#<5U-c4WDqDATST`?vA(>ub8bs(s94SF%o$B^n+lFYqwFg!KFfV@M zcAlLT70j#1F4S~T_jV^jZq#-U3>2fof;QSij$s|XGGu7fS;za_w|@n|;fl16bTe5E z`v8{xu9In$e+!_-+y}muDu^%#u#!_Gu5$qhy!&f8Kww%12vFA}zm^C*bf#9u_&0qP z*>}UfI1&M{9WZGfPuic#cg^gF(kj;J3cwoK60-mLp8JN>iy)Ye=a%KO!#)YtiEIPr z@Ol6)`=crEP>fyOsqcsYU#$PomZE}E?R9XiY2h^pM!0JcvHZ2Wl7hk5>p$rW5k^qb>nvTr1-Y~R!jk%mY%={jix5d=MP(L{S zmr!qG2Rb10V-BQIZ}_Y5liX3kIpa8Y-gYS+8#-_oDKGPW^DT7mqR`LERu+Ijz$ZTO zi8N#g?E(NOD=SO4-F91=I(2Gl*RGwXHTbZ8fS~*NmrqDnzV4E=X~PyA{@-R^uS$@qz!AgG0^!iJV0H(s zl_q3`)zv7mEsJsdG4!Q^m6D&>ouV(&l$SpJv&eA_)Q$;wn8_~6IM6Dkp#05Rwju)d zRh0irVPJ@UyC4U$j#zx2*Qm(GzxlJ=_u@cs=RfqHv5000E@Kc>Uc&^A{b5-hq(C)? zF6ZPgN6D&eR1BV56A&22LOwgq{ORYy=njgHR35h-0bR_H)2e>5UEYfu1tmyIpU8aB z+A(fw<{0L#LlGavQP4=y&{Zjk2)g*H^jv%nLu2!uBK3iD%`x(PBdxM9M5CqB8EuVc z7zyAohs;7MBVY3&`e6q&(5XZvrv|0X1y-ZQt$KE`0J*J{3z`Zp%bUY!3YnfD+6hx*`ndSIDB886@AZhq;5+0lnQzX zBhPDu(%nK67!<2$afa ze;8TyT%GuMAY#kkk z7=tk$d=l-7$dq}GQsJS@VUX*5M<4P|agFWD^`Y&tFNR<9p`aT}<$vyf|2hW6gR332r&5R2Wg@9i}`{rDU75+Z+`3n`rLL`pNG|R89QMl2pE~mxEQCV zdM=~y?7ZaVl>)bMOp-InKRZUMWJKKfRK4ZrwU2oBm^&FA+CDjmb7WsR7jLt6!6U=AlD^tv1)13*;S3>4f_FN{+*a9EV5K`~T|J zbj5WSr;73e>Fystm|mK`Ahqk*F1_m`Z%#u-4oquStV`ed+7Hv}WiY^azW-j0FwAfpwg#XFB#CmIe_eEWw%Iit{j^lmThKp*Li`F^(+)W{$1V>G==; zS472)-X5ioO`&0s#CfjM(!`C}4Y}eyM6It&dtluxd-hHM{8^cfMbF4UaxAyT03Ueq z%`o_`4Cl$J`rC*u${_1pIxcj)DQnWNUF%x11_%gr1IX53-$KNFBT;$_^7UdZ>rSDv z!{{Q5+HIQuG z(D&Ter5@NN&YK;uxy)HNf-R6L-PmEy{+Fhcyo4?mT5 z^Bmi$o)ge1#mPQIuw&i>-zNI|1iCf@1Y~2XBW?c%*m-5>xRSx=(J(cDfcQpUCfLM+x)vR}vjw z1|y=0kyk*x(9?_wzgyr>u*J1(9}ci-8%@y*ohTTmlW7!q8@AmV*nL}Jjk@kengKwI z%!)qaug;1JKKcXXWuZ!F)#xGD?y#>aCpz<9{m+;bY>=7S2cUHwGFbBD9XUY2Ty69u z`eFEM{~RFXT7P6Gf~T=TpT`;7osBETfcBbT!g^%8M@NkNj=%Zy=;~`TP)VveHm!_5 ztIl@=V9=qSdFO4cD=R~X($Hv~?L0LgurG=z%JNX|-plc~fgL&ov$WkxNQK?Wt^}*5 zJ&?BY*+CrhVrqhndE=)5S4xT0Pft?+_X{-8e!&$Pu4S87@D2;JwUo8fxu}cw3GBs$Jj9dA=?~mLi9mr#=F3btXm!L0NxloM(1U!wJGkI19cvcahi`}pD94V zwMjdv8#+vSzV(3i@Qw&QK%pK+^haF+qhbT;OAn+iump6p1xf5j0Ve?z!OZ2qzZ+om zY4pu*R#})5j9CH48V75n;HWH=ZbL3$&Av9CHj@MEFs3dHkD&>*p=^z=L*tpod0avzk5^aj}DN%qpdva7hi#0 zFrzY{BtxKo|NiMiANo)lHf&gG+qNx?xn1e&U;lcVHf>t`UgI6=`O6`gcdn_IUVVPL z;PQ!S;k;$(`6p+ly=D8-4Y$Ht>fbZXeqnAJHk$2ITNR}RFD*{Ly#0aX&I3jK-k75R z2sB1&r?{rHwDhEBXt2H-41vs1YLmsFb-3}!vwQ<7& z(-9~l#D6M87u_sJSE_DFME<4cI6*}|ozw@QxQXcR0TtGG(wPx)lp)Z*WDw}ys-Rz~ zpmp9vmPPaS^7nm2Q4ny>7$xrt1>&{s+1kY%p#TJM-p%jxd<*_m<~}MUCVfk&hiyc} zX;&HVs1fIaD%$OWsw27^YMSq^!KBk}B*&aF^N_8zpp4CdDo3GMt0D5FS;$*MU+TkR zR(k#opuaO%#4)0vA%zpns;IMVL?-Vh{X7O9Rd}-AVqs}v0PDYYnccw zV=Mpxs!a=2=xplbwe8j)qi}yLq|&vGC}@b~Ss~uTXL!FX@2XSCK=~_Q5!N!^#b~yM znMGmD%Q7mWqE*HkzpG~cCKS4D)R5TV@T(J}O$GDLP`0GtPcvYT8Tl^=Oqw%DJuQBVwudJL~=5TfyI4R`m;-zEgqOT$4HI8#Z4i{|= zCl^T_br*OI>7E!#=e_fvqAlhZFM0e2w43p&aUUR1R%N^$edgga+?GhDjFBUqN%P^H zBaZ*-kq{$F_M!W1Ysi{E7oZD$W1i(6C~+G5F3d)_qp#V1%Z0r?TUZ^UD)}lFaHE_W zp1#xe^0?rlZwT_N$a=aLcbNmI;kAor;%04`R({6t_KH3!bjR=Qxt0NR; z_1sn*C?f!e02#erLw;wjXpzs+fODR=bv~kh1Z9+uI?jlkzcYDhc{a8j$F|Li%7Q_T zs|*m>Nra0rSssJ;002M$NklPY_^lyt7FHWmg0k||06v(ev?Q#6y_m{V%i5HAX%NDIl|M|7s z(~@~B(};0H(g#2B_B4FVU@9JOP51uvx6~7upSEpg`!1>=zZ%Ec3kbYB7y{CHrT(r1 zkasM&ra2x4UUVzQ@cB56^V6b7rRc8>U`;)s-t2$=n_~Mw=kQD9I=;fAzHc!tu6V(Fj0qf#3D>o`KQz6ZGN6 z0Jf~3&>yhl9LC4$84uzxKM`yM^_GA@KXUv_pce1jz7c@#jwraOuF9)x8)p8t)%C}` z{x5OJNpWJ$F>0$5Bsi%vIvj^xU9bW0;>CNv7J!IMGq+{*`7*|I+I?4Lqm#92`ft+q zRdZrqD!0Z00s%&#`)A+%&jC1~B;pxHAqP-TMcYW`-bO%-3`F>3I34En&;0q9vtR(W zK-M3uAF7jFpG3zf1ICf8yg`?~Euy6YK#LyzpIm?E*0%h~ez#wB#L>x7uK=CzJG!Ny zj!>SpVJb=#f98C3pg@8kPA4M1bAR*gNGouSh_+R~f3=_0_2!7{KpS{+3{(LEq#Y=C z#`%P|em+wryLD3Y90l zxB(yP02!ei_vXI~>Ws$cth>IDwy%5{g_%Vuq>v51>}?p)B`Es;2pV?tR;{7JeFTMj z4U2h}-&Xlpl$pv^!^6eX0y9PmTr|es^qJVZR0la0p8Q2z<07qLZj@jn$Xgi>iHfk7 z`GqL(jyTgg@hUE_ZGm$okYMFeohku@);MYc0#d64Fg%Qkm|LX+k>gIc@2&~}_`6_iTNdlo|(>yN`OtHRt%mAnxR z7Zi=AeY8o$SOZTdNyl>tz=~8)i|HtP9eW)>X>Cg}hBoT-<8*d_=9E{08yEgQXk>62;vT2^7#c+n24+S9L5fOTB z7||#CLL<+@HS-_(uK-?bm*dh%MOUb7L#}uyQ6cjTt*|TYo=7XH2h#TzJ@!9PRTl*6 zJ?agA9aKaeRpnZF_%rQM&eofl^@}eNb$B5Zd0*b6CknO$Myc}jxhhu2(4H-8B1g-G z!-c#9Q8d9N5oGfVBPyGJNbY$qqE?HRa;tMCaAgFg8-|j(pGLJ5sD_Uq$eeq>5p>(5 zM7kV_ohWUGbi9+$;N#HfTUv>Dl~XjSk;=BzeqT z8Mhf_vUVTZB<4HUy-4I@Lm01}nX^zM$4m(a+CI_gwGRaktSzzu2FJ=M`l*v!6`gK0 zAV42mKSX+RU4Ve&S*N}qhIV%V%r<~c8Doe35L}^;cWqck&b8It9}OoUa;O1H{T{3+ zWS1StASVXLmT6Mve>>O0Il`e21A&NHC#a9UzqzLNw~@Va##lu0@?#6*r+tqhIBFk` zqFjyx^_&&NjaY7lvS{=&`p|x5Yz(B&M>Ds~fp#uy^l8Z3?*}kMjEGq%R8TU{h|)08 z82RW&Kbj^@niSMU=lgfR``vWcU3Z0H;_nST4wK8+u0tDY2MkSbc+1tPYxmA!oZR=b zhr{rA?M+vvG3O3Xor*iAy?geixpNk!Cx83^9%uN$XMj72YO^1AeUpzwNCKTLqI@!yLDg!5WvA$$5^b~H@rq)>d?x*0uaEc zwGM&10SH1E?e&?iC)v89UTzl7)?iZmWK8Yb34jS`Rt|H}$h1IlI5X&P*D`k*7<1#N ziM~$430sxivP@lS#NNo@__usEa`@N1^aRCz@1pJQkZ?t?xdez;6XDeYjSHR&s_}Me24(umcgP$M8IC%sLrFhU?^$<8P|mf? zG_q!-MYLz#77R6QVET{$F5X3_z+!BInt~bDy^#hk@Tvo~d*gE096tzMFW}J^T_t zQ|ZnV1`q^ob$VrFSYWua?;Rkn5jdRPhF%mlob>5s&;BgNk+O1ai$2c`3G{Hr=F<7< zK-~({6k^?`V!b+~H9?GhJ2n%geKK^n)%LxC`rG-fP3rXe0s`87>u_YP@8KHaVZh+LcYQ5> zHqas!ULeI_f&f)7SU1`Lrd9+P&73xkW$Tg|F+VeK&IN`!8}@FK$nDq8v2C#(AZxR% zxH$6joc*$UL=H*HXYH`*+lJ9}DJG z*tw6R15C5U&h7|{#(EF3j+T&8XgvgVwKmUD(h-V^ic(2QNu&n|#Jd)+UAs0?2W03q z<~Ue!D8P1W1xz?^bXr55fNfj0r-|o}NvmMsO?`5Dnm>C{`ryakk%o>Mm|iAj;LiW~ zRh%bdpfN`Q5NM3lPH|0XY3WJNc(nn63AcQnVuF|9z%Pf6#2%-hrWWmRVwtx#fIVW( z|5^0-?Gy$2B{LDa4-1BqPUR)NM#ER7vVw&>qSGjWau#2!wM(gXQE;zXBfn0p{w&n( zyA4QXL`nq=jQo07SVdZ~bVs9?gD-z)?2EdOznSAM-AILRq|(T}MSr3KE=oc`VBAgC z5E#Opj-h0B<7`cjMOJ#D+mKjr%-p;^Hq{j7z#841nvwcB2Q;@adP?5$di%KmBqIMNT<%3IfE**CQQ6!&{?CXWs3>O6fzXfHF0lD=z45F&NEd z^*k#$uf`zRPZX~L28)HAjPM80z~bQ8-ic#w}GhY;~j|@-8A2 z?u*>AWf9KUIcfQl)#=e+Kb2-oeW}s8jHZlazQ~$A znJD0sY5B7P@~$PX4M)&5-SKUzq4(4I^m!wR?01F*vymd6%cuS<*6chWPFpAoBOwY3=+-~$rmbO940H8)G&o^3L8xYWL z((ak@lfMh#);>`Gxh_j>cb%GZ&)0B*9t{vz8ni`SU4vZf1R0(Gt}CwFI=^M;0d=m9 zh==bh+o1+S0LMA{yP7lQxDb5N-jixC3s4|Pz3o^OK(J6-`R?s$J%GRpm<9m|AS-pZ z?aCMeIY0nMTRoL;M>M9^7vI&KZ@12@%@D}gtE5N5d>VV>Cn>B<#ec?}^&|{5#aLvl z487`oL~`F3^)O7CSwqggYu34M`y%T(wKuRCbuwiwI(9nr1Z2DTtpTbmeEbKjl{2tU zsnE|mcqoU400P!?GO|7Q{(sA^$7awjzVQ9ujC-z~{YVz|W}G-j+PN06_8UmjX3D2MfV%c4PxY zJp?AMPJ9WDOkWh8i@aMc8I2bZklr=%t^W|pc^gjmO5V=`G;P@esINvkR5lU!XuFT_b48(?7xR`FSNEpmK8zY*{v)2+cD%LJM&U`^7dlqMb%f z%{!EeYCjHT@pU%|72N`=CR;sNqe`Xke!?zN%IOdwfs3sFjG#-EA9C5d0(jYj(J~8z zQ9~miVK>_DqU0E{ZjRYMm@U#gh*YP5? zOVGf!yV!fLs>4WFlQ5>c4!!_Z#%pkTJHQb5mmEVN0|YdJyJF0`Rg})55$KgK{2JqH zMJzlnzD7BWe6K}L%1Xzr8}gg{_J0hJ!^Ot=qrujZxnw#>XHezUqWt^u{0Vq_bs^eoV&vmgt~ZB>=0%#~$;QC1R;R1f;gcemX&4Ovuy{d?9Mthn><=m zqO7ap7#$CLM|RwLb`e^RgXWx(!YnXpMRwU$=KLE~_Wga%$k%=ZuxKM_rQyuXV^Ryry#|SQ@NG*4z9+92Rj}@Q$eTafhE} zpPN2ly`>@0)Gctfnv^Lk`}YRC?>FfU5rKW-j!&oE)b(*q5^NlP?T2~(n{fKJN0f3S z&SQ1@zu>t0y~oZ3P^rCU7`i|}!2W&dS6{~odLq_U+vxfjI>l(K`Qm`9;TZDHIw>#R z_l>X#BErhM)E5v?|M!5gFpjhj+wLw+%4-knzw5C2eEgd}!}@U$HpQa=0(aE_1cD(z zkf$nTAkPpuar9H2c`87_)Bqhb11G+pEE>}*1q8GohFvG!a1a3!{gYe{WDU;wsV--!YOtzulB3=qhJ zHsdO{9b816lW$itIGjouusJN9d-H9)XO93r44Uj@jzkcGRMPP`{Vj8%ORRlMdH>@8 z0qRG{Hq256>IVq8dxHTGz~mh z4GM9%j@hQTuf^Pqs9CVc%EeNq1P4km)`wm79@=#%6zB?~mK8V!f(s>pBs%LF z>T6gW*RzG9m3=eH_1K7>=tz`pUX8N4BOFw7w({@l`-=t|K^S+#Cy4%41e&~-`xs?b zUPji3UjA;JlD>iR&t%&o5ztmJDXcheQ4|fabD#wam}p=H#Zu>hsPA4JOcBT)Ah1Sr z8VU%wC$%VVmVf#PebbcZ?@9f5Z;btTRq*R! zVOA%|N!hXq18-0R1>Bv9n&8+GUHle(eDLXWQX8hH$Q&=h>iJ!G?qcN~?z4Bm+t&Oi5Ti0`Fiffi*>!(j^uUVa0AT1B%O|#oNiOrh$L-?GieaqE|1r zB#kd!vI+nh><4k1*o|D3<7Nz4C;6i3F`loI^iEuo+a75Ia_FTmZwv!LEhOlsl37+c zn0jb_w`~Hi62IaD;nA{bA=(1#q)`0Q>YzH2f-mMldDd>@44YrhbS?$~%v42#R_(j8 z^oea{fWTe*OJbFOwE5i-30dx<4oGG1oJA+PWlV4cEWUYq(}l}3h;`{FUUQP@bQg~E z%+L}s#)VkKgxs~aYAWfmG1u-ZWP&3pthi(j!{V~4PDnJB$Xg;3lJC9`*F~r_KHOpt zhjnNABkm=uPTRcKyUQHL7yW-GJyTSayi05ze+7^IN|r+ky;K%)PefcrHe&ccJyyG2 zcvs;DZ_T=kWoCO`hRE*l&Qw`xTW2K&0PIs)*n2B|{I!B}PgFMwqd zG)e?zNnKH{C4OjBE}=l+tPVU-PRF4^835;4gd;2YFv0c-_T1P^p{R8$2UAlNcma)- zevu6~L+%A_xTtMIg!F9t6w3$iTskCEmMCe93^6N#r?mj1#_JeN+J9dHpp}d8+=m1e zo^PN)$f@jAfh>~!*ZB8vEyC?DGDXV&9wpC0Vj4%o4)jb=WfyQK?0`+`!`k}7#I=Tk z4^3&DOjo1fRrtP<{Nybp@}%%5(>m&oG+Lx9fIP{MAE>8-Lb$rQ67F#X&v#~4c7IB| z<+{!Y%Ih37TfNy1&bvUz5=8gi@WhP2Dxa$J{Qq>?EVtmgoo68Ne@Y2WlX!Ty`+C-8 zR=WycjnZR}!)5ft?l30Hdb!Hz0SB=7&4>Xq)Iu3`a+p1R|Jr?@oXn&1#_ZVKU=8w& z2;$-*xDF-*AZm z985&p4^6rPSl;VrAWP!qdN>tk9WFKk&7QmiNcD%Juz)|UC-HQqQ1P5axwmoaWUTod znlV>yoP-V-dd@QBLhj3NX#!ERZDD|)t%z6)c*}r9X11U{L%`ejMJ4=sZ{XH;u|d%O zk7~~y7KMU(Nc7^DqxVjsA?K}t-KAw~5eK|L+!W)kInIN@=A`SHw=?Dp3I>$vXd_rD`~?+NteX z0kW`n$di0)XR=Y^%C*TxDJ5DzQVOtksD9sP4kD z2SoezyBv)2NnIRKe!)XHkDWW!w%#IpeVzX(2zBR`xaQu41HkOvAkYjRUeQ~DZsvO7 z&zuU|syPqWTr$6Y_Ao-8^Lyf7{d^#+F%>v^&OM~**K>)aXK~Y^aFnAHE!fd{tQfMO zq`;WT+=7qO&W?D7huE2X)Eakt7)S0DPLw(TrVi|$aE{k7pVqNu$LJD@TL$t)oIM`p zd^rQaz9Ad_s2X)-W6q$ztVLe(D<+CJKtPZK-@UH>xsNWjHWaSWYz>EnLQUzniB&bS zk6Vm>4QYH19NLYyCkaDhFq{kz z)dqru^X&TQNV3p0MVH?E5w9b6x1#xLdYrj-t*deMW9MZd);g5VtVZJ8Yyw~Q!0NfV z7b?xYXR%X!#J<|W(O-kpC>uE;9X%W4JNFqct;N03b#PEs)_8cOX(8^%|VPRmp6rWX$lyoe;sIH&|OYp2+NApWDcOiGy_7X@}8#fy5q=v zmrbR`>rf)g3H1eF%(o>4JOMUww8b%6gz8&V<8OC+-uwjHOynbYPDUP!?-sZv%V@7{)=J|7WTJMQh4Tkdo^E4SM zIJ0Zlv9vG95;AJFTPsyrFr0%U^uBkwDI=)$Z_Pym$9VvhB$NAQSDZ}B40*z@i6ntV z;91$9B&NQ*1YdB{NvVNHcLlaxUXhz%qYa<^1P{Jf{1_MzKpTN5QA(Z7x~suIAf52m zWE2J4R}h&=YQihtO3E&x1mvmd&u?q%M*y&dBeV8?l_Ax3>=_oUqW0f!Eifu7g?1ohqY=S@^Zp`g2YygHNubi}72J z(hP_89)D*Nt zo>~$I3$_Wxz~}ABlX?N()1ucZWKpjreg0}c;3vf-23Q}1+~%mBHqsgF9r@!8CP^(b zIDk_%L2WnFqjhl^l6W`%B>b8>D9*gl+-EGHyK%VKR(w_Wc&ea}s0Mmd#)tdMtU+&! za-^Y=E2Gb{Qh>k+UlCHx*FWzeU64V-!B`Crph8Alwip zem<6CEoX6)ZEdh#I+9%*PSoGQX6pADLN!3CQU0W(S}s#4mUeBnnvUWOrZxN=&u%o( z`cr6<2wVA9gbg6`3{1G>24L z^3_J7t;zWZSrR*ER^`3cMXXqJU_^h&&Igf$!CM2$|eP<-C$mv(5JsrG2?!j+=b_yS z2x+TiFdcM$9LW(ur_JqjSEP&+AWXah4P!e=bv9up5*QS1gPanL0^WgVd`y9XF`Hju zrWc>mkzner85mL)=6^-H$V;k1qLVk2BE;=I!W~fUB3wHxrk8S;Y}w`GiSZA?PYdgQ ze|~2yB2kGHaDdRDGKb&_T`gT{qanv4f-MIb7lS4!Yim4=?fprhd2W0>3lE`vJ5#(l zB?N!w%E2X{AznCt{;lnG$W6SmS*JFSn}E81lbOCGb;4o9t29dXLCzSylU5EGuN6Sw zmhj3tXY=2z4>WH^o(yj={+aPycxS~Q$Kthrw8{%J77Ga;L%z0FWXhy_w5K#wm+jjy@JR8rQ{<9L@>CT&SM5d+$ z_T{ruLA>d}V6Z@vOx*ANRr-6`c6T}KAmQOMYlf5w;dS#(h4e11X9QLdi}o}Pk?jHK zahLF$-K%ZQ-($4_Bb9o2K#n|ISty!ZjXbl38}AkCam5l<0U!V_c}fgE13j-Rr8S(Y zQ8~RPq%gu|$%^XtnzQQlqptv`K%*j;58K2=WQ*>>(#q=QW&s2Etv6n@JEsFlfK|5~6*2?d-M`sjoK9oDVHq)FmS$19Qxz6YE>TwcCS7 zv(%AqWW+u2-k`~vP}AB>N5BTB^rMCNxg*-(3M5KtiJUF_?OJ~e6c=h>y8Cl2zJw(0 zDMzTjqYZ*a*~RVG>vMr?dEPkzJwiLG&7pvOtYw1M0OquVVBvqVo`Til`gPL98EaL2 zQ&Ha(ZQkY3Zxt z8bDn0_#Tqm*rHkb0y{!i@yfLE2lP&Zf;#aVvV z+^x!Tgg2sOr9QW&6nw0ce_?KJ5h%wHv(Gcz+#-Ea&XMbC^F$2{1WG?I_4-k>ATfc! zZp2eA#5e~%?mLYkpQ5ur3TQ?oXt_}h!pNVelxxHhkV!??K*4{xdTfkk@sk`FWuL)u zy0UDgG_>#)FS+BlQ@8_Da1&>rKi|mW*JoWXt>O<>vADIkdyfbZv9PMF81Yq2O!DG* zTKXIT-r#!3Om2LjS-b&|ezp(4>h29#N34pAcrsWybJp~HDqk>Dc7wqDL$~~LozXzp+A5XMB32U7z0n6;&Q|#`Hb4A z)@bq@g>hZkQv1H)?oMO1NrSAAbpNe|i+J{x@G>##6?1;M>#|okPC_KpOT4E^!E?_r^)g;B>^=INygPP@Vq~{=-evG zWV_Vmsskmn!b}WSfY88m1B)R5WZ4U=Z#ctzwmIqYT7FDmxdHj0lEs6!)y=ZvjB#+L zeh`XY-T?rotRZw`GmHOi1cylxhPU?|(c)21d0 z7_6YESdeURVzof8-rem% z71%zF>0win3~iHI%lgR0AAGs(k#y7JL0!l1lv4bH0ps;hH zrcz^h?f4Cvhx+Dw*g1vnj8XPS@Bj_hevsK1)m6px+)$l|L z0Q*UOJ4G%%Yyze9)^RVDZeE{L_qy;=cXKqz&W%;-YmcIWOZ{~ADB8pQ^I4p)HF zlYP9aVZ}tv{%$0Z^6SkRv8+}q1HL#XYn8a_m`E9txV8x> zQ5RQ6(Eblt;GYO%aitdcQa*&pqMJ=j=&KMGa6-+v@d@DHcs&DmnvHWHzxyO^`e@dx zVL-HQ2ybnp?@>E{>}3=H-^|~`rUags-SaD>3vc7o;?O+sn~fHFr;Q#fTV%NKY|77w zQgpN^ECra;ZiON+pPl$e{0Tme!K2nwBnuKMg9g4uEx8nQXP?yjgPiHX#{s(XHgqQnO@TP#ElKJY!&pm+b`2NwE7fcs z9RBR4gxkDJ%si=f0Ce10x|p7O%~0}dI_$&o4gd_`E-J*O)plUgdXb6s<(g@4uf%}{ z)Mu-xbs-OVn?)Jw9jCUfSDRpDLrjBK6t`frJMv6+ik#f)-Q~FluWU|pdeauVN&oC4 zNcd)TEuwj=^mAwOJIRm8PiLCvoo`%bJ>9V6Buy{7_Q1t| zJ3Lmq@+3YYsZoyMo%$Nz6t(~9!7m>NCK#u5e4kiL{`X7IqR;MG;|zJc;+)H)6sc%( zYw43O<{HS_lV~k43JNq@q)hbMuI_t2%x7oy`|==&yJKXyFLVCj8ybibh^L=c?)5K{ zOtPs1xJ|DqNy>7H`jvihEC$uxh1vW_7pDeZdO^0Mn;{969G6G!3wTeh7n3pRv@fW6 zU2e#LR@GbLFr0@gf^L|PBtodaJMnZJoy^8`6~_+Ea>M+A;h52C%c#pOO7nY$IPr+S z?I#skVv5)N=fO{LE!!uR_BF{M>a9f^??Y58vo^|`T3#gSd(XHIIGf9x^W(qsi+$HKnCSY4KuO1U72My{) zA-TogGlm5HnJs##PUKzdRx`x)<@uc7d9C~MEY@EXn+n1Y2oUqWE?jhM<513m2z;gv zPl5d+nLYV9{-WshS=p)iZr|;UXs2(%`wJ*|#4xV*xAn|L+WqaNUaav(9cU)ngER$k zp!NSgD%4H-kB90)7ZZ;={kysy-K&Ws28X(j;)dgusY)vObh@2P7$z;%!%rh!a-&s| z$pdL9;LO3iHL_oSiF#>mQAT3rS8Z%Qk*o6X{61kRxc4*6OiuuTPQZB3J1}jxwEKCP zr7@b(CEs>;mb$|@IcPiDFi($g`pI&Z0H1q5^(aI%c^9i*Ch8SKoh&I%py)P93m%@S z);%#>ou4FGpRqL2GA~!-JGY;bmH%!p#9XhTroFaxpijl8zD~G{HeQm}aZaVaoM;*; zBOOzv33R!yn)G7aBqBLloehLPGd@7e0Kr?5_$>f%`NzyMx>H`yPvkNm2w7*J+0iz_ ziER$Qb}Ht*^`*N92miW>Vg~y%&`Y3M$U_<;CbgoOSEMa}NeMT-S#WZj-z`_)CGoqp zjl$Ak;1)O5N|YkFpJ8p^U=i9AS)`GLMe(OOZC}5?mdjYDmgaVTV-Ezu^c)WP3JMHe zpvIT%dOP{+JrrCd97DeU#EbwO0s6dHUh{Xn;1W70b;;l@&(@eX1a}EEE?;pW`p+&F$PYvsV}0b+*-rT5G*$kGh@p`X&JiuQV~B#Lgc;hM2LK6>q9f#S-s>8<$UyEa z=jf7>;yImfmfgP((D*+xeAkFHmIXxA z@q%eX!MgoA9B#oii_HY`_(0la@0>a9?&;Qiz4VA$Wv+Y_RG=kk*|JbFx6Y!^h`Ga! z)6XG@_PuXe&~h97ReBSr#kd#Ybks(LJ#k!)r~t)-Q3-WTx^H9fK)>0EjMi!cW|!m> zOPrI|7?p5smW*?9iwd4$@i!brzU%@e@Gaa(w5#!lkf6p(@&=y1t~~14hvsRa(#j;C zv@YADE;`c{Wt~7JX3YDRglLs|`#RUZ^2H&J$OsPRhR8ymwoyzULziWEk7twXQ2<|eMnJ#80xKqTr;{S4W48I&v&0Z7$||~XHM+l2 zPGTrRt!W=`sM=<%^0j9~-gN*hPK>F|l>#{$X0cQ!Pa{L&fy%Ib>}*lwHLHtAJhB`B z?r=KGV4wcTHBH+0HAc&ZiplMa*fiUF9wtkDY4s2c9*0+xB2Wimk__;sR`r=RSv|Dt zkg>C8M`2rSByo-ZYM~Gh`TSSa8|$NI4r%&oyYu8^+fYjDbrE?Z^xD zNBxWb^YND+vFLhUgT)+8VpVq@zxP1IsACl7Xq{ONoDGcc!)0aF8WD)G$hl=Iocg?d zGXzU0$A$(O$lCw26_+Eni2`PMV|aKUhCFj=uR`DBfQUFHRk+2fGnRh-?8&%CT^V>z zpfkfO!ge+NTvkp!D-Gm3f@JwmelBk^cbQNwL_rsycZ{{ct*u2XuxNU1_}SVIAQDVF z3kMhk$;GgpFeFHa<_T2v=vYy*d?(e7!ltr;5eJeiYO9dTx$Aihy}keP>_#<{)?^Cn z%Kd(FD1?6-=TZYZ`eZ2-`TW6Na?_Dk(wC)eV7dE};LtUvBMh2?>@yHeL1JII=XHF0 zvE({dgkWTR?Ju#=dqe&)lh>i#1OaAs1fp+PH15#5fE6A zWX3S7t4+le02op%nvTq;dYW^eL~9?d^@L~y2VuyG#}jMZY+kEh23DBu#n%EsvKa9akR=Eg$by;Z^Bjz4q=6%;J;ZlzRfH6OJISemp zO)}89T}D#?{50z0P*6lpNc9l)OO2e|@X#TImvkq8msQWX4Lb{Og0a;9Z`G2jPRM+0 z`^$=u{kFwI*k25pEBIQgr!(sDCjYl%@LUGvkK^2tGc4xc zY|sSbZY$(DF8a~ML4ibwfvnbR>#rrMQXWub8Bb*C2DL1*{`(AMxjIx zmam1}89P!5<1;NVM@*^g&CB9|A;S%IvO)bp^`{@8-N@}kk-ob0Ck&j=Hq2*R<0Z?~ ze~<<92}IdqPM4vL$c<`qASz=Q#)tJoTT-R2oQ@dXQS&@H14+YZu)XvEClV20R>&Rou>=`BxMkAQc{(H)Z0jEiU_tWP=~>4iX>58W z?L*2A@+TH+x^EBfntrkRaN81JB~RAvAxtY3(854l4eA~1TYN}oYKlgP5?j&OVBx$b zsix_sEwfJk48kxOKw0Pu(nsHVUI6$R(Jr4WhK8QIj6!5@YJ?Qgsc>cHIBp7oi(%ru z7-OGSt!Lcznk3u z?GSG-Qr15+xN)R??2H@CPaUPjNt-g!;_zIt@z;gsfo?-@8VSsOb;#E=z^ht)-Jm=~f;Z7-jpi;s+_CSJ`0wM) z`3(DVMm+q`wB6!{S>|d+KcknuSV4``yB54(%yYl>JeXWGs9!Sb<2{w#C4r|R!7}a^Daq%e=D>vV}if(l^f#{|0FkY z$*CDX6$lZ4*rx@b2>o8v^05+S+}!u=ow#Cn{!;nMrZ#$TfT!dU8Of62qX1#l0+Nz5 z2g#T0($yPrMY85a40YQaeD@pI6_Ngk0D`eKVV;jvxbsZe8YhF|Bw%wNV#~N#*Q0kw z*gzA8G4;pzvv}cBxWyWD1J+fuF;}ZxFHFI(Tj*8s+pjb!=}5BwI?LC_6yn$;8LQbs zu1|KR(*wz;EAwz7W16Zo8@3x5`aE7NU^Q~4Ekbe>DI3!seVuTA#lC2z)<-VZ*ylR+ zdO>O?yVf5bK$Ro>=S{{<)au9UukOs^ambMGjWnJqHrP+pM;pG^U7@NN=VkVWGya}W z-?6Z29py6g6s;D_Ztwq>3qVph#V2|8*Ej%tN_OY-+dz9M8zir36IfdzCUGJKd;3s$ zn}i`@y%Av=_r5ZRvhMn8cVPf@?q2|3O*Y9&OQqQUs9pd2{_;^MN+9M|HgbxO>cis6 z`2o0DY3$GB<$3Y%zxI+9xQpKPVK>#uv17HVxr^AxU(%|*JR1|f$$;yiLla`9U^L3C zNAix=A3uIfj9uU!Em_3#b~Aq*uU#t;awA8D9=LEvI&Up*ecdg+jS8;-Yfqkyk_2=A zN|WD~(f2i!+6bX};b5lMmW4Nx3v2nP5MTJhSJ*T82&~&arvNKmG-Pn_V*FKE8zRHo zRyz`_p`S|GXctP%kF)hjXvSC-yL6QcJ7#0Z7jj(U01T!anO$%})p#Gfc)_|(@sLi$k_NQKxtXWFFa~B8 zg|UQ{>c-(|{XJyDPV0SGBNe__q%67}`%iO0fo`;F%xt1{)u%NMX&#+;Trb=JsE$-O z4^zV!6=2wQ+LP#O%;z05V5`35@8Q7D1 zzJcapW42pupjFF-oV$cEbyNGKW0oAzl-%(*dNXo8w)37V$g%u54x=>Cc*2!7q%>6e zOK(sjh|TfF!c8i|`I?qk4vQ0r(exDMBhM<~WZtg-WZ*0pQOyEQ!%rn+*iYmX8kPN6 zh|(tZo!Q@E_WeSTt;{}-I~_t+=%*}KvMK{BPPo?3xqVvZusoQ$w2*Vt`%0f*8bY>)n5&^{2)2A!sF63uF^sd4u`VX?tP=w<~hP>-%35LX1Ip zmYd^u=6>d3I8=YXi(i%UoA-Pfw9?w~y~tQql6biri^aeT=SU1cH@aTAm=sRQ%=S{V zbe<5+k5$x>X;KlgaQIYKz*04;w0c*SQ-p2*ws=OGCuZ8k2np1Jm)g4z$ZF+&^(2OM z-9NneNUwS(ic^Uwa?BNol57j{1?vvWaN^|$ohS7Jv!pPY49PuCTJ1B_9zlBH(O<8lPK?hc9LiNuwq zj)&}X11w_4L-P51vvPLo>hN10+4X`Zy9A~!RNc*{L5T=Ceh-y)i+^Md=Pa#_E8d%e zLoXZ^F@p!jhJT=TAAm0zb5ATf`4M`?T>9JCl$`OF9CAB-diW* zr>;(F55~dPn@3kvx0)hj7h|}$r;m}c3(Yw`m^)yhUl#?qk(Ku49d}3ei0&m`9J+Qk zO*dcOHW&YM#W*3g5Zu&E^)@1w>%F*G?C-)pKC+I^qPeMX|M%R*-_DuhyTY`ey%31U zM6z5k9us;K&Ub!7ZjxY3?Q87D^zd>dx^Gf|;M=G45XsR5fmcSU*_O(F{MgTRhp$l* zKy$}2sAL$nkeE9yWEOZSoz*`?J4CDR%@QXi3?)&M?e7n=I^e;658;GKmZWiiVC;D zj#&SbJpukFY~-r5I3BtpM}{O#zOCpDbOm-e8wSO{!gPf^sc}8(0+`O~SG%?sZ+BLv zCgSBC;k**{h2x-Ve1nYc;FjMId>vr{)8TOS#?#V5UawBV&soVun`(QM=;OOuifxo$ zKSv}NCv9tR5!YXUE15vETmG^gCqf%pT9mgakUmdL*7>vMZ_}_5O3j}Db!Xc@+ngEx zeZQz79yCspR$lIpiv_t94%#gaq%G(TQfaHxgv_452L7_i=#TN^33lY!!MK3w zTM7vZex*QM@>ei*xq~G(Tn6#KcGjY|4Y`~U6_vudtPs1zmW^uR?jh>!*zV+M8;-{< zcL+=;oCL2LZ*o25q(WCJml&@*%}s>e)h=3Ie^~zeqN`gr1h}*he*@EimK|8eU>H5GMQyL5g;ZFP zenolS#T3D4z}Ucr90v}FDlFNE>URp`nD`p>1teQGXq<&fp|J3YI!~iZ@BLyrwy_y` zs)c=azJ)zH(X(|PP49$tC%TF9p`!N!*t=uxX}0ICzqsBrl;7wVYqs)bKl41=b{w=bv#T=N-6qkot5Z#`{Z8qDHTZ0xKHylfF#>XK+I#u z!uEF$(Pk0r1Clgffwt3$=?NN?)+FsJC~!Shor#JB)gp`&3pTdq(E8?VrRMtn%NuW% zH>)1M42Ogg9orxBvQG3(Ho7RoCjA>u{Lr3Eyd9sT-jFig@vT#(uRYV{GTfC_s(#AY zl0QB-?0S=OVi@zYz{VB;G+MQE-IHJVOu66mC=er)vpHth<8Lf+F0gs@aV-fD_-3~m zaXSiLnI08QMr=o;i|paZzxuFf1}iNSKsR&pgu5#Ne9AscbOp*V+3|icp>4HQs_Axl z|2uhq-wsii!)N6><~LfhoT*6?6>)Zix>7ZYIK zhMgwOFFPR-+nW1_@5iR~r)r$dXKHHIzTum#4s^(kSe&Opery}+i>ifb7$i8Lx&q*Y zZdk(%Kg66PqCg98vwm<$bB=7(ooZOf2K0Btd^Y?@& zzliQxndsT{`J1ebX+5JxnX94H*6bih1Bh!B#(B_=tDI4d3p3s9aFNI&JJ|!-ZBB9I zIDEeg-xmFd5)}es3!+XZijPn3#IUv!=Xb8u?Qaib$69=yqyee_l+>|CT_;l7W53GG zHdetDsiyHDFStu!OIwSY*m3kqk9YlqdP;J69q|a1%1J+HVaiNmRoI@CasGCPufWcF zqu=^IYeVnOAZ_`upt2D#CCoDFYGfS~>86mSyQi(6s8a2~r&22u=#VjC z#qh|Hr)9u03&9D(nl_yI)wa`8vrzJCGx7e~XNP^gR^*dtu zxGX5!w<$Pmw@flxD2n4co?%|TgGeyd%Sek=arQw4yuON`KAi#KuCwlEMmt}51yLt? z=#5nebWp-=nWBppm?dnJwgY8H8F??p%~Lq46W&FOx815aL7FoEXqZ$y{hRx=bVw^! z5}Ho5qS%r;#xC;9i;OtiO*F|R+UwU@I}u9I9$;vx_j)kSnTY@{9c8*5_f+Umz|1)2 zMSv$4H?hB+&A`{=%_=yuZ)DjU*z*|zhJNvica<*3(=5HLM+KA{z0YCXY(c{Z}hiu_k1i-Y0NAK zd|kZwH|rj)vG2<{()gGg+T+R?0eJ;Ocb&mu{he5VKyVI$r-Nt#ad~)MGgg7} z^SPnKeqjyI5y|b+AMx`csz}E4))u&yh-*1MS~UEiZz_H*J)yEZ~u&W!Yvhnwd`Te%|l|`~KGdXewiUvV^14gF~xlAYKaos(;fv~TX(vF_tMa0@e)b}XvxZ5dnK z=wjlIwZCE*yLh5BL`M}RH>wJmP0&PIf_o_Cl zHO6+c;)=-nZ9~3erKRKKPrVP62L*`e*#2uuw(ftn`=1e?wlV&X0e9$YYs1Ie>{6)| zL%Ss@H1BH}1HXY4UNOJVWejw$1}g+~i!@&-D0BVy{lA9W3dLLm8bFeS@+JUE?HLI$ zf1Czu2n`!o+$;xF|kX+M`swNzd&Nx>3!sJ7J~qNF@` zdfRW*vrOWuZiEQ+siy1FPuC6Z`Xl*Ag6(o#G7+4^5pSr%j(!})Y?Q;oc-}>jq3U;@ zm>WI5%`rgSRX+wMJN~~D@mB!7hUTKTw*B~pX9FrtcGUmhIjVi@etyLa1U>vIynO$E z_HGy}V(QK%-yl&Ji0PT5mATpdpH?}#|5^!q*o+PSx1&>klm8hb6pD@*BJck*1eD>w zA)?WWF4g}}Ct=M0brK!~$(%$C@lU?Y&GG-V%Khg&oHuLPjQ`JX{jcvJ9yJg+9a>Uk znEd~9Gyg5scsODepbYO=d@udgKyrExw=cPc>6=OO#4`qC^QQ9z`D^=<7zAxe4rh17 zJyw$j&yZ}4(d2&Zgs7B_!{Yz`97rKz$pY0Bo7n$%84>G?k4||K(4FycUF_?9!}y}y z*Jf&VDd@C9pEX|I=dumpr{C;--W{oL`bcsT)vM{YON(gmY`;JsNhk7kjq)#~;k8D* zT8z1D1ngupEwiQT`9KB8HdZ1rd_Qv2-XO0%=m znjc>lbIY)5{M2ia>3?^zvhO$l2p1KuJpWVM*g4&B^6O+-%vyCMyWYL(V*F;?|GrTs za=TPU@$&NIR2}iB=DH%n8yqiPR3kn@^(vDNQaA6(R`|i+Y%y;fFXg>I|9_+Z@57ua zXn=#Z+n~x~1`D-B#xr9oU)$b~ONdU$4}#(S`G{F)l=PsBE$k#ZT63mSv)wy@HpG3B zWxmZ@ccIQ(PDrtL^qvJgplrjLVTu+>VxP0M70 zL%>Npxv>HvrOf(zb&nL{G&sexQmfo{*wR?>lMYR@&eeXQ&E9%A8pTxbsOn#RlbOw1 z+`G=Nbqutsl0HumqkzptzXWX>tV~^>aF^W{64NcNdEI6_}+y;=9SjI z>`qatb^mLMeK?$N5IdTy7CqAIqSXF(2cO-XrGD-Tavn*IjB>xXbczlbdG^(O>GX?b zFq(P0F#khYX5nYs)ZtPO$IAY~y}Q@<$3|S*O3#b!QrN@W()Mt{&Dek6zmFpIuW>g>VmTF)2Lw=2=oTmO<)}~~6yDmJ90z}CZu0XdwWr^A zLTWh--Q{~Z?``Z>J0ePWfViueavx?JqiuV?k=ZT>>AG+y%V@4d=sYzx>RO}hAeQlA zs?xq|sVIQ;H9>pzZSl0jz}kLF*B8;h(Cu1n$HvrDxXhwAMQ3^qk162{a=g(W*; zeB}z`Q+(+gPIQQ{(DYwH?lDc9`9{1>Gk{She@vX$fi(;_eO@`Lh~c6CVhQUPQi5x~RSAb}1cW zNkPc3%N3L1`tVg`J!mZG)&(DP05Zas;x=A>?Ps-VSf#}51+k4OFvXB(Lfp%uc-qaE zi!XaLtBT}KyhA&YtL>lLZjP^2{>NP*-0}aotIj&c+zEJM(AU9pIVxaf*|W8HfWth6QrcUK-V6Nwj=2RrLC>4 zw)7@3n)LBUtyikSW36=EfGkz24+VuB295pZHc2`oesmn(PkHr@D}Q)a$q{K6JMZoC zw^97tC)y8OH=_(5PM(fOGGTX8!NR0kmX7ffPAA9vS~H!z(J$TBn%~8HHL*t#pz02u|kNj?=alSGxLkqsj z=HGPaQ!s5MeJg@1Bzz@&mtSvwcIk{||JebD+|Odx!zw^UdaDgbSO8o6qIIe@-`nes zB!`Yw43#?&&7dw+4qe)) zAnWn*jmr5kmEq*!fPb8hk}qTa*qK$M*|Z4(Y$INuvGI6*z6JaFx^rm8d+ubYAs()1 z-6n?r*lEG_p2#<}SYWvAPW2@}W}T)9wyEE6QR@66yJ@>hc61_Y<^b?J^2SnH4$V$q zKoZ)UQ@xw^Uz7hv4!}#I3Hn$ea<$ez`N7ET(DlQ<*mh8O_n80jHUCR#4iy-0Evu-G z1W+CvEw%W@K2NhtJ*q4+%{ycA(b`G5Ez{K}rNQ>)W)v7W^dmv@<*RPdar@Y&NN1eR zm>(xk8by*zyJ1E9AiWLy{XKM+YS%UFM0{?+ z7xh|&DGS1?40%YL>ad=js@0Cvs%r}+Ozp6pU)SDiASo{XPUFb~1Jl}Q&+J2+ya)VD z{yQ8F5OMK;hr|~t~UCawp-Hc!r5AF!0 z)cmU>4Q4W<4P)=g{VV>DoY*%yS#ULRXsHA*R>_U0aoB1KZzQTuszv=H_jrs=fyE)r zVKR?@O)saHZDz`{e^C6Mfr4#2Q*eMZ@LnHc_u5&M7n~^pYrRw!lg-Qu&30vopE$C8 z`b%cJ6PhHc%gOL<5yjeVpkLeeiehXd*UW~m*q*8)l?ejziQ=P+Uh*uRByTOaH5xtR zyJ#vxJ~)NkSd7}Yx6SZ4oij{|MX|($x^lZUxBe~-rQWG}Jb|!LHhmR(Pqwu zf>@KT3(Nol&7h%5(RWU7uUCv{T3_9z?@%TBU0Q4i&?Y7wZF!#$9T8moQ6`vgN@?`u zdib)#?7Fzr`4BK=e|cv+I4=lR<9~=hDaxvr=N+gRucSB5yb@+7JYFoee{o(&JPF!4 zQ9=ai#RMLqH&r6F*SGpJ)T>frszYGVYE{=AyQ}C?*lwH|!>x)7_Ra6rpVs`SoBLBv zj4?-^bTn3r_-lP<)vzP_XZD}ei&;8K-lCgSTAmM0&Q1>yhyMr9Krp{D$2u|zW(iJj z$hYn#;-_q!((kT!AzRWckfHCB-zU2ydk3TVT?UU!Ctmpbsmq{oY0*n}r`K=4B|y1& z2jp633wlk~F8eND8{___mvF?nwR4I-WE}YY-s+vHGm-yc7ye%A(tk`^{OWya+CBfZ zA0WUTc!u>Bs?(mG+i}(}Nhe?Xx4|4*_`3ic8weHvr#aiF-bJ5U1leSe$t5X3T>jQ-s1$JoXUiu+d zs>iw+^`Dn5jLo6CdYJ2(Ded}a?e`nwx&;w1^BDcJoqRKmyv(88@9d`gfPPe_Wf(@j zLm0oYfaQ<0pIJmP5L_HtVPXNwzdaWJhJhFkdovbn7IT5Rw_*G_e%f~Fm)iFrmk~;= zi=~EwpKn+^CCf|Xxy6T$i;i$zhc4>3eNmH8Ms z4cfJ3z0;2)Ux#!`bnwg3r`qV-$wf95 zAv3P?`}znCZoxS9gNA(O?D0d~lW+Og=lgl_ciH@PT@7a#z10ksL)!vPdK)PKQo{F; zBOZXjhrfv9-w)^Z`84C#U&Xmy!Ft>?b;cnZIO*M~qSxTGdF6sM{k|`!4GX8Rezc9Y zdVk+-AI_H!v{di*JqCr-ybCJ*?ybnmgZJ=IPOd#=?Yo4Ws?qB^H?7JdnVwKMFPE3+ z>g4o?+TO0RSDOC7HzI8#(gx5^`McF#rwkMWZ8ECsyX{6l%52zEy_t^>P;4yvM5=nn zSQA@ff9>A3f$LVsdY|7@rw?h9!hlmxYDv|p?@sF$PLA=ibK~l)kGNOnxcfqdqo5mY zXVzzR^2kqV_;1KcTafj!yuI%MTLWMw2T(l5f{y1#|1e^c#&(jhd%I2-GD`H4x<0=3E9Xf8|deDkgld=w7cm{Uq z&drfi-w?ElcVeu2QFC(K%dzoVwdn-=hOt54%Sfrc2H7;@Jp^1TiQo@D>;1vjSvvVQ zX*y#vD{z>lGeo~f;|l%Fb!E)Y)&N+J$z6=QoyscajE^sR?}DJ6_m1x&=YH@l0D-~< z{G%P(d+Y^i%r$=*_V|GS0Va4nQ=QPdvInxN;3L)qfEL&55NuJKVq9@eIe>rw*uc}? zjf^&=Sr30Vz!~S4?-1jvAkVB-S>HI`vvK98>I!9E_%1uK_U}wrmBsvPjs3TWdusy< zVCL=4PWBxHaj?k?Ac~*2Lx*^52RwAV#ZmMw*#~C(knYn0kOuu`4L0-pi$Q|?yu7G}6AqdG7IcZiyk#1U*t!l@06z-TGJq0#2@0ER>b~$Aa9RTgY(|f!)Jmuq|y~ zy%5CqQF6}ap;TPl4n1mjpm#hTKG)GI=e>tt`UwoOekhF$!L)7FD0cG(*Uo<>%VSg- zhHl?q!8ggf6cl?47C%vR4UCOTrm^6dN182kP4e8gx+!vS;cL~lV>p#6a@!?Xku3xV zkPqj%FjWpXiG}T=)NABfY4&43f(rXE*KTjHAiPy0j{JKKVhxzqoq9u`d|%|RIu5e7 zdta6}7eMBO{Xg%ipJI4yk86(nsfTf;{m$V6tzp~}!)(*?S!owWjKLqDwZH?Hdd?X^YDyKZJ4GuHIubo(7%y{xs_HPexQH00Hi^14DGq<3CKRp!Bw& zokxAxHvlxPpb}T~7@Br%-;g#hpIun|l}qDeD+~?Bq&c$v#$V30gVL0{aUd4Gj~=Jjd#MIQ_OGL;=aljGg*jm-5JHYuDJ z=UGt&agD)u0%1_g>O9cEuzWmvS=fB>o@)?BB-Z?L$~mSJD{G=3nxxzsS`C2dYpI$ zYgQi|`T5uno4L<;^48TgE%@n;#uIn4jiME}4r%ru`0|a&md2L(2G(KN9|J88F z%W)p1G*|Q<8o)t|mTdyi+yNl4Y3Unj)vTv+eip}fT?bD{UCD8;=rts$-3Caca_^vB z0elw*+=6FsPiyDA7;BmiUR%~^Dd3g7e_H^7X3fjcm4K!=avNcNEFvdfhb;3C?8}=c+N#{d+{frW_qv!@5)r__5b} z(MIhw$B#~__dkK?ai@M`Qa9u;-8|MgbiI0e(aZN{j;l~TJPfXs;dt*O6=6G$@%n{R`7=3y<|tUlIgVfd zD4T&e-(#=-^R#XKiZu7hAEzZR-4p#EYn^K$0_#8F>L{$IJt}S6`5~BZWZUO%puWb^ z*B%HPBxm$_eW$)K5yoDK%(?_fEV!m)Yrk(;G#%UHLB{p^7#9Q2cpq)=8V(&OJ^ZN0FJEV zLq<&k2)Kr`es-b&VT@m*^<{to%E8a~?AitkXGPjbn#szUPXan^gndLh!ilE?e4WJm z^d&{99J!hkzlZl;gCo5Qry7uhbLTLwwlco#H*KX3+~4PPsT#}uc{bzC{#^XZ{b@4= z65r(7+INnAY>sbnJ~BI%{$pH~wU4>8YukEcHIK0l&7Sli`_F!LZV$Wo;{o_7uNYTt zJB9p||Axgg()vY{(^hm$_#?_5Fv36Qop)ZEFkwP!+ZLd_Wy|#P%P*&2{pwe7tsueS z9^TV+w0o~^>6#lZNfXXIDb1U;F#YU1ck%C{H1VvH(pA@AoQ94Zl(uf#nx1*|rS#n6 zucSFM7ep1PC1N=sAS*tBxB$ATzRckjyWW9@n0HMo~Tsm#D*Z{G=5wpZ-Kz zP9EbX42)dq)_c{0LSmMOBG8bjRS5M?%zjZx#ku_YR_8Wy`JsJOXiMRV@m~I%KTqa^ z)Wiul{%h)hk&)#w?h2>GbF7vsTDl&p;PR=Dg|VW-kL%;6%FiQrR8Wk_Ew-?5Mbga2g{tN?#;zm@N&EKKu#`S;X{vqRVa1Y)Wbr;%x z-zfte8heI{UqhiI(c*sNF2S(cOMc~#BeJ7Gm{IC-dDPw6z7`Ou=rc0)J^4}$(~HxL z-+VhQef5486RDd%x3TMdk4(;uwWsb0**W<=^6}NMJ@$_VcDpY9)9_0^mO2&aiY}aS zf91xaXS875g4ffG`@e$WzBNOuYmx7)o!K*ZV)S(*ZLe!w_EX5<;Nv3}T+ZtWEwl%q zNg0daEDZ7u3nphycRZ%CXBGFIZE8T}EwshO-o?K?&Ve-JZW#S8>}4#{uibG=TKdYb z!!Ryxx_#b`!e3H5_Ywt??%8ed#I&6%$8S9H9l*lJ!hkBiruOIjo$W*9)UZEl&*KN5 z6FIWvB=)07(IyOwMHF0e4(bdY=-QYo7%rWwPDxd#y(?8xyy=zO{*8#@WQH=4ghuC~ z>W99Fd3f-4Wn=07RMhT0Gk6tS7&GFc^?WxeCgx|acmxB z-PsyOxZgWI)l0e2tKc2)M!NfsyFB&5;c?Bj_@GX^M=NxOPVtH&psz# zhJ$@kXfeYu7ndoqjEa->&AlC!}Y-@rj5Q>KHp0Mql&S zQJk)t9RF8;`MD?}){@Bm9-_Cs$6Od-W5+(j!Xb3-wkN8+Yiq_>X#vDA0ak@GSw=p$I&0&ynUTv~Lr!;=+suoz71>#-~ZLyJ{PuJ)IJ&{uj=FV(z_d*KF3+oyfcb zuw>wwHvr^xr@t#|S+X)b>_^vk83bFXAu;PW00Lao0dPqWLCU{!HvK~TMn;7x89O(x z!#Tc}asDv#f`Es1A@}iU3P2#%GR9QzlP=-UMX7^xj&V~HwoA(hc=_xN%x~?r&5SMU zm2@9|M(WCZvUsNRTegFMl*~wF>DX6(vmg0E)X)g~1Rc-;TR;G;`;dvTQ%Gw9R#2O$ zA@D`!(ldZFSy4gzP=K*xpApFGy*z6iZQ2p?k_pllM&EXH*Anc&C4f|W*jYlmyHo#B z>CBIRmFLU4fWd@)CNSYO+U#2ZClgnm3aO0ODO{w&&MKVKn3f9-wEeV<3gn?nk~YoQr8fX3e~c8 z+fcR^_c7v7N3YME5SVH&VfoLKiAK7aI?0M18114aD?*F zkzm&4g=cENW8$j>oovO%lHX^Be(oUhZ{bJjhTcmczz>aTw;{@MS|LiYbULVaPhhCpaVx+l&cX25o--Y->*B-Wh3K8Pc{g;5EYl+x(tIl&!dZH zL|6KpH^XS<;*gzt1BaX%I*EmM_YGxML^=+iDMu-myiC?EzK?Me+l#)LjJi}onQcvU z>xCcvZCV8&*AnA24zDTnqt}G7!57hYyt9X6+rHUO7T%UcWI}KxMR=Hq7Osw z6#64B%JhhB(lF^Y>OAg$W6Z^w4`P5pYtF!?{l`|_*gb)WX`e8B+jZ?jUgiU_HB&aW z3iBg>7IVvf%j+W8uGr$r@xvT0)_<=c{_eXqD_{;I00|NeQ zUmQt%j4Rz8gLMpJ`=)d##D6zY9?Aa;HOj{(FB3O?Mg3&DOmUS9}Uv;bM&X^`SG? z6Nz`-6A&XH!SV76HR|TwZ$ee0AM==bT%)alUm}CE6=t#dIGr0-!ZcA#d~nZ zVFWNP)REOVqIKgXs{>%)7{%@^JC7oXuJ5nk^~GRc0#BI*QeDK zv0Mk>BD3XPuzzCRWea2qQ8e)peO6JG2*r_vd_Aey5eR7N=0hiT$?skgKqZ2RsIP>b# zxMubfKZyc?+FGtJ7W7j_%K_j7-y&6(c4~;pDi{DrSAqPscjv-@bDap=hcPANMLS1E zNFSJvfa5m(`Lp^R%@E1czVtN5Q7hFIXefR#)E_`e zKy%$9#xiv+WcA5T5D=L3;V%S>L7ljIHsfl+YthcCQ{TlL>BZQ;n_Uh57qPRRYg4h_ zy5`<+!wu=O%PvbDI&@%b!1DCqgAb-JfBDNX{*D9?*aHCXHiM^~J1(7j=^3%hz{B@F zohDO2uovs^NB{H#Y29jpIRM4(ozk);tJrPesr1AH&j(PSjeC3koqv=V0!`3|RaI37 zy=yph7@56#^$Nsm-MV#=2XoMij^N910&!r5UiAABwQa^i_v&r`8r6(dzH#W}f|Q%v zrt;hadZ*)4?_egh01Y;e(dfjUU0WmPY;QRFQjCfXa(^|?u4gR9%;YS;iF^BV@e$4? z$gD@EjOxCv%`4*?o#&X1g|EZuMq#0?gL0&EsZ-LPt$MKDY1^`(@0oulATWtMMh&P{ z7*#Xw`=3yv{@xiwY0&BKrRdR+w2AF~rr-Ntb$N{8*h}RkPYI=`la=Q&+8*;5MU9J* zVcY29Y?PzS+&n00=H|JOtI+c!qPyJR2t_3bbYG(Bl`K?mJo5dBe2Ad>TxnUwN;=mVX;P_*~@OXq5(;&lj-KaN(gvmv}w0!dUVM zSptHz?%XSkk!@?1#Jj|^;*6rdc!mpBC`9gXO5_#TjXWNGwe1CSRy0(&*+?svxxm< z3R=Y$OpF~{<2%;tcg~l!qrv9nxbWIppbBP)m{fse4 zKg8IIYwL7MIOFt7?ZNwI0MUWRRz&{*g^X;NMqyrJ-MtHUQf~1Mq(d;~Vr=nMyKV!b zk9-%$Lh;U|eS<>T9aaBq6*q36?1_D9YEiKBh?JN5eG5fE^U>h$S+n76Dm(t>%c^Jo-p z2RdRSlw;Xx?(Z$ArgL9eh2eh6WkEIHOjLN;>yNT#zZ4NPb%&8}^^N0M)|*kwL1(^? zsQ%?aWnT2+U95Faale)kJ@124C#z-&4$=}RzvlJ!M*=A5((1xhG27d<}jIGQuYb)psSoK_n zfq+2&30I^ZI5^cX4;D~#aQW0nV+~eM8$58lTWqfnavDqOfx1YCWB#+ZF^^#)weOU= zliD!sybne+*9hez?i0>5x$y07Cj?Y{p8aQ$_x>pl6bAI^}@_j1@7M%`s+=rHNfx}NzQqwua# zzL$1PTb!q!!_R^V^T2nb|b z%c(!L?Rt(nhoW_VA8Bd=s-}ZEhIA-h?}uG*Gw;76()`T#-v#*42O#8>>;Ey@yqE~@ z?8knN zf;!7!*9bOg>y07}p&yJGZ9HvS11Z|H_N%f`wmSEOm<<2-G4ZBUrgI@rd=GHGwC&YMALOxGo}GXK9T4RAcU)M#eO#UINkGD6s0d4b$4Mj_ff^CBeD^cRHfE! z=!Brzxe!!SSZ2X&nkjqT8V0FmxzK`whm_1u=^M!7q|Hb93}v!09GsEB$Hi5M{HT_B$$Sa91T zr#9hC?A)T!M;;?+wA%oQR%?iKCpT1O>3K3V%tOk4A&Jm~Ka9U+84%ICp~r zCTiY}XsJ%(K9s%R>9D(1jZS`sSQ_<(Y6$4iuIm7d7Sa+>w)UaUlE*G059XnY$X64E z>4|Y;bV9nh3yry8E)vySHblf(TAj%B>_>kP`S&~^7H(x_N{W5yIMA6jPi)C64@7=p zut{REDL8pB1I%sfebNOOFP)H=IqfH;-4tiqx@sZg>SgGoQapJF#+pX;@Js(FqB<5S z%qXOlu>k9+i{6XU88^~@5{)cPg+4P?aTm$Fg^=LnTxBk8F>2j ze3r2;czCc2q}0_^Z^3X~8b)bE%L?)n9BGM+`axxF(tO`a#+5YEh(hpg8gf$cj1n02 z+lg}#>;xOmq1>GRM+^v@0U!YA&=3$%zP7O|R6_Sq*5LKI0VZM4?#4jS__seC^MZyt z*v@rx8KuNF!-aDdz zNVibyAjXwOIr5h}c<#C9rZdhsBeieeKDC18`}*szr=R`oX94maNu**Q^TPd&yY{F| z7hQEuy5Nd4qssAJKYJj(^wjHV-07p!CD)vr#!eiCoOh>Jo}ZGQC7*HX%d^5zYW6$2 zH*z+j5B~S@2nfVHWbEmnsPijWLtC?EwEp-ylPIuAT_5IVBvR^1qm?Nm;Z6lv0Wzx5gRfD2H{kgUbF&$ebI}*N}Gse+aA|N=UQICOPD zpA*z)4Ltq2H0p{!4rfAVV14ndF}-zZZrueE7zaA7g3JL3FrL&~w#nK)C%^Y^!cm_8%xw`J54IqE=lVC{1OLi; zTp8&lR>k+ZeF2S5x&H5?h~+%S;au8ddplsem_AZP8ijzzBJ{C9Q>?$p&g0Mlfj^EE zGHsuifBw&D9qYd~k-A()gASr{U(8%s&${BfR>67`&=On{+}ONwZmfxdZRWzuq!2iB zjgAiI9bIEPGe?G=`=OXCi(x`cV|;6Cg=|&&0p4fh%f8pywVr@u&p(28uG>cAYpB1q z0-(p;01Vv>I}*Vs?6XTZ8g~)J=nH#F#Wq3Uttc+9oP9NOvt!$ z?hhI?C=DJwICbnu`U5`8ym|A|eiAImQXt)Sw3K1Pj6t)AAa~+CaF1{x9Ei~(cB z!R?ZC61suNi;DNeY1IJG*w;C7(KMQ_v9jQ~+lV4Ag_6~Wysr00uHp`8V$Xj2lK~Xi z1{Lus(A0XOz@!ts@{4~4U7sD!mI|of_$$dVyfzH1ttd4O4I>UaH?5@|S(IYVlRv{z zdOV!Q(})h68sVZc4Mf=JzJKG$4gdf^07*naRLWb$e$sn0uw?7nMQQTww*Uyd6cPT; z1F3=xHL@FqoYj7%7?!oE44S9Tdkv0`pGRI4h`H#z%GLsb<}q44$znGyuo`{y&CP>q zsL>-js^i^>sEr0)8Q_e-fQ5}}h)}Sq@*b@~c^^p2$rCj)ZF|iV72)mFYgi~^-`&1& zQFI|*h;ilu6#z{bEc+tjU><94q60DmtU9d&szGF}fUQL3-AYCS(li0L1zuvNx{vjdnziOeWS#uvi()Y5O^-ly#K2)9vx>Mjvp)Vn$v3AeJ70vb3 zpq!C-SvO3=IB(hOk6`>zBnO!Z(umHtrvk4A)-C`LQE=(1w%_?NhyK{e4gz__;CLzI zX+3}=1_Tbk5OAS4YG#D7=ZG^xwicvP&K5{)5BTJB*P&yKZf$3Lm362D06QZ<6H^y- z2$XZk7~@3RqD8YZM#7I6pH{EV0D%hTNYp`q0xUbiLP;9Hul@3tpt}k-DqD>g!I@6| z#!@Tgy#OdU&B)7n*s?VR*GLaChj$6l94WCn|3>F32aHZvWC6eg zi_|IG&{d1bRbEWgH3Ls^6fi<$0^E4xjp^EJagH!d+O%nt9)0xD^yyE3I=&MiINW3J zUW*$wPa{qmmd?BE^fa1cg0H zte%;_`BoAT7iesFWPoou#Wu-rpLiv@a3J6T>kRAMcJzX4ve)$@x;^~jj{(LnN(-sk zv5N1VzXQ<086fZ%ICB8*hnO-TAmG|1yGO?|YQ(TkFhOdYs6Nm!l_6lg0d=%GTRE7% zunPb{FxrB2vUlQI?IPBt00acr0UfNiF8z5M`Q5q06^c>kjdfrEK*w;lciRYHr+#*C zdmR&_*cR#2$rXHE3N>FRmxt3vsP^cfV8QVm0fDJ^e>o!mGUfvK<1C$Mb=CMAKZ_2+ z0YtZFprnkl>{VSWJY<7dSaA82hl6TwA!BpgEvRcsn5meJ^~EvdrVRAN-V*3o zi(_oDw`zh4J~!;M;tL8tI}QvqbU*P-0D-GnFZTxokSsvcMOnpv)+x8#Tk5)mgR28; zjipmRcnkWq7eLR`Y091d9zlY>ID)6ZD$q_?L_t6q5FTxCl6~GV(mqUq(e?;{7P~P3 z4$e7rK;To@rx%7z`r7TE3;R^N#y%W=*&ha5Z6(1MnJ+mYZzS2;OENTC0k}EG1eGkH zX(W0bW2@2JegJ`}{*QC(S}^VI|6*Jbuk!pZamECHeSl5xsiG!%iE{F`5JAg4}}2n@R7Kv9StUuz4#! zW6ou^${7HS*D;>fQ#kCZ;paKQ;C2(={!g zw=B{Htk-kbPw!7l7cK{oADgbf`RcTi6uyVt{B(HG*3T#z~wZPcOO#NxSz0zT$aOGneW$riTo+FUPLVA@9o*O8ZeEEc;BENDi= z*FpO;x~D;4B;Ck{e?95~=}P@He@)=ScUetUW?2K>ho2V3 zUu=&Cgb^iab%G6|!lSSFWEh8=R?H5{yi~Gg>pKeQUad`DV(hGs@rM zfG#FdI^F6jr?I;|R&4<$mIOg3t6U2p_&(iFoD^uXDGyn}sb@gnohx`VKD zVHkyL3e}vA3YlBEW5cQ_(qv`Y9XQJx%@aR#OHkMB>(z{1>69)EzA}i(9oI%IRZlctc7@VW7 z{8PRg7KM*yKlWoBNUB+5oVkTgyYBr1I9W%e$H;;V8i5uK2W6{4BVBVkd2&|F)?ifL zu^lE10}VYFVO-Kw(Aa-B33z2ILqO?9xe?_uQRn4aTK_k~y`qFWeH*!b7G@XuK`t9N9+dA3*?( z72i8Q@?1t4K8{KAg4=ZJ77;z2i9B);MlAs5h|4~St{EPEDAU9!n{%W;tO0>ZYl!G% zSdcJs836<)eem)Rg2C@cX2RaI4oBytVO%1U;+sHjM5)~um6LzZ%JNEaW;NsJf& z6CBq8Ga_k(SSs#`IO>9lj)FZZ-&s-k*A%B5Om+>5gMX~3E~`QZQ%0LX7y*G7fBd&m;7`#1V26G0wu3SR zEc&SK66B7Q0c3MjfBZ%l9z#%an|v)JOpSNKp^zug&&Ck!Q3Z*8nrNr0Rh)u*Vr5o zaIHNO06u?FxAJY%wmh9YX>>aG;?vTJ)afy8&-)9=|M=^7qz-I7c;4k_ri-sRCoP=2 zG(AEMfoC6iDbfovMs9w$clN&m>&N;i0Rk+##{v*QJF;$O`*&L`UUAa&u~pp^aB+%yqN4d)Zd zJ?@IawSdU{r+>lu7_vA577-HxmUb`IR~o$gC|iNH-+=&ucLNAOs~5#=6c8Zy&xnXo zSyKUI1E`cU=M?0Wyf1UwL`IELSlA@XV}weHBA0e<1klg7KvSQM)2ox<_HS7p51!xsuKy3ZOITj|A zCS3vDY98q9Z1Vh0K$&%=&y6md=chBfeCp%j%;r%L4LSQz<1O~Jrr%uzEXWso)?$C(*++18lsEWa&l%h(vJCKP0SC=7^B2QXYh!o!p5ZH-0&5_-P zVPZt^UjhJ7Cs>)<0!l60WVwtZF8MeHe%nGW;}3~CE=rZ8F-&4?naUu2dD?x{7y)#W zDk>96(8eNVGjV>Znd|leJrf3rd5o7{dTHw0w=Zo!AwBifQ|aqp|N0RF0vaZ*aQx4` z^z?N0MUzM!=$w8(%nYZ>l!1P%CF&o~c?FvG7946L zdbV*awDNvjvyHWN%H3ZKns#wf!JHvrLC|>^?6t*EqlMXD86eOlXu%eGb3RVJ`#;kz zS$sq-c~ArktOpSK%D3V9IUo>)3jtN9QSZf6uqg0{ZYw@?pa&3C$WjK@M1Jx@7!obY zTL(bqjsoM~Z$Z4)I31=8e6=1RU>b+Jmb3@hoCe^hJ~0K&HPM{@+LVD0d!%D`*4e;&O%E3*-hoA>U`y6k%8 zT4@y5f_jlMKvcN`w#r0wr|XJ4Qn)Th$^bf0KwuMW(8Vv_6Gaexb}=BZlHi0X0~sKY zfw{^=om{u=;PPOM)!TLunK=#u5Fl`(o%Q-%pDzLgc0_?&x5Qlq3)N=`)(XbxJUWkD zV=WBry3+=xhl~N!*sN0j5`85Y9n2TnTnh+LFxR4!+Gm-=h+TJHc~#ZaYqqkaf~zy2w+d?BoAf|%Wey>k0OuS1=^mjR}FyyS&BWe zldXrLOy)C==RW#<`ll?evEPlhkGkql$ge*e8+%Hm>ljF|uySkIL<6zc`cv1TF+iY< zz>fihL1$hcy2lh<3q?CmW4t$*TL?Gwmh#9_2ChWEj7?MS`R~}VV_(gVcn{}DCwzp7 z?BvyW%0SmNp7~=yP}blSfTk>E;1mLNUnHPF9R>nrGVtslgHahnV1GbBxoIDnGB9x9 zzyNgBuZM)ia>q|tUCl0Yi zeFns$C*4kJ`Z`d2>HI3LL1%veKmdn@NcaqBi&pg2!FB=D5UDdtQc%b@E( zySZ&1;kfZU7j{_@DsodWOv#w{)K6m3QbrxAgD~NS&j#&1TWJ3a#mBz)v`;19dEhBQ z5w&u(M#)-G-vDM@G*p1x!$p7eHGdgKo!71+qP~+f3+Z4+-BqH}D>b|<@Z;7*yKq?h zA#-;yXv1PKo5g?Ws}Hgm5W(QNE;{+WWpQLQd+R+A#cwCY`}9~my#F-nF1Xm|j&`H@ zX0{W9&T-)OSJo`34+yxxPz(?!{!}8e(lkZ=r?OBA!bE@I_@4CczmCYtX6jPt;IE)U9~e^nUjPrn^=yWb2J-?ohjlsXat2SJzxzgoYq!>t z2JgPhj;SzeXnRwn48-8~FP>w1jO+~4Lu^+>ZWvcaYi#pcqBK$gHRxp!IUn5;u?Or1 znH}o@7-v87y)fD$`kuGF_9591k&j3}xV@Nj(mlkd+$A9JS^=aYmyvO+12Ex+&%{Nh zYRoWa7&#~tfx!t-e`Ry5B|XMm#;rI(l^BMT&<{oe)m!F2YMAIq^#BxAr)?uQR_4u? z*l8mJAk;BcRaIe}7;Uys7cE+pUVDv-)1iN|JlY1Ya?oFMK;XQ~&WPehJ$iLbPf|3n zd+)Ak=x}u1f@SI6UqVR+2>6SC`Z&PD-uS)*2&8m8rVOY*Omi{iN!_U~vhu&5>&&X4%2~fhT=EA2 z#tW1m6cC7X1^@x(e#0Z$g>yOS!xVER2w@a?2F|^8jOwE6^{*-h1kCNXs`+$4JstJX z>CEHe!(fCdQSNiET&$rJbY)~Kd$Bu!_=)F#IM!v~Td=@2&$UlSt0TJ%2s~JD(PD%$ z&t#-|FF_pTD?l-lluJQ>84a#IR=`KG#5vkSu3b8v%Fi}=Z?_SY8EM^!WdQLO72G2A z89*@{L(W%E3l`_8Uh27W)^cmc7R2Q4t_87+3o^(V0@j9k zD?lKabm(f^>>O~n37@0RwpP%nEB*wa{OkaAWoFo)&06T}XS+`s`4?btt4323b&Tz2 z^>;+!=>xax6|^36^`8=~SQ6{{a>kG2rV{}VQ*e61%Ji8lU{f??2*@mH54*)V+@GM@ z8l3hwm@C?DIXGC%g0p}8&i)&5@gIb}V~UH68XCrWk}+snvZdn4%Rj-Ez~e~`eLB`w z>r%P4nMTlS^tllfiu4)SGC4!QXSHNZ=x95xyr<*cc@^7_JKh1g|{%Iy(>G4yhsUjT?>TTk@xFb_U`I5E6g@#)Wi66_pCsc8f?`Fw6+x z4&Gmdud;MO7vZ%?U?s@;!WZsF0h7mQ@kHJ)JF;iJNqYrOMqc^{Fbx(26>k|%W3VS! zFic;Vc+L16$Iki)?hV~oA7<~9{q4e_GpA8vlp+8D6nwVJ zKwTbJ@ip-?azSYt-5G00E6)yvU&7jiYL@ZL*k_5fF2?1t|nq#*!*xV zsdxVe+wnaWj=$Si2_~!{0w#^jt?JyXyCcPFhMad}7~Q6PY$R309TyH85CF*^edV7M zDejH|j&TkMqG9Ob9$Q!b9{Hz?5BCul%{IbkzFTIzUlN70@?u)DM%IzSAjoD4L0#cH z`cs1xSq%t4;7Xi)7y`femjI>e8`j8^#jlMKBXTv}4MVnq23|y|k*CZ7<+cTI%~~Ey zsVrO@apU_V2LwJE4*NFpisw9Df7?OZ?>MVqp*QmAwq5qSZE{@tZt4%^X2HYx6kO8q z(BXE@MP!NMSA);IF48<^Kk|L_1PlSLSKf^sK2yV6=cYe%MI$={1Sazw#w7o}N#ArO zz2anQf(Xb6+$;o)P=j-5B^(#6>ec>F5?#Jl5{3YtA5b1G)k+Xq~3_W1>7>1 z(H$u)ZsfLQ8u0np(l{xmE^3S%4RtY38942{ap}zSC#FHe2c)I*SEP#09YQR3{P@1u zesBO)kAMG9K9IJvJ>ioNy^!vKMNmo^SQr3JW8n zCMaO~O4lLdQdj8lrrii&EqMCp(NuTtaI4^x-u0KUwz{qegqkL`m-Qe^_39Qh^p!CC z1j7bn=xcbZuh($idKd!Ef0XOM+sK*g?Z+5h5$XG^!71+U+7>D9E`v*PcPs8t^y4|_yx)86e>1t0xs%LF z_Rh{)1_l$}oDm)SPd!y!V3P!?sEA*Kvn$hY@M~>onV^Y|+G%B7$;cdO4fxQ?ucm4| zu;{fP7kXD+VtAxSNYTP-NQ=?SS8!T+cD%t;^VJEA-WCJe4NbfWk@@3h10#aaEe70i5fQmUN{-^tbj zIJRNz#MR2A4_02o0V$d!6lZJrW z9fXmqI&B}3KOPn+>Ts2VXoZySZf1(&EonA$+r-QHiz}_5M z;vWAsae10YZ=ocim|l~k3XOlv=W!lT&Vsb$GyAXSvug~GAJm(u0RnhbuI?m-sZU7r z7Y1J{K{R5S2%CdEIKgZ3?DNK@5p9;~iCf=(!tvJ`#)I1@lb7g@XBwt5O%e1J3#P)p zK##~ZcwZ_ni&X#k%fhYY{zN- z)dJm0M>%cBQ|ago&v_SIqe0!x<0#j3G=obacc2qdia?XR`Xl#Iof^$xL-0s7iMA%E}R90>jp!Ai0{bVN`@R3T76 zwv$rlFW$*p?fF^uSLM4hpJwgek6!u;o&5kneoj~zSRlw)TpM6qO-LgePhT+GPnrb- z*Qs)r4CPf0ME^HDHCue_Ag#tT0U83pM8WAUHF3!DA;OKB;dtqDoexBW{kX`wHe^hL zJ>ZBf>5yU=GkYFy(&09wbntx>hCV_dp&tJ5O0TaU-!=arkO6P+AX;)X5P_1^vu#aB zGVT#E5ID{6*3FGRj=dHku`oOmJ2uoK0bpOmfd>D$@2(S#N1*ihqhmqvPW$Gky;}A@ zSbtK)`70gRD8Qeyke-{5-;fU)VK)b`0YI^lE7te=_=_~oe_|jJbU0(`U7-0KnpU7l z>6rK+L8}{(-#u6*>AsI1%laqi-zin!m9TyqEe$!EjCh?LmyY!|8sA+=~N`Uf~rGAt0terF+uLI!ONCh%Em48E6rihOFn zv#R32m>QX|H!HogeH>=&uJ%0>+HiZ2HMq4>yP3J%@}D@9X05hLp0wr3Eon!f084dp zfV*cu5(3pVczUlnj8<}cF~Z*?-@QG;9P0R(;wb67@9y(d`lvP<(mP$5au@7J(7=0? zn3Z3>kM#iw%H_H{=#TXigGfT4<1>4=ugq;k_&^M|YV6HWBub;485Bds%FxwDFmw&B z0>XU39&lH9lf$Oritb(XM02o0K1|{GRP;{U=L-aCekFIFKy;#Q4bh;cXSvWpaOu8b zNEYWOW?E#BLWmR`l(Qi88UbFFN)A6e+y5o-B!HQZzt6;lv8J++l#U>{IaPw}!S=d9S&0PnUsAM&%P_LCypXU%!F8W|OV=*V$)iPdc< zT)&cFJDWf=^Ik+z1wE@lk5NF5NJSR)gX2ed(zLo*rr(w9bBZO07Jq~ek7Mly)osrl z%=N*2m5(QU3%DLLPWmw|`@ee|mj=#Me?M1SS z)Y-IxPBg#=-p)qhMMwW8lpek^&swAuH{eZh>`ED7*3}y84gg{DSF3lulnNWrHFjrb zNXIaE*!=1qCi9(->7i!V?M!*(tc;i%B!b7AA=8{x&OL6%$LT~Gt4WIItIE28{mo{Tr&*VmV0b(TD9#|h$D!|}0UGl+b8}t=LWqB8=e40SLBJpIusXsz;-k_Cz-wop!)CLY-iiVCoV6IO zUHe@m2x9gJ1Y%czL#h88fm4|Od3k5ps!lsG^un-f=X$l=|Nq2F4GSR<`fq(j1fY1L zpI5o=lL6a{*a^@C$zTc$s@s@7j(HfM%voIyVSZs9KMpzT7?FJ`+5?$=0(Tk_PzG-u zZrXK)|LfR@9O9zG9tNIcV25KJS4SZGC#rUg2vl;#d095-Gf_7yAs*l= zJI((NqbJ010Y(|+=aDN4uXb9W!AD-OhMTxsoF%@gI1(v@((0YgMuusNjR^?nsY+mS zHvq5+cg^oE&{JcvfWg=d95jb2seR6M|9XPnwz(hCJye=;x%n10qh@CS;sI~Jen0~U7b>4_2}C^ZqUV2yMxk%RIDdDKK=)QhC1Q{DpZ)?uqhj@#eFAa{5Y zNd4{K*o}kjx_Jp!JkN3C7C({DeZ97wF7|nSw9S0YZ2Y=r^fqpvS*)Y9y?D6}<%J@c zp;?}H&`{S;$!x#92%r1?uA)thN7}qzmeacLJSUtKxEG$h_QTU;>y#xO;9M3c5|R5T ziAtF6(-!DzoBODRO` z0)PNg5i0gL0N@n}WE>a{jz3NJ1$oxhhoGriK?0y&XUF-jf>2b<}x+)w9)PBDe+PGTjZIu% zMG5efNkJ3#twkM-O50D@!q^akv%!&fPB=-uP3W*FkRWQw*%4%W$i-w6mcm7jnB|y5OJ)4>DV7PxhW~#v~gvC0k&o z`6rVm2NDH7=x0YkMnby39R34MQMIsqI!CH}SLxKb6_QU4m-rsVMI#~*5I1Zy>491z zq}XXmI`Cq=?wiWM#QIMS$!@i>4qo6RH(vjmJzIjUYBBWF_g?kL(478CdT$6l_1}_T zK;&6nSWKABNZhnySM70u9R&1b#QX`U0i%&zi}nL$eIX-OiRPzt`F26ysrF@6*AyS* zz38cd^ai8zA~^M`jBLS++`tgVj~<7Ly;%iF$2YO}EZ^-9z2pKQu*qL(zS@O7(AbKf zB{7avBZFnX)0Lq)FLToz4y+`(5I;JhJLCO{i&60*ZGj8TdGG5iw>qd08)qUlXUtb* z0>F7x&UxlrY)PEnI$iJIO_lx|KKj+5BZ-hqV17|Fr)J`#X$q@484B~;*awA2)s`2! znswlht)ISm5&z11!8L~{>^S=a)#As9wHJU;+vr@sD09}(Mh0?>4a8nK7&u;r9=2K- zi<&xILrwNQ&bnyH0PCp4$e=8$&90ixi97ranCr*cTqL$*+4e+sUSX$8B$O`6 zoJhA(5Amynetz=}6Zv_hZdrA;JHnRV%;Hs^V#ndf0X@3{jTi~o?C9MJU-P(vNBCu> zm=d|dPV4v%DU4)zp;D|Ihw1sZgFeF&+q*SR>c{Yt13M9QFc|H|M(||NY{?3$dkQ@m zq_IWd_~+r^U*2g`AJHGQTGHs1(Y zF;=DA(2jpr9hMcCtj~Lo+wSg9C-eD-PTtXi*pbBywNO0lSV)=mjT6hHj-Jah1Bi-C00M zk%*ZNH4Q10-wo^zBHMb82Ql@haaY@K_ znojd;hs&$=j$h_i91r4<^@wb7vG-ZVgx@bRX{!GAs|eCh4}80ljzOkvDXt3Fl(0Bq076E4#@?xmmY_>iA;D4QUr{nMoO)AcIXtS#8+U9=K z>Wuq$@BvxCoIE)U0dxETKmY+n7FWAPTo^8vgnnN4NH`7fs@4HA|5&!!Mrk*JLjk%Q z40?|jEGVBkUghLB$A4LS2g!>Z!(}_HUID&gS%`D!HvEro68?yj@Ls40wqn$WLhk() z$B&X8jpu_8kj?}8kG^jV!=pNOS@DfRM8w3iqERnMuV;r=p1;?YJKti-YVLav1dqCs z!pDf!t`J5@@&!>s33LZtA{?krm|jJQZB{OA)`?UK=P@y2;R4V5J9a+7Tuf6|7TN)M zt6#JK0_LOR_#Y?o)Ql=SC!Px~>r298L>_gXA67c;ud^9~ISU;%O$oN2c{^wJMQv$| zRo>~&V`}DHoX(p_Wgk3z^-P|8=YNsDtPNN}=pic%C_NB9%wEi)BHe2ZgUeIs#>%e% zb0Qk=xqH?xskYrh$)3qCnzl1X84pm;HDs1n@6w{0ftk@vQe$V%4Wo(o?Po7TXA^II zfY`z+B-zt6U-j1ru9(6!DQ9T!EOSOW^K3GS zFk>qOx^;p*pa~p2 zeRNHE@{~U>ERa5^d8?o~;brx`f(&?`$uBQ^5;V>4Xu~A*5Co3`a+ z?(w4{P91CDcB8Fd~vu*iG#vlsxu=R*qg4DCM5Wi4$6?ceg_-$TMGh2drq{c5^U%58PkAP^rM%%}cMvD_vk|SZvhf!C=bKx_)~@I3>JWGKmVPU=cDOd%^PRP!)|= zSNwbkKc9?})kJ498Iqen?`OjnFLnq= zTQKu7y=TB)B!bf#DPd1V-o1|ZUZm#lmCR=wK@U?bYAl^#X|?F|IrK;dy;J)L!-)C@ z1eY`Zc1~kW-?NrrLbA9 zqJap#E*!-#2)^(xx5tFCGf%gbfY9~`Otl5ZVzi04a0HWTjRafgP+`Yhb&2PBYXleZqp zXEf++t%s}Fj+&nS=^gO~=^fiscxRCr>OKG|k}l_p?a-@T9k|}(se9HCw(@NKH|Y}2 zh_2}OoeI0LDQt z4z&$8m{T_%#)Mxy1&Jzy+}|CxR{c)@!?(8oi*H1rbl;bA-JFH~-OrLi$9vmQ6Y+06 zPSNx-ZOH{qa$Z22&${rtDX=hF0XW2~_YqNj;~)5hR|6wHl*ii=I*mer?AZm*ZoMBx z^yRHZE=_A8jus;+n0q_4Vn!$HQFA#lmJPnpHD<`(Pi3(RaGEf79D)3SG+b&^f*(Z1r|osW^$QF z`YmAeRp@dgd@LwNU8I`{ z1n=$Ku)Vx*ulWb;!yL}X#8jg!Bh2;@47It&DT8xS9iiPY&H-}yLzpdTd+)g?g38}$ zfK)!P1++d7{4Kvp>uMc$Gd6W{&FrrO?pI1l)I}rPVN*Y=zHBCdNvK9d_b{FCr3A*O zTMOi@%DFA-^i3F;!sEwCBGN*)wk>5>>7Ja@4_*Ek1lWIqzegF;zP~YZztFSvrD4;( z_;=phvKy&<^_zmsB?1e>z_n~dX@m>5NfE-n`sI^c__59R+Rdbs^B-7218}7L?N#QX zD4X&m)P7@}t-zaV@;fGEJTDaEALiV&!n9f~Sk>FJKjV_=9}+{{qmrYe)3tOIJVaL`ijC4#JFuOvb+ zM)!X&s+$@t;d}m8Y~9C%rPW5dxk zYoVl515L4PfU=~j9S5etr7p?r5p}cNM^5_9^s)zOLya<;fR{tm4B4gT1=$K&Mo*oI ziSVD`hlzm{7gLfLEk0+M`59Tq)6>(d+XGQ+TAf$8PbaR4sJy=-!CQwW_7f>}Ycaok zvNKZ)9|oMYj5an=WKF#aTDyJhFHwKR)|z!G{5c@MJ^ls{r(22I>-*Wd>73*s0CB{) z+^SdXMnC`a1=0w5dr=ZoRi4JWt&*cM+yR!=YKss2HBz#b^@@tiSLqG=yFM-w=v2n_ z{QU1I9%1Y#&=~`=KGU$b*)zR_KyJ+YjZJZufl z!?kRatZ8Lp93bU-e5?rs9&mv`ta*rV67n}&=l?;1trZ#wur-74d}wY#l&avGnkQD~Y!Z^6=ICzBwLp5!Yg5`;gjzX|0j@7-~k}Q@yFT& z*sIQ?IK=fZ1`<>h;2_xntQBf$+7ak`!hldj7*1Bfa`ML_GT!UJ*Z#kD2G7{2=islB zYEkrLxq=JrmdyR9gw=%t+KQ#TxIU-x?P#jH0>&^INDbg6L}Lj#;5Q0Xj|8lP6#D%! z=*I&1@+oNyH38;u1Hvw2LIBJ+OzQ3f&u1R(?^U6p~6&>fUHt5m{B_~9Rn1l6J?%48RX`u(B18_D1 zpopZ^V;8OB6w73ZCJeDD=ak>uQA)>fmFi5vaK_^tFkotwBCOC;i$7tD%Izr3scP%Y zvN$$iISfO#eopnJ;08-2xqa(-g7K7)AT1-mhAgpwPI*iVUCtg1vFE9GHUKfM$_zQ68c{h_0|@^>WM^I{{KB%e4y~cdJ-hu7^M5K`7nNNZ}~eMlBP_U_7i8w z(q;H-vOkahS0TyCui;4i8fAa|iq)@LUfXQARg7MI*rQl(r=U3TPXS|dLVE?qYLx{3eb8V74ja?H;s3ZW_@&x#ty9P(J?#Jr$-?_&pC;((;dMA(i z424xXZ$jz&IggVd!<(M$!t@U?=~0jQfoOEe_jWUSQOp|b3JhriN%rKLb|=`)BPE9f&bU6 zvVmlvL&QYcj|r@L((#h<%*@Q(Ftx?S{mjY+qOL^bAI-D!D|zKuBS4d(AadHiuirW9 z;tIup79`~)D0-m5AG@ZHLeY9C$>MPC2DJQU1Gb!~B*-$&nV%rk;=}{Os){FePngj$ zlhnRNu9Tl`^|wMdiCvmvI|(PkdH*p-Y#k|@s8%F0FHw$v|9vtcy+S{7mkq^@7E%_l zS&4w!aj5;dOxzseJTd({>%$VMw1Rlc=a*qY8d_yRCJrCc{J?!^dp~@|rfd3QW$>fU z{g3doHUVb35xvjH^p5n=8>C&t8 zSVNTtX3E}ct+>Ux;o0>)&KzGv8pU07EIRmvxqY}d2gJkMQmHaNzHGjV zU&XQ?ciahTA(;~T>6FLbrT!s;7ba106?yQt5#1W_h-~=l`Jt~3No`kXq!Xl6cs%5h z148e`lzSM$joosjVO zPD+j5pW0#=y`)w@8Ut{Vj%uKGLFiIiybor#sd=b%JyY;6B84pynYe|az>|If)A#q1MC)|F`%} z?th&xa{8R~KY!)_^Fg@C`xE{Yza0Lzy?j^{PjEhLVfGcvm)n|N(Xt-^*LN5ELl+Oq z58$V^(bT#+o|r1HXGw!~@_?d%)AxRH6#egKzf`yWhYf{~wEr{W!tjFm5JWgZipYS` z|9KmY{H*`_iVt}%Y32Q;uxW>|H7*8(f1Don+RwmhX^#( zLLE~tq}u)}Yw{RpssX`Rb6~L=CBAf&4IjHhu)>Xlg_Ap!2KqE!40QT9PCRltduls`rBZw!t((5>|AU)*-Nf|!s@mH0 zfd#`U$;r*wf@sfs|Nr#bWSHVY$^HTXM5aFY$Xn(rOput$>nTpl{*g`FK{043iqtnV zNGWF(pxCQmRV52G!iu@Bhi$37?q{W%hytTqyJ7Ll&+vCk1bN-DCtub-{`HT@Bnl$|aFx;b%o!abH#-H2^8Ad;Gz-@s zuKH4X2>amZ6i{fL!t*U?lp*^NOM{cfhxafErs}!dQmfG+7#z|HXrJ~!iLzBSt-T`x zECBwzdIF-e3+)b*3j8v-j(|^OpUIZCe#M<(l1{F69!0fyG{sn+MkN8~WMWxdB~hFk z;;`*d7f61)S(U58VPXOLW{W@U8I zRUIr|RZunkg=F=}oh?8DWz8grIAQeMt%$7?*`%N4sVD72gq&Qe`dSR? zF$><|-zNXzm@JPbCb9Z8JFk~6{mc11R!V^mVwRh6miHu$LBm}cBj<9+caB1x$kLf& zDC{FTy9(+7x}ENJWD~Q?7wNWdod_g1-EJv!sg`F5|Ct#qZ(=rfDY#d?CmTYP4Vdm? z8U_t^BjZ~B@&)wFrQ)`bDgZ-b_%Fi<9g{mujEp4+Q=&dt1vk70)e43zn%Knw2kqW zEWLo+xDh4T_g`J2pdEU6YJkAUOhymI)a4unf18ni6fh_qZM`o1yW!17$0GXGh-kI1 z063_je;hHF9t5KL-9qdER>$N%gGsc$PO4)Kt=2E_P+D0u#cVPDP`s*(xwU~c5 zkCSUREt0NZq?QY}uUTW#xBKGBQZWpQFG?PZ>Q2%;rdfaGE`dLswbXaly2-8Y3ANuh z2w>!UmGN*qJw6*ME!qFc&JHuce@N|hngjl(o`d5+ z`3_0*6$bf}Zdx0>sQ%Y_-Rs>2xSE?T~E4#gGW-8SN|7sp~Jh*w~G0* zaeDClCD&GN;ab)Gm*Wm3B}ImX`}5CQ<+q}9<7?0Djji)BIsD6OPe1k6LKra9GBZz( zj*d?G>RCi|&r;cR_B2`aj_*!|jkjRezAbO;GfXl4x8!JbmM-N2OUAZeIVnjK#G}bUgdM-ZGtQ*s{sxh zW+ZJ=1Ee6>&{(|_Ls`C?YaekEv(4Vc0>I4iYeU)|-cT+w97{Ai)^7cIrg_XXYQt(+ zLKFoGQVu_r)Qen%D)u=_cK#S9RWa zk7bytMxqRtInfd!q)^V>TkH$i=OOjY3LsoRqUysKi&5%va)t2aCaufN1T(>Lm>gz# zIeo&%jxU-!Iqvq(n)9jTZi9DK2^RO-uB2{_N72y-gcpLzqnnD`!ckh5oA+uea5?%H zRGt&ymKi$gvJnYAd;8;0e}mT+N6&aIaFQsKK&J7 z$GHsCjpVyw}3JXdLaUJbz*AAnFfB9)L;T%Kn#FJ78h1-_TP_o*eV zrB;(r_uMP*xz&)bW$j#K=dQ|E`DS37_+k`n2@}HqRnzy8h+aWVUdT4kqN}E~cVfHI zC(!5blaxV>!Z?GY3;DlRVH#-b_9+m~@Ii(N1Lo|*T`ZWsAwz(98^wy%dB-9~taeYN z>190c=(UjyIK;b4J>`!rav?|Y2B@ck1Ne(Xc-0{mB(4KL1A8u#O)!Z%KcNI^C zRPHBqYXb%(yg6Ff@ulh{tm;tcntRMFTM@i)NVJ*(l%UG{7A5FB)w3ZX1mW!$E1zyt z5$DuUvr$)a~@V95X-OLAKj*Gz-=!JMu_cd^y3$k^;_kH0wAqJVQxuxwRJ z?rch`m@^8K#FPsSnCc|QYaA^tJ&r4+&!@SuohB{FP-uV+O{E{ z_nBi;JJML}ru!In?*a>`WQ_h`QjWs0Ad|9_r*CGokCA>>B(@|)ku2K~iwsB_CF7af zi_W&0>1CX$xcwG?p+h;U)*g>k3A$3Z;29?1TrRQv&>#{H&(6M5Gt#xqfYnM4CuVyi-#ei944gQ9Mhsr1y9gzlGGB74B%4yGSWPisim z1quR{TU#>)wZ7<71`IZs!N^RUbc*O5?hHD)Yixc4zDENKb_ukjIST?91o~DTbisQBG>r~)PgeTG8&v|b}F70a1p2^EZhc+V^ zSq+QJu}OsSewJ1o+XH*>lz)lHmxZwS50ftD1B}u!(3(|==?pqi(Qxff9 zFY-{XyJ*jnfm{VOg=8Kfs(|{#A{RM%J%a&E4JosGJw6z)#CmAZPp$MXt;X9W_6t5L ztp*AKdq*V{AEDYn=}R%s_+hEStzoEcLg#Qh5oef8e;wm)ssADrXD3OxqUAzZo~~Bf z=FBmT7CyW22rg(gm7HUp403jpvYSYQk-zA&aiiC1ZS{96Mq$-N81CD+R9zKm1YQu{ zp>M(V)#DGM5**=xjMsFNEa6ss>83@y1FFmHF%Uweo-8SmOELRq!YGB~mC^hsc15ZpKPd9}OW z#*Q+uH*9R%Gh1j~IX`$3n0h%1S83aLzL8E#MvIt@L4Rh+1$Gp_dpX{pnybj7q&^z> zeG3;4@Ii8vD~llfkj1(2flzEEBq(WI@M21Or)m?jl}u11fm&T55y!a0VY>J-*%RnpM2} zuw=r~n-ET6o4fJ-&b0V+8_n=)WCF6c$UUeQPK;TI7ecqVrnyKk(C~u)yi(^rCN@re40G^%PpRmtyA?Kl}h1g8Y#1bKQ(Jhh1<a9An;2jmAFo}z6BiL8*AyQ6?dYPM2}V) z`Gz0J!vo0IZ(^BnfVJw;|8=N_2i8HI2L=}CLfFL#HO9_T~P7}ZFqw0 zG!^g|mRoyC6R!NT*->H;Lxr>qk*MJF(a3lVYLk;C+i?op8%UPSE-?o5-1WqkAGSILG^t)C ztlU+452u_wcYlf6fQ3_Rf7GZ_1;gH>D<sp9ojf|1tYyJ!vO!E!a($v zCsDufERVf!X?)xZj{$ps`PNWX+V>epVvhyxI5#W;yiji5ol1(Sdv3RcIsgcQS#l8L zN|h{SnI3`^e>4Sj82N!NlwQ3aO*-30jk< zjNr&$flsmaQ=)s2&2uVd`XK^W@3l{i8=oURQiOq$?ykLK=1~?6)ck^hTjrI*w9@s* z&gZynB(-gw`OfYv_LVSt5L(C)*y%nOE`mecb_ORBSTJC~-rAE8)&EU&-+8w-oxW#; zbuE$xVP94(oZ6V=Gcy&TpLjt`!7&#Pku8hVQX4#8KUA9dkK=c3g+KVKMQ^G@P8$m3 zoYSPb_o;Bd_QK8(k5{Gx$_M-Iip;) zn$Oo3byVIMu2$Q&T{fl&#S9}GE1rPf5>PtYH`%wPTN?>Yh)rixc9Wa1L%WcWXkx9Nup&kkV&Rp4_e|80P1l>1%I^1Jg+9bTA!AYszAfsbe36CL3(ld_;0 z;b1xlarW*b+y%zsK+l2m}N&DTx6I!ihzdQ8wCQ`P`5xANhLNg zQ%PRQCy(qGNFWhqluiC-{~D$_p9_t4A!iwtx>cBqZe}mr-RN|4AIqo2Jf^sAuA1VY z0{DRBE41jA2fQ^twarC;Exj+_HYL~739k;z)jtlG*dJ%TRgU0GBe?GU`Uu^X&U0^} zDqAEoKP8sZXlDob{E%`|t;O7Ep!i2gNpa;FPuKH-Z*{Ztri5*{Qf$d?vAU<@`D*km zhHu?*Z*T9;>w)F`%t076Q<=Lh>#Swjz~f1RkDqPu<-|v&Ipw^<>0jUV8lBkhkh}!U zs@7Jh#erqZp2KhF-y(JWr(ehdu|ELEcRLQ)R03cBi_Ja;{(29QjcN)|JgrDVg1J6v zs-a7yYu1|H8*kHBWC%KbuPbL2VNUk_%?vGpx)SfEYI=E=)xxuJ!NAf+wwmM3X+|>1 zXM_;EO2&VGQY2rr@}42!b=mtT{wXqG`W*Y#*$*4GJ2SAsWH)r-2qL<<{?tSMH~w1$ z!)*T*VGdfLU1fdfj}~uEZX(K{u`!x9vCnu$^5hNurFEcEYg-a;3wy)neGa_GO_7&^ zH$5f+;ow4qU=)_s{Z87RV4uDx@uV4=h&`2TCK|rUkkn{OGkDM4s7AzSlSJ}@Z(Z_F zB#YKN+%TcJ4P-DKz)+Bfc->TlC_9w~Xa@$#I%)v?22y861E1CtX?X_R7+NZ=?$cnr zR*n*i>JWzJ&2?FgJqA|y31&DG8uS6I|73n|xfXDh_#^wN?A-Y55JgXY@h4YXwI_xCN5DsLv=-DBuCQV9Ig7^s2np2P25H%Rw5rM? z;$tmuep{N-Nz!z|zhV>rX?*0142(l6PTy)|`InK%@)8a$@d5Vg_-^KF43<(zKf&Frp6h?uin-KJ?$y0qN$@v%6frnav9?1Qsf=$8p2oVG)xG3;viR%x%QuBC zsy=D?O$$FWy3RXzy@a3rV7{mPjRpu5=DXK0^6)aV`n3UT|CYHhwi4-!fc@KdD%qcN z`}gaun7otFM`N!-ujQE5LqQ=_3Zz z%-tWg*(>z+`4qi6`Z;`_4O674Z3}2CGl~jmdT<+=jw_?SFP8sFDs<1PQ*`b)cxP8z z@hr>BmXerR!HCE;j{0FUi1{TNmJBkGS3`NAPoL|lp1KAL)T+KR^9s)>@I2bYc=+`o zFo%`TQrqhkD%Lxx8tv3UcP^CzzME5d4*sLAh_G+ra?S>Zh$L553kdVZGW8cpth>3T z4AvvG0I{o*Pa20T=;6#qiQibH9~V-8_c$YeUH{JTmDPD^P`|)BvZDF%dqBPLJG=KT zvbB0M!g1NB<<4F%Y6hhe(Cs>X<#j(iIX*z`1VH@0Q=>#d0<)fqUoPp~zlLJr8ScfV zkvaNkbx})>;@xIY>aJNLAPcLDK97sFIae-FcrmJebeaBw@pW>X8-hlNBuH1b*Zf^e zq1ir5?RQ?^s>ohN`a)^*S#O2Kc+{wbkccomO93df+PnsC0IR=-|q? z>Xf1|sp$6hI(Oa%dxhS-HBr9S9*UnOtm^xtKPFFb-p;UTt>fQxn|M)vmB<{Rqil?ajw&BURHh)W5~3 z2$)&LjAKv)NJrHzal>_N8YX`r8?5U#Tm-1$Vc+T$;%LO^$mcUO`j%#SO{~5aO%_lC zB|x2kIx4(2{v!Ub&cYvZ_7T+tSe)vb zpAH)Jigsw{^H#0+d~O84TY|o$f5plsP-tL=VZT^>=o{?aP~Qjl4G$@-0O;IIx#`Dc z$}U9x%l%eG!hgU`Ew*@!9EnUaPp_1OV6ovd&fFon{(o(qby(co+U{qD0R|u3VQ}{X zrPu&POR?harKLb|C^onhcZyq~I24B#cW;Zk)8g)Mrtkjt+524Qn?EwSl3ZEIO0u%@ zJoo)u^baqm&^n)zA=4!SuV~O9SamgdWOkF*EgxlnP{k8*e998mA4AQhsUvvMuS`gk zjlaiOm7C3SoKJZ<(=|f$LIi+0Ou4a~XcxuSs%v5>`qT0^S-~BIwM38rm+Lz%P7QHX zU{NY<#4#$nte{+Y5Y+e?3fLn+g0Pk+WN_ahM@a(Q$0giZci}d}tvCT)7XX1q$kKm%dBP3*>PuE? zXIhvjmdN7-$r)$*y)f5sV>M(2pOukF|8RfU$fu#Q%EIAy+;Ff%l0?`&xm>YwC$E?B z`Nw;Fwo(LPCJN}$JVMg+K2*b6WWDSzQ;8;8I~Zhsgh9-)+_K~ZP;R^aNTSl8>c-`# zv0X%DecboN6B5~UCWIoWw29idHQ-l&x~yV%+?@pkxu?bB^5XdQHsjfyY*t7rt>;B9 zN4wLcuykVewkTphl{;m8avTPa@L>;hcbUI^*1{wZK6dnO1!pEp9%gHJ)4n{bryADZ zAy}!4?1cG=IUs7yM2~PRNt_7r^)blc%ZA9;m8w4hB_|O`?_+5j0BB34r`AfMKSA3L z%~4&M6;_1}dJn{XTr@t`mgZEZAu`F`+v*O+vyCw-dLz_AEP0Qm^W`KlnKCeB{VMOg z3-4T37dy9rbm8dQ4FTAPu~_1!v&Qtvk0j(MtTKz%hU^(h8;86!u-SZatUSZezPB8{{rKeMpzbO%YpyZ3JoV~t8ls43xA*>UpQr`8hU^o; z$Pk(o)T312t+l57vp$mvyhUfg-qXpL1m>3Zb(f*Q5xk(XwLnJR1v@4mHME9OIWBZ= z5{ty838zU=57$rs4<27*HSXnrfqa|n9SdMSka?yGYh0EK%sG=G8v2n9ldR6_g`4kA z@2-T}HJGiuM^t-YpKICtn^gF3(ybQ1^N;3o5x@D-=!M^Zi|%jc)1R8RX8Wn@tT?5U z|EUf(&>fcl)QOI9rT*!DGSA%1E|I9}4!AmMI4-r@;#O!d)25T-ERj=yfNA`prAuW5RO~_zc@B)|3}r!n>!FjKb1is;XnoURhP? z5sLhpKKQP^5+?DaS2ch#@p=5Sq&IuH#k1Pxs)fsDyA66p2T?+w16Sw-;Inm!1DqAJeO=RzcJWDe=xnqQNP&0I$vyB;*W4Pxj1r+Xc(>%?99A~g+J?5B4Y{A_0W!;*{PqmcXr+$ zt?QQCoho-O)h>6MuebZSXo0fZ5knZoVi=)BZRC1NY~Mk@e;Lqma88=s+!J9XW~{d^ zanWC15+(L(ASR^gX71VL>EUDVx0WlP(&z1sIcaTTsH13@-cJDjCB>obI?ZR$_C=bH z=jd%$5u<7J&UV{(QX~Kym3XaRCD?`@-`MIXjqmEkayE=umeBktcy{+@L>dfSg9KIY zOOpl@Xj7B*mfbz5;U!3t6k8+~vh9*tXjOeIE$e59bcnsCS)nNPeCYOc>hOb)2o8vw zG+8H-X9s;GUA*6R3(-!Y;UAOoz`l3fA_OTKAQSwoZ>Zh@0xaFV*Snc3LBcmF;n1K#l%%uc##Tf!f26*GqV&-Tn8#AZ`vgm&;U$PGaVs*#v^suWOq9(Q(ld>T_oPWw57J2g zf;o`tF;bND(*f5K8h-bUetay__S9)g8YG6% z-Di!&Jy05LrNg21s^b3pNpsV|ZAz3 z56j;sj21%qw>Kn6bTSqe3U^`5&C8asj3k;8T~z34q}F{*#+7TrWXCrlQ?=*QH&+oL z8WYk_UP9~9_c^*+CZ|_%Ta~jC&-$>wz4$~AAD07vsKVX1e5S+7np}2*>e(j0`v8gw zUm-;<(2BIDkAH9XkW+8Int6{Hg$_8vyO_=Wgfz!r`BXQpS|3UniZwlIr8;QksAY;1 zD~$u=l_R-Q|5_oyoc?m*d+O_^@ogL)Um1)D?H)Covi&!n!S)Y_-a}=J5c&5@%_aOO zmQ{DtJK~&MqKsswg~33JH{?Z5VvV{13ZaF$@Er9-Jmjw1ILZ1h%J_O?+S`NG_@84w zU1ty(_pf`a!}q?sGOsu&OuEbeHu)$&W6?> zvnsezYO3sRMX2HBK{NtF2ZP^REWBz`z(h52v^9F%Yg0ss&4A==+G-l)jJ!*MAU2H) z^_`bbf7;f3pq>1__;rmO<5%Oicr&j8jBjOhW&!|B!&Vigv6`bG29OQ3qW_!eO29>M zPl@&G79Q_atOKMuw9ZnFQRu_@q|V~W=1_UmQV=ebCN?>4>%eP6$oZ96Zh^n#UCd*3 ztUn)toWyBiOiS4w0Q-f4@_Qb!CS623rVgWyT*VSZ<|5~Dm2JF_=;$O1W1`f_D>C^3(+@MKx`Zc=krQ z?V8+GFwNxW`A16|`A;C6uR(gJ3~R1ND4>|%oWs?IKv63QOhA10kK<~V_ejxRq(yWO zl5otOW;rG9XYU=ZBp>DK^rb=NcWR@pe-{YC9Ei2Ff&9XC$f-FgVqx1E06<6kl--1jJw< zq*Cy(&4DlZM6$HdYEAVskF%Zvy?zKa~f$d#L=vYVZ9lneM1hn6RWj=k4pQSi|426xurIx@<_{$mDUxAr zZ}Hw-5ZkK9^Vpa?d<%pnc`GDNhZl4Ic7eEs?R;fy zr?vwqA9Y0G0Fn3-;x2Aoo7-ql7=zhU|HJjg0AY3vYI!45~)SqI<`A6eX2ivk3eWmYr*$d38z7ptX)t&$4R2?MG$Zty?~0yT)g4>WKY0;QCX zw?>?>@5foA%(tDM)1C@yUbSo4j|S*zM<2Or!Dfo7Byi3#$;aKNOtL`tQhyb3C|V40 z3Mu7T_lS0Y@JqMMdj5qo*^64?nfBvq1UU}@O2@w4U1zAJVw<6IeLK;l_~5gTPAQ`15uB^1T*-JG z2hVzvbrd0Rk%U#F8PfRix%(mNb5;#gNGD}p?Kp+-9 zXoWpphhYxZQ$pG$Teiae_^~h!{JV#vl7<-fX_Ht0o#@!_!-#s~NR2pL#Egos<|(Ev zw4>-OhZoVn-Dgl=ZqJp+)Y}g|9s3mu$0@q5Cz?2>kqaakU*KwU)f;}$4#T`4Xs@8_ zM9~OkfXDM7WNyC%iTW&%X0jP-RE>~$hS(hudaN;UY zj71X|)rv2xj@V_?Bk80*PSVXeI#SRSqu2Qk_%uNw8eV=eKxthBhJY>O=|IvwgH%pm z=L)Q!l0eIBblIw`fsl6}ejAWjlk z$8egU9%Ng-%4$4Xw>Dx+=}+QxXbGe8Ui;XNLRgTU4Xo*jM?uciH*EE)eA@V0E`k8;*aQfq<$?s z6_Q&0TET4JJ*?_p*|^FXWRYT>znxY31_UcHCd6j1hOONIO@4$%^TAE;h%X~_TFu)z zb5OQ9&}l+K?-Wn5c}L@sG0|Hx9`;1{H$!WWBslAa*RFn|a5xRR2Tm^vXq-S*fZ$l194C=S|i^BH$Y3vw-2XCcmf8N44(gY6mWcHuFV^V2|2^wUzwHFTe?;CY7(?v|V8plP+%ofmF3Md^;xG9MYxSlSKj3KoRfD z2a2eHppL9*n(;{kXgf{x11}st_;`*C@!WjoFqB$_dZHJwhPIns9vE;eQl5-+P-(5$ ze|vl;Y%!&I+2LioIHdah4Kc)9qr*e#X4>cF-)2KlcG8$}4G0V(7{uK7-o_|B#Y_kt zXxAL5dO<}Y0)~*okLa>H=z8*UuUN2L(PGIYHZgOjne>hIFpEp+SaUndeh6^|9dx8r`0?eWH{I2S{zmD?#XP4?{@5zwyB)?#eE?s#Esy zRU=Q6+EDGMh%t|lj*zmFS(50V8yg>bQ)bAreflOf_{66;D<<}}+vFBD`I%5=0Ma=HjJY@J=voKB3X*jY@v_Fa5?^KqfW5Jgo_@2L1V3J{l6njhnp znd#R->NJhYZ)BJss;_rZxwFdzU88tBk2tj5s&q|tv5+kzWoIq`MJbGqbCN^k7qEw& z-Vj7IP8y)Odd9KI+_bpwd-w)L4Y~u}VZngdYFfVyDqSSdr8x5;`+V53VM|k|yb9rK zoDM+%ZaKuo7uU#;VZaY4;H3|{Tn&~31Pz{F7oG@aEg|1rzid@s7dFYa-Q}bU_$70& zNo+lgrF=i&Zd#LOB5O5TqI;=C&+4uloMZY$_q0Q<;cW79p*iW#tH<-tV;=gq(^()N zS^raXXt5w3SK=lk)04%kHQ~k42Hyh$@OzMohM-N}sDN01F$kKiStSTN$^!WN9TGs> zKcp9f{pKzCxHN(hZ^cGkrj#erNYtZ&oIh#%hgQM>-p0-cj#Df9Aw^3rSmcfKy*20O zkMT*_5&Um@or_WMU=$z_BhkVl5<#BD*`}laPV(;cM|Qk-KId(b?m&w7_!p4aA#%HQ ze7}I{)o2FTb1*1=WV=KIRvo48d9;PxvL1}E}OncMDOLDwK8YvHucE)QZFBNWj{q(VKhy$Nz zU=b9@hYL+moi!YMSe?KiYqR(w#{Y$Y2pzIw77{wQcl#*kG^#m(ZoBx$#8=Bn=8Y*8 z{x^`Uwz4Xzwl@;Y$X@0cpZGdbkc@^sNf&yf=`6-+IsBS{fbE-evtoC&oUlL?KQFaE&KYWmjW#g>lQFOB;;MDv5NZx)-kz zXAuXn1G33G zi@83sp!Mx$bV>IHAPUcbz@f0D--KXd5FvyLm;Hl zm`%Li;sK!!N|@zdH++Edmb=oOHVGZ0uSlmk2tdkZY zo+~$D9IZXu;a|F*nifDHq)Yd&?GuSM`Pl+8L7&wOZk3p4C%x zHlj|XoOWeS=Tb!z11i*p3Zv8|#tbR>6Z>EJk}=t*6jG25Is{JT>yw92k2PObayma*LGdK-zoCLK^=3BBgK5CjhO1vgUh+;WAShEEYxuEVZ^cY{ ziP#sx_MzS9~LdJP1rC6|BHXZa_a()kQSLkV(;`Qf({A?dr8WZ4*)L0Kw9y+wTUj836CFsITTuH1lD!iZ z3&n#NdZ+RG>r6KGJ>KdG8&tj?!aIPoq ze~JQyw9d&z96HKbZp0A5?kQi}SIcGpC*1+&@LJ7%dbYcp>gxbSt@^ZSf;}5?`wxX_P z%Jdp>!rbD-Rl}F>t)nVyq2i-1L}rMCF!(tMeC3TNq;)ntv>j{95&fxhF$^X!;6Yik znZ+FwfPIV@_$Xmzg&G6F1}^jja-Gq4QKIyCEwMb#MpA_ex7iL#tO5{N-YWGz3oBU6 zCb@!s?N>7@R(q1{S%Dder9Yxs_Zg2%<1Q)b688bXiF95xOJ?(J46KE#AHqr7rfoo0 zB>Lh9tsKh+XeXIr?3oyUzfY}6ZoX_yt&HtXkYm7mAOL9jq;n>An|G$b5=Uq@GWNO0 zaV}EgJC4wy8+*I5^<8y|_Q32AFqIN6$a{FF93e z3(*@=7U13Utjk2NO>A?WO$(P*2{m36W7aarvO^m9!bA0)(VazUF;D?7jQ4zQjH2xj z7X}@aLo7`jdzIg=k+$t9{J|nSTKmY;oW!BiJUBRLtVPbN_VP))fa#J}N~7pOo76rd znZtb#UUvPo&a&9@qRaH8_RZzAr0mz@W)5IYWFYq={$z^nc3e&2UnTpA zJbI<{$EDeH85lNs<0#p$Pel)U!@fyG=9|zR>wW;Y6>prY>f=W+0<5w}zh{v3fyJh&8jiGmS) z1gqi?q3~*Of`t91ZydgvF~L%sVIjKJoA`rjk!bmi>GWa4R>CZt#Qnu}g$Bv?O^Fi| zeFj(Qa0;qDwjdftu}bEfP72ns=TxkUp5{swskqod?;c1OPq)>P9iNX*nJhFCOG!k` zQR5=dHwooOzDtQfx6)9_K6=OMfJ&81fP7vXgPyumpk8A7`*ImH`)UH2#R`7drR3ZJ zYbfB1Wdk@w7S216gA>>%Et`#?RV0AKlx9qE>jg(xl@}*i0sRq-v8V~$?(3D*wn(fCw=f|6XL_#^ zH$CbwxaNfp%v*{bcrt^$dLJM5HC7ftV2L+(m=5Li{=Zg5&`?FZ)b9F*zb$SK5k@&v z1ZNrwqb6+YUuzx&F7KxpczMBBN+*O`HS&)mS-TJjg#fvgQ5E2u1zCp`5E>M@x`n#G|Tm0)|?|9Pw&kIP<8DvPw(hIe7Oe ziQ*A+ootB5et{BuOaKQ!w>sabPN4`IGG10TF{P$>G%Q_Kom8nW7ksv%eA^z!+(Ut; zNmz{8E5s2j^aI|Z;povxDVCYN(l*w|^-1ws@sahKhpV3)`)Kv%`{Os1iwRhR2_&UY z7_Z|YeFpd4k6MymBR`qtEmA*Z0)U>B_Fn6K)Ir$bLhh8uofxhRelU2Y8UQkz?Rc3k z)YS8lR8;KjgMr&Pa}KRwpY7uCi_cBVkGt|nadNcN>^UL%VxoGMNZ*lp> z(>C9iT4>2F8$|5>o>`PX#vTv6{)UDR-~6H9#)9z@{=HV3r@}}SERGTSQGsksDr#Wr z`Gp90D^>dC!lf@;mVqX+MXr324|zmVspW4bODv(bGO5ER5omBRazvpJzDg-isF-bqrEsGf52OxF%d zQqQGclOev#c$SDB*~SG^<24?j0)mb0aUkHi%%JbeU**)K@~XEQ$@Vda8q^qobT0-X zLR3vmxdU2~3NK^hsolU3Wm2aYEnw+H^7MCy-)*h#RZ}r+_SgdyWD_i z$Hp)Pff*4{eQ7c@!5A4h>~;5Z;nV0*An*idrCgn{X>%S9n)@R!4lW@|~eR()cNc``5?& z`OoblK*$F6E3yf##(Khf7RPZQj7Va1*)WP5%Z%2y zsw0gZ)H9@)Kz`-WrqM6z8kn`3HTFu}1)!4nhPsj>0LTi~#yJ65?jicRn`kwnDG?Xf z*^kkQvxb?jJnW8#W8f*8IC_290~6^1W#Y!mv}@r(+oAXq#i<;zW1CH0vWjj;1hH#L zz4;y7xtk%f+m^K=JrPc3d-2}$4N{i=)1O0f6%%B-8hZ3%aI`aBBpWXxCS?GJR<#BL zbG8!;3dZf-|y#ThuRF{oYS+H8^2b|Zjw{(L{rGC^C5R{WBHTD8CDq1cj8 znz>9V5TW5?V-gBiSJhd{rR01=O`Lk9248{!_kGD(BTzl4Bq>!6~E}rTZ z)d!p!<6sIbvuM`a{&$F{HT8{A@mQBbrP0qPuQ82aX$)|pc435g7Wy8`iN>l{`^}zK z7`8DVBg(J_WQTQgfxOgD+fL!KJqE%61A}HyV>>Y*96(D`V7`dQ< zMw?yb{Wwm14p64%JN}2Ww8mgP3~WbILIG=*&xu7&0o^7V;y@{p{FaZ%^%} zCohOs_$)icgk@<6kph)W5DfE0AVxibkX&hGwn9;?e;+Em79D&9?WYvzveOY;W8RE_ zt6^|5Q6w0GEJ$~YC4g=LvHq25I;gi9CqZ>JJ7Dq_^nMCKg7i#K zFm`_gzm+GApN= z(xG(oAIyI3qZV}=4jB^{|5mnVsvpsE5FKoPa5ro3V%ca}mvB(Gz2wFtMrWoq308RL zGW2cGJ2QRL_c*X zx%(NvbOC^;)2qS@UCWJQDOg9af|!Cz*0e^KuC8j0F5CBoW2BXqdx?>#dys^EtARn) zQQFQf0zrvHT@UU-)=gbDzZYrJi7ybwa4U|E()yk3YRB*BVqS<%M>fK8^#gV8a26KE zJpDm_I{!Xd9Sl;EY?W~Fc=WDI*3t!t0$m{=lGUqsU9_8JDz?D|i=&?1S7g_%u?U`E zTOy2ignb1#!G#f2R}@qBPV5uHBGwRK_YUAFma8ZIT((KRHkz$_=F?_$YdeDRit2Lp+F#V~+lBHwZ#f2kh=@$jI`beQx4Acd8ekoC4UK&j zn|&19PxMq~U@K@tlhP|mj1uTyQ!Cj-t3QdkHzD_Y<||$GC4cSmX`e~SH^G?;|6>E3 zvz!xIvkf{bKHF}_D9=yQmU3y{-L1fiT9HWO@yKl@w~FdJNR-A2P;`bx)48*y{i^1I zO@xefe#k?Y7QrEQ5l|KBIdOmCe_^n~$EQFSN2W95aMq*)qbAN!*8a(P)Smw2O?=B< z%@8(%hn>AfqpihlpewijqL%-m%a$;KU}2^8oqNX~oBhJ`;OAQfEg!T9inV8#yU-(g z9GG@BHT9zX-)G)CAf?fH$cWI5f6d=ED@TZf+_IW1HaPXiGs{~%iM0o!&YZ0hTb1UYwdoaDGD$xp9ogsnaYIKziuP{oXQtu>aK;1(P7f>5*0~Sjk zPu=#8{kLARC(_=k7J6?3=+E+a?oD+sC{&?JVg&V4g+Yt#K-oQ3`y3aW1CLXnDUvF>MVBxeKg3Xhn>wwDsTUv+24;|5;eeSi7@Vzd(ij@o9H^_1yI# z@51(DY7i=ir^4^Ltzsw4L@$(jqb|9X5 zBnAtV;iserD&JYn$|>%ptpqdc4$D0N!P`c}R@T_{iU427O$-9WAAVM`EX3@Cmbx@c zJkG`{IOMHHAZmzmo*T_F8B<<1M4i#%>Sa;|&9 zZ)G6)Do2)S>iH%A(ys-4=C)rizD&NXcBQZ!tabwbzK*V#p?Jeh-?E6#Q}}Z3jTfKL zl~CH@WVp|;K5Uz;{A!_h@}0Kt1;*eL{=ldg+2~#(hFw$QGYhf~VruWiCSpc*HFj09 zsecr?3S5vnL#BhabHvX&S*5cW@6F7}Mn+Ct+FR%;Xga!9pL#6TEa%9Z8k(Cp>-o}w zry8*;#iY+?EC67StvKaaACI{d1(kq~kY=>?hAw$rE$-~MI>y>o#y}6O3>Dp#H!)+v zM{)l=&t^>w+x)N`lw{js!=9rd*Nh)BiQOD=o783&k%>lYXGlb3C#t$QH9QA?VE()2 zsc912Otd0ZT+NAdZ(zd7o-)xiij0pFE3p%p+Af zyUrSm+WWQh_tT~ElV~oKr6|YSiy&|!d7BcXtw)L7KBoIaw*kNERUFf&_#xVR{H1oP zAuAjRDp9IPq*pQlS-cj7l~-H*f|=DDXce5iSWb^aCF>o3flma%VPtFym^;65$G;IT zz2wK!Jidxz-8avM=@5XtZ!%G)hSw*F-9^tgZ=x|Li}HZ&xZFuBmRgYDG&r4u(@*>B zJS*ML8;sgq&~n(TN);?Fq_oi4^ESp2<5F_DiU8Bp78ut$If zYT9N#Nx^j(vg*{sh#eH!zm-+u2q@zfvU&bR3P9?lZG*VD2}swplU^e0dy>s7)!d+PSQ&qn_qCIIvlY6X%r5#Q*xqa9!)0s@g)lqkYNqg#`>u|iBSSB?`&VKm zwWn`WMV*Rg?l(kL8wC&T-hcT`Kytsy_MSw2B?AD?A;pY+AS@f<%P++$3=kk@iVid$ zo0ar>=AHO@Uaa!9GG6V)ytkbDs;t*Uy$8q9QUrVC8tRme0cy>NfY~cMKXm7h7mL3= zI&k?z6jAucS_x*eW6aPVy1FLkSpc35uSFF5oFRvnummZX8(-%o!K zv-8?^=6`MGC zh&7(WW1U6d3ehck{<&_TRlSv%i}ClGGtP`2ntJY)Vy#>~jb+f%=vs$&E}=6&)_Fbq zdg2hVNOosR{f=vIB4^~iYVYFIZ3>0<*BcniSPpoC6ri+(qR9X$d3yf+&0_%)w(=KZ zm8Djiekq6Kz8!A7m+F_yS44H~N6h7`MW_38^;7`Q7;wVqFLe5nxPDjSr z(v=kb2aFSe(_;ZpMZE1{!}M*?h_%>Wc;kX129w}1@_E8a{>ofG#M5DK{1dIFLo?08+R_Jr3w&ue@x1Z*3jTRO_&RowDhA;vo=wmI(j6q@#6W;HCs~e? z7XBiUmsKlgw3gCObyuSAyYL1}&KinUQ-5)Wh)eB$rd^)a@sxXh@?A~=eHPxV({w>3 zDaKa-M%9xE_uvIx;kKJ>k{@xO?}I+teSfiC85C z_4VrIv7TDs=?ppj_>~hmcJf{^nW<2>I@N30Pfo8ag~Fn!mB`u34#Ol@IhQHmm&8E& z`!Ah>G)@d)!@UoOiVaBNP3<9+9(yWmZ|~iZi}w(h(u}Uw=915)(d8gVWuw(l@@%6@ zUxb>@tHaMo#$GN;im`8Q>Ev>s(x7I%ni*qYlB|9>TDI4nR)g<3iH>oJhq=}Bi zQZf-NAn?^$;Sv6e;B?=IppS*)el}A+oa5CqHDuywtoTEkR%zc92QMKn&H`$D-i>{D zHS=mxrD<)sSluw!gNyTr?of4(YT{%T=hq&MfJ-(JJe}5Ck^?u!v|Q#}(;l}3T{JAG zPivUf7i&s0tSMIv=}TG!X{3TKO|=+Fy;12N9b~Ya%X051i9mc_G@?gB3Km4WIuLXw zdOx+?a2;2EaTFp9Hq`vYuZZT^3Tq78mN2fBkFZK(GY{+=6GDBWGi5yYr2RR1Jrkj3 z$V$GbcB#aHGg<&Podf)dKuuG|Iz76K&T?ZT{u)9U6(9>u(JfR0ITsfAcGj#Xtfr+Z z5Zzh!IBLAL`PC!LitGHflXdBd6|GLs-LZ4o9#Iyg(X=x|HB4nZnm=ruVl(M!`%EF9 zbM6tYdh5fuV#=p;%9Lm3n**Pel_k6oe1tzua@f%mwZRDgYeEhM0*;-JCqBBE+*5w7 zylY0{ztKO-&31OaQPO>qk zNn5+DdV?kSpf}~0XQ<#v+}*O8YV+Ki!A?UKbQmD#DHsIM6gapC;mNU80&`LKczVU& ztJPc_A}t_y(RvTS!T$Hu0MPZELt;?pz0mvcAmhYmW$GCl+`)jHeiWKx9}1rVu9L9F z@e48gsJ+SNLHg1-Y$SX2Gn$PtPGEWcDb5MiwVLTL|IiDBf!${W1p!A~LHIqqhQrXI zS~7R9sIahU-o9mIBu${toK)C;VMn`Mf3yDGtoaj3YB=J#(eJc3_IusxfBg-@F^HgU zsptav^SX2Ut~tBENSU{;v7XCF+1+bO)KLTY$~%Ty+L-^r2DW=D{sX70$x1@N-(}^* zw8!Mk=NxK~pB!3rv_MH8qIG{x?vYizGh9!G~$Y&b5|hO zrf1?G+bv|8>-e*L&}lc)TPXr=w%;}2h3U2pbL@zs$<+t&NoxO)W4~^{Y4@I&~OSVZIg0}leDov@A!%x%GW2J z-=J?K)KEoxFI3~kJ2oQ|8R|nQk&kzVJ=ho(cf04@BQ!|Jq-7PX!ipzD9U)X5J}j@( zB3SDlNXzBL)i_OKMx&00c@VMK_4M7aBhC!YjhVAfw$S5D`UzvK&d2X8D5w;%MAa$- zIr?kN>l9eiQ**2LJFk&48m})t^Aq}cXQyMF7!%upuBKE)eo}sOloB;?tJoUiKHb&9 z7_H{Hw>`kVEw7vVD-to(n}0w*wh=cM|6*o}p-L$I%_vHixiJ#_uF(pz1>Xvg^Ft}2 z5kZNt7smN~sWqHTh4~+EuR^WJ3OO_b)U`WB07R+u#CGix2^^9)CpxL>-e)db$)I{aX_gGkFdGfyDRf8r1yii$ULYfjWPtX_Ab_ zHIs}?=d5D{yiEozaUP;btS`NP$6C=n=_<(lb*0w^l}qsn(XYhU86CQ5ra4b7thUl% zzoD3KtL(>9ydk<}xsC~NLe3+uTKimL3p}1zyj(&rmE0Dr#=g+HS{|aE$_-4>Otu2? zKP8$*2(ErJUCdvXbv)QH_p4H=M>YO;{0%=2 z1U!XdcSDAaqk}0bM}Vm+LEh`Ee#d+;(>3s-qiy-YYOuDqH+XHj^2tuGi$N5+)%WZj zqO<&|@)&#Uy~u?;aROAdCshJJEH0mg9~kWu!UMnBzFSO}@*r&o*p3+s12*=qC_=hU zktD;pzoqXhtS$c=GW2fQz*xP@N266HG^Put{*roY<6^92C$OuN(edHqzPh4+f4l z`RD&uItHwLoep4nE%D4|tnELv%p>)GecIKD|Nnqgehb<9<5+?~`Ku%T)E%b^BjV3R&IM(4PM~nDLi?t1mt1q~Slc@-IN_e@`=L zP|;Z3#){6w#VKxz{sTY#PeuG|ZdBxN>^#GOU()pdUbBA#YXAN3|FZ}gsZz-f`HuR} zHvW%o)S?Pn(6IHV50$cgkWSh17CH3Tsq#fP6bGo3REzc!43l&fNBYe!bJz~Z?lXb0 ztb-ZE)@d8afb+96RWLCS`=CQti$CHe~<3@b79LAPM*k=L-S=g24W3 zf^Y>P34EmFI1K-_@b5M`JnaF9?{vif+4aBXs#FlDz+L)$v;QjepEYNwy3ldq0?_}v ze*kC-<4zwsv+qU_lKX@Lha4Mi?WxM@NA`TVRVf^CvzEm{>#uRvU)j1=)tVP8ax;G< zM*~E5caogB$rIOY%!z9R`H1lk&aJmPz4-)E@{Hmv)T`e{$K)wY?Yauh+&6un-qjMQ z0_Jx+a+Xdi#WThYZPI6|$jjx&)y~_YH0Pso0naa*P)qHRaWfAw-}&3wu~v%EE-9{* z7j?Rvzka*iloc1sH&xsoo%t;PD9zay^KagKw?}4*YUbm?HSwtiWvYOu@*@B{5#udj#we0yvqymjue3WDaxumuaGtk F_&+v>&R+lk literal 0 HcmV?d00001 From b636abf70f0eeb7ad3d89c21ceb4ffd0d216fd2f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 1 Apr 2024 15:13:50 -0600 Subject: [PATCH 140/240] Updated ElectricalDesign doc to have correct mpt and shunt cost names --- docs/source/phases/design/doc_ElectricalDesign.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/phases/design/doc_ElectricalDesign.rst b/docs/source/phases/design/doc_ElectricalDesign.rst index 14519f88..5f038d95 100644 --- a/docs/source/phases/design/doc_ElectricalDesign.rst +++ b/docs/source/phases/design/doc_ElectricalDesign.rst @@ -55,7 +55,7 @@ windfarm's capacity by the number of MPTs. MPTs are only required if the export cables are HVAC. The default cost of the MPT is $2.87m per HVAC cable. Therefore, the total MPT cost is proportional to the number of cables. Note: Previous versions may have used curve-fits to calculate total MPT cost based on the windfarm's capacity. The MPT unit cost ($/cable) can -be ovewritten by the user by setting (``mpt_cost``) to the desired cost. If the export cables +be ovewritten by the user by setting (``mpt_unit_cost``) to the desired cost. If the export cables are HVDC, then the cost of power transformers will be $0. Number of Shunt Reactors, Reactive Power Compensation, and Cost @@ -65,7 +65,7 @@ required based on the distance of the substation to shore. This model assumes one shunt reactor for each HVAC export cable. An HVDC export systems do not require reactive power compensation. The default cost rate of the shunt reactors is $10k per HVAC cable. The total cost is proportional to the number of cables multipled by a cable-specific compensation factor. The default cost rate -can be overwritten by the user by setting (``shunt_reactor_rate``) to the desired cost. The shunt +can be overwritten by the user by setting (``shunt_unit_cost``) to the desired cost. The shunt reactor cost is $0 for HVDC systems. Number of Required Switchgears and Cost From 65c4b7c411b8e7cd735b48ff68bcd5dbe65e291a Mon Sep 17 00:00:00 2001 From: dmulash Date: Tue, 23 Apr 2024 15:17:42 -0600 Subject: [PATCH 141/240] Added 22MW yaml file --- library/turbines/22MW_generic.yaml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 library/turbines/22MW_generic.yaml diff --git a/library/turbines/22MW_generic.yaml b/library/turbines/22MW_generic.yaml new file mode 100644 index 00000000..7e6639e5 --- /dev/null +++ b/library/turbines/22MW_generic.yaml @@ -0,0 +1,22 @@ +# Most Data comes from IEA Wind 22-MW Reference Turbine (IEA-22MW-RWT) +blade: + deck_space: 744.12 # m^2 [IEA-22MW-RWT Value] assuming area = blade length * max chord * 0.75 (assume 25% overhang) = 137.8 * 7.2 * 0.75 + length: 137.8 # m tonnes [IEA-22MW-RWT Value] + type: Blade + mass: 82.301 # tonnes [IEA-22MW-RWT Value] +hub_height: 170 # m [IEA-22MW-RWT Value] +nacelle: + deck_space: 198 # m^2 [IEA-22MW-RWT Value] "The outer dimenesions of the nacelle are estimated equal to 18 m in length, 11 m in width, and 11 m in height" area = 18 * 11 + type: Nacelle + mass: 941.2 # tonnes [IEA-22MW-RWT Value] Nacelle assembly mass + Hub system mass = 120.0 + 821.2 +name: 22MW_generic +rated_windspeed: 11.00 # m/s [IEA-22MW-RWT Value] +rotor_diameter: 284 # m [IEA-22MW-RWT Value] +tower: + deck_space: 78.54 # m^2 [IEA-22MW-RWT Value] and assuming erected tower, deck space = tower base = pi * max outer tower diameter^2 /4 = pi * 10^2 / 4 + sections: 3 # guess + type: Tower + length: 164.4 # m [IEA-22MW-RWT Value] Hub height - Vertical distance between tower top and hub center + mass: 1574 # tonnes [IEA-22MW-RWT Value] +turbine_rating: 22 # MW + From d845f0d411635a1b1b5c75a15cd449545938aff0 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 10:45:47 -0600 Subject: [PATCH 142/240] Added a test to make sure 22MW generic is different that a baseline config. --- .../config/turbine_install_22mw_generic.yaml | 10 ++++++ .../turbine_install/test_turbine_install.py | 35 +++++++++++++++++++ 2 files changed, 45 insertions(+) create mode 100644 tests/data/library/project/config/turbine_install_22mw_generic.yaml diff --git a/tests/data/library/project/config/turbine_install_22mw_generic.yaml b/tests/data/library/project/config/turbine_install_22mw_generic.yaml new file mode 100644 index 00000000..25fbf83b --- /dev/null +++ b/tests/data/library/project/config/turbine_install_22mw_generic.yaml @@ -0,0 +1,10 @@ +plant: + num_turbines: 50 +port: + monthly_rate: 100000 + num_cranes: 1 +site: + depth: 40 + distance: 50 +turbine: 22MW_generic +wtiv: test_wtiv diff --git a/tests/phases/install/turbine_install/test_turbine_install.py b/tests/phases/install/turbine_install/test_turbine_install.py index aac2de9f..1124a792 100644 --- a/tests/phases/install/turbine_install/test_turbine_install.py +++ b/tests/phases/install/turbine_install/test_turbine_install.py @@ -26,6 +26,8 @@ config_wtiv_multi_feeder["num_feeders"] = 2 floating = extract_library_specs("config", "floating_turbine_install_feeder") +config_22mw = extract_library_specs("config", "turbine_install_22mw_generic") + @pytest.mark.parametrize( "config", @@ -250,3 +252,36 @@ def test_multiple_tower_sections(): vl = vl.assign(shift=(vl["time"] - vl["time"].shift(1))) assert (vl["shift"] - vl["duration"]).abs().max() < 1e-9 + + +def test_large_turbine_installation(): + """Test a library extracted 22MW turbine differs from the + project test config""" + + sim = TurbineInstallation(config_wtiv) + sim.run() + + sim_22 = TurbineInstallation(config_22mw) + sim_22.run() + + def count_component(list, component): + + return sum(1 for i in list if i == component) + + assert sim.config != sim_22.config + assert sim.capex_category == sim_22.capex_category + + assert sim.installation_capex < sim_22.installation_capex + assert sim.total_phase_time != sim_22.total_phase_time + + # sim has 1 Nacelle, 3 Blades, and 1 TowerSection + # sim_22 has 1 Nacelle, 3 Blades, and 3 TowerSections + assert count_component(sim.component_list, "Blade") == count_component( + sim_22.component_list, "Blade" + ) + assert count_component(sim.component_list, "Nacelle") == count_component( + sim_22.component_list, "Nacelle" + ) + assert count_component( + sim.component_list, "TowerSection" + ) < count_component(sim_22.component_list, "TowerSection") From 715ee1bbb4dd041ff542b66d41434da0b10df2c6 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 14:25:33 -0600 Subject: [PATCH 143/240] Changed tests.yml to remove 3.7 and added 3.9. 3.7 is not supported in macOS anymore. --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index f29cdfb6..e36c3ece 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,7 +12,7 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.8] + python-version: [3.8, 3.9] steps: - uses: actions/checkout@v4 From 9ad4454be66893c3b38c8c8c8efdb2c38180bf68 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 14:54:23 -0600 Subject: [PATCH 144/240] Updated yml github workflows to python=3.10+, exclude older version for latest macos. --- .github/workflows/gh_pages.yml | 2 +- .github/workflows/publish-to-pypi.yml | 4 ++-- .github/workflows/tests.yml | 5 ++++- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index cd0f8c1f..f19310e0 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -12,7 +12,7 @@ jobs: - name: select python version uses: actions/setup-python@v4 with: - python-version: '3.8' + python-version: '3.11' - name: install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index 30b1b9e2..c66cd240 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -7,10 +7,10 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - name: Set up Python 3.7 + - name: Set up Python 3.11 uses: actions/setup-python@v4 with: - python-version: 3.7 + python-version: 3.11 - name: Install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index f29cdfb6..472aaff7 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,7 +12,10 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.8] + python-version: [3.7, 3.11, 3.12] + exclude: + - os: macos-latest + python-version: 3.7 steps: - uses: actions/checkout@v4 From ec2ee112592aab19eb65874d651a654f799e215a Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 15:03:25 -0600 Subject: [PATCH 145/240] added exclusion for ubuntu and 3.12 --- .github/workflows/tests.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 472aaff7..ff8ec742 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -16,6 +16,8 @@ jobs: exclude: - os: macos-latest python-version: 3.7 + - os: ubuntu-latest + python-version: 3.12 steps: - uses: actions/checkout@v4 From 8618194068a7661fbef6db5fdba31c4cc0a99a3d Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 15:20:06 -0600 Subject: [PATCH 146/240] changed highest version to 3.11 --- .github/workflows/tests.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index ff8ec742..a01b010b 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,12 +12,10 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.11, 3.12] + python-version: [3.7, 3.10, 3.11] exclude: - os: macos-latest python-version: 3.7 - - os: ubuntu-latest - python-version: 3.12 steps: - uses: actions/checkout@v4 From 1543f2744296b466dc7e62cc60d3b5b24f11bf85 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 24 Apr 2024 15:22:35 -0600 Subject: [PATCH 147/240] changed 3.10 to 3.10.0 to see if 3.1 isn't falsely chosen --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index a01b010b..dcfa38f4 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,7 +12,7 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.10, 3.11] + python-version: [3.7, 3.10.0, 3.11] exclude: - os: macos-latest python-version: 3.7 From a9a34be0d77ac8918a98956deedf80031a14c472 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 25 Apr 2024 10:16:19 -0600 Subject: [PATCH 148/240] adjusted py versions to 3.8 for pages/pypi --- .github/workflows/gh_pages.yml | 2 +- .github/workflows/publish-to-pypi.yml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index f19310e0..cd0f8c1f 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -12,7 +12,7 @@ jobs: - name: select python version uses: actions/setup-python@v4 with: - python-version: '3.11' + python-version: '3.8' - name: install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index c66cd240..a96a4b59 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -7,10 +7,10 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - name: Set up Python 3.11 + - name: Set up Python 3.8 uses: actions/setup-python@v4 with: - python-version: 3.11 + python-version: 3.8 - name: Install dependencies run: | python -m pip install --upgrade pip From b4866580f2c8de3ba09b3d872a074828d03af8e3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 25 Apr 2024 10:21:53 -0600 Subject: [PATCH 149/240] Updating README and setups to reflect python 3.8 --- .github/workflows/tests.yml | 4 ++-- README.rst | 2 +- readthedocs.yaml | 2 +- setup.py | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index dcfa38f4..44de923c 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,10 +12,10 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.10.0, 3.11] + python-version: [3.7, 3.8, 3.11] exclude: - os: macos-latest - python-version: 3.7 + python-version: [3.7, 3.8] steps: - uses: actions/checkout@v4 diff --git a/README.rst b/README.rst index bb4df5de..a97faaec 100644 --- a/README.rst +++ b/README.rst @@ -44,7 +44,7 @@ Instructions .. code-block:: console - conda create -n python=3.7 --no-default-packages + conda create -n python=3.8 --no-default-packages To activate/deactivate the environment, use the following commands. diff --git a/readthedocs.yaml b/readthedocs.yaml index 0c29499c..d504aed5 100644 --- a/readthedocs.yaml +++ b/readthedocs.yaml @@ -2,7 +2,7 @@ version: 2 sphinx: configuration: docs/conf.py python: - version: 3.7 + version: 3.8 install: - method: pip path: . diff --git a/setup.py b/setup.py index c7d875e3..2a36c14c 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ long_description=long_description, classifiers=[ "Development Status :: 4 - Beta", - "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", ], packages=find_packages( exclude=["*.tests", "*.tests.*", "tests.*", "tests"] From a6ea8445a8fc7430f41ce208ee001b678eae5249 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 25 Apr 2024 10:24:30 -0600 Subject: [PATCH 150/240] Adjusted exclude for macos-latest --- .github/workflows/tests.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 44de923c..6afc4c84 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -15,7 +15,9 @@ jobs: python-version: [3.7, 3.8, 3.11] exclude: - os: macos-latest - python-version: [3.7, 3.8] + python-version: 3.7 + - os: macos-latest + python-version: 3.8 steps: - uses: actions/checkout@v4 From 3d566a75e1a51ff150735922b0729206894221ec Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 09:04:02 -0600 Subject: [PATCH 151/240] Advancing gh pages, pypi and tests to 3.10 --- .github/workflows/gh_pages.yml | 2 +- .github/workflows/publish-to-pypi.yml | 4 ++-- .github/workflows/tests.yml | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/gh_pages.yml b/.github/workflows/gh_pages.yml index cd0f8c1f..6940eafc 100644 --- a/.github/workflows/gh_pages.yml +++ b/.github/workflows/gh_pages.yml @@ -12,7 +12,7 @@ jobs: - name: select python version uses: actions/setup-python@v4 with: - python-version: '3.8' + python-version: '3.10' - name: install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index a96a4b59..663128a3 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -7,10 +7,10 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - name: Set up Python 3.8 + - name: Set up Python 3.10 uses: actions/setup-python@v4 with: - python-version: 3.8 + python-version: 3.10 - name: Install dependencies run: | python -m pip install --upgrade pip diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 6afc4c84..abb8df56 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,12 +12,12 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.7, 3.8, 3.11] + python-version: [3.9, 3.10, 3.11] exclude: - os: macos-latest - python-version: 3.7 + python-version: 3.9 - os: macos-latest - python-version: 3.8 + python-version: 3.10 steps: - uses: actions/checkout@v4 From 68dccff22dad7bf26ca6ae858ee6a5afe6a687dc Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 09:06:16 -0600 Subject: [PATCH 152/240] Changed tests py versions to string for yaml parsing to work properly. --- .github/workflows/tests.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index abb8df56..e0aa614d 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -12,12 +12,12 @@ jobs: max-parallel: 3 matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: [3.9, 3.10, 3.11] + python-version: ['3.9', '3.10', '3.11'] exclude: - os: macos-latest - python-version: 3.9 + python-version: '3.9' - os: macos-latest - python-version: 3.10 + python-version: '3.10' steps: - uses: actions/checkout@v4 From 924c5fe246469f4eaefb9fc48c36abc0962acd76 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 09:12:02 -0600 Subject: [PATCH 153/240] updated readme and setup for py=3.10 --- README.rst | 2 +- setup.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/README.rst b/README.rst index a97faaec..088cf0ef 100644 --- a/README.rst +++ b/README.rst @@ -44,7 +44,7 @@ Instructions .. code-block:: console - conda create -n python=3.8 --no-default-packages + conda create -n python=3.10 --no-default-packages To activate/deactivate the environment, use the following commands. diff --git a/setup.py b/setup.py index 2a36c14c..018369f6 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,7 @@ long_description=long_description, classifiers=[ "Development Status :: 4 - Beta", - "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.10", ], packages=find_packages( exclude=["*.tests", "*.tests.*", "tests.*", "tests"] From aadf1fdfc3728c0bae83fddcb74d0f2f35cd0cc0 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 13:10:48 -0600 Subject: [PATCH 154/240] updated setup classifier with all py versions --- setup.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/setup.py b/setup.py index 018369f6..2dc99f4b 100644 --- a/setup.py +++ b/setup.py @@ -20,7 +20,9 @@ long_description=long_description, classifiers=[ "Development Status :: 4 - Beta", + "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", ], packages=find_packages( exclude=["*.tests", "*.tests.*", "tests.*", "tests"] From 444593920eff246e0d0211f66dd09425edc2c8cb Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 14:55:08 -0600 Subject: [PATCH 155/240] Fixed monopile thickness bug. Had to double value in mass assertion --- ORBIT/phases/design/monopile_design.py | 14 +++++++------- tests/phases/design/test_monopile_design.py | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index ab1e5349..25473fff 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -230,7 +230,7 @@ def design_transition_piece(self, D_p, t_p, **kwargs): "diameter": D_tp, "mass": m_tp, "length": L_tp, - "deck_space": D_tp ** 2, + "deck_space": D_tp**2, "unit_cost": m_tp * self.tp_steel_cost, } @@ -355,7 +355,7 @@ def pile_mass(Dp, tp, Lt, **kwargs): """ density = kwargs.get("monopile_density", 7860) # kg/m3 - volume = (pi / 4) * (Dp ** 2 - (Dp - tp) ** 2) * Lt + volume = (pi / 4) * (Dp**2 - (Dp - 2 * tp) ** 2) * Lt mass = density * volume / 907.185 return mass @@ -482,7 +482,8 @@ def calculate_50year_wind_moment( Rated windspeed of turbine (m/s). load_factor : float Added safety factor on the extreme wind moment. - Default: 3.375 (2.5x DNV standard as this model does not design for buckling or fatigue) + Default: 3.375 (2.5x DNV standard as this model + does not design for buckling or fatigue) Returns ------- @@ -559,16 +560,15 @@ def calculate_thrust_coefficient(rated_windspeed): Coefficient of thrust. """ - ct = min( - [3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed ** 2), 1] - ) + ct = min([3.5 * (2 * rated_windspeed + 3.5) / (rated_windspeed**2), 1]) return ct @staticmethod def calculate_50year_extreme_ws(mean_windspeed, **kwargs): """ - Calculates the 50 year extreme wind speed using methodology from DNV-GL. + Calculates the 50 year extreme wind speed using methodology + from DNV-GL. Source: Arany & Bhattacharya (2016) - Equation 27 diff --git a/tests/phases/design/test_monopile_design.py b/tests/phases/design/test_monopile_design.py index 0762b46b..86394893 100644 --- a/tests/phases/design/test_monopile_design.py +++ b/tests/phases/design/test_monopile_design.py @@ -54,7 +54,7 @@ def test_paramater_sweep(depth, mean_ws, turbine): assert 4 < m._outputs["monopile"]["diameter"] < 13 # Check valid monopile mass - assert 200 < m._outputs["monopile"]["mass"] < 2500 + assert 200 < m._outputs["monopile"]["mass"] < 5000 # Check valid transition piece diameter assert 4 < m._outputs["transition_piece"]["diameter"] < 14 From fe814f516e0658f9472512b03c9897968e50f58f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 26 Apr 2024 15:03:12 -0600 Subject: [PATCH 156/240] Had to fix py version for yaml parsing in pypi workflow. --- .github/workflows/publish-to-pypi.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index 663128a3..c61c9415 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -10,7 +10,7 @@ jobs: - name: Set up Python 3.10 uses: actions/setup-python@v4 with: - python-version: 3.10 + python-version: '3.10' - name: Install dependencies run: | python -m pip install --upgrade pip From 9cd12445daff80948cac9fae6dcab2f2438c8e77 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 30 Apr 2024 15:45:47 -0600 Subject: [PATCH 157/240] Added semitaut arrays features to mooringsystem. Created rope/chain densities as optional user inputs. --- ORBIT/phases/design/__init__.py | 5 +- ORBIT/phases/design/mooring_system_design.py | 92 +++++++++++++++++--- 2 files changed, 80 insertions(+), 17 deletions(-) diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 3998529e..7871e0ca 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -7,15 +7,14 @@ from .design_phase import DesignPhase # isort:skip -from .oss_design_floating import OffshoreFloatingSubstationDesign from .oss_design import OffshoreSubstationDesign from .spar_design import SparDesign from .monopile_design import MonopileDesign from .electrical_export import ElectricalDesign from .array_system_design import ArraySystemDesign, CustomArraySystemDesign +from .oss_design_floating import OffshoreFloatingSubstationDesign from .export_system_design import ExportSystemDesign from .mooring_system_design import MooringSystemDesign -from .SemiTaut_mooring_system_design import SemiTautMooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign -from .electrical_export import ElectricalDesign +from .SemiTaut_mooring_system_design import SemiTautMooringSystemDesign diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 5b0eec8b..707943bf 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -1,13 +1,15 @@ """`MooringSystemDesign` and related functionality.""" -__author__ = "Jake Nunemaker" +__author__ = "Jake Nunemaker, modified by Becca Fuchs" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" -__email__ = "jake.nunemaker@nrel.gov" - +__email__ = "jake.nunemaker@nrel.gov, rebecca.fuchs@nrel.gov" from math import sqrt +import numpy as np +from scipy.interpolate import interp1d + from ORBIT.phases.design import DesignPhase @@ -21,8 +23,11 @@ class MooringSystemDesign(DesignPhase): "mooring_system_design": { "num_lines": "int | float (optional, default: 4)", "anchor_type": "str (optional, default: 'Suction Pile')", + "mooring_type": "str (optional, default: 'Catenary')", "mooring_line_cost_rate": "int | float (optional)", "drag_embedment_fixed_length": "int | float (optional, default: .5km)", + "chain_density": "int | float (optional, default: 19900 kg/m**3)", + "rope_density": "int | float (optional, default: 797.8 kg/m**3)", }, } @@ -56,6 +61,34 @@ def __init__(self, config, **kwargs): self._design = self.config.get("mooring_system_design", {}) self.num_lines = self._design.get("num_lines", 4) self.anchor_type = self._design.get("anchor_type", "Suction Pile") + self.mooring_type = self._design.get("mooring_type", "Catenary") + + # Input hybrid mooring system design from Cooperman et al. (2022), + # https://www.nrel.gov/docs/fy22osti/82341.pdf + _semitaut = { + "depths": np.array([500, 750, 1000, 1250, 1500], dtype=float), + "rope_lengths": np.array( + [478.41, 830.34, 1229.98, 1183.93, 1079.62], dtype=float + ), + "rope_diameters": np.array([0.2, 0.2, 0.2, 0.2, 0.2], dtype=float), + "chain_lengths": np.array( + [917.11, 800.36, 609.07, 896.42, 1280.57], dtype=float + ), + "chain_diamters": np.array([0.13, 0.17, 0.22, 0.22, 0.22]), + } + + self.finterp_rope_l = interp1d( + _semitaut["depths"], _semitaut["rope_lengths"] + ) + self.finterp_rope_d = interp1d( + _semitaut["depths"], _semitaut["rope_diameters"] + ) + self.finterp_chain_l = interp1d( + _semitaut["depths"], _semitaut["chain_lengths"] + ) + self.finterp_chain_d = interp1d( + _semitaut["depths"], _semitaut["chain_diameters"] + ) self._outputs = {} @@ -77,7 +110,7 @@ def determine_mooring_line(self): """ tr = self.config["turbine"]["turbine_rating"] - fit = -0.0004 * (tr ** 2) + 0.0132 * tr + 0.0536 + fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 if fit <= 0.09: self.line_diam = 0.09 @@ -100,26 +133,57 @@ def calculate_breaking_load(self): """ self.breaking_load = ( - 419449 * (self.line_diam ** 2) + 93415 * self.line_diam - 3577.9 + 419449 * (self.line_diam**2) + 93415 * self.line_diam - 3577.9 ) def calculate_line_length_mass(self): """ Returns the mooring line length and mass. """ + depth = self.config["site"]["depth"] - if self.anchor_type == "Drag Embedment": - fixed = self._design.get("drag_embedment_fixed_length", 500) + if self.mooring_type == "Catenary": + if self.anchor_type == "Drag Embedment": + fixed = self._design.get("drag_embedment_fixed_length", 500) - else: - fixed = 0 + else: + fixed = 0 - depth = self.config["site"]["depth"] - self.line_length = ( - 0.0002 * (depth ** 2) + 1.264 * depth + 47.776 + fixed - ) + self.line_length = ( + 0.0002 * (depth**2) + 1.264 * depth + 47.776 + fixed + ) + + self.line_mass = self.line_length * self.line_mass_per_m - self.line_mass = self.line_length * self.line_mass_per_m + else: + if self.anchor_type == "Drag Embedment": + fixed = self.get("drag_embedment_fixed_length", 0) + + else: + fixed = 0 + + # Rope and chain length at project depth + self.chain_length = self.finterp_chain_l(depth) + self.rope_length = self.finterp_rope_l(depth) + # Rope and chain diameter at project depth + self.rope_diameter = self.finterp_rope_d(depth) + self.chain_diameter = self.finterp_chain_d(depth) + + self.line_length = self.rope_length + self.chain_length + + chain_kg_per_m = ( + self._design.get("mooring_chain_density", 19900) + * self.chain_diameter**2 + ) + rope_kg_per_m = ( + self._design.get("mooring_rope_density", 797.8) + * self.rope_diameter**2 + ) + + self.line_mass = ( + self.chain_length * chain_kg_per_m + + self.rope_length * rope_kg_per_m + ) / 1e3 def calculate_anchor_mass_cost(self): """ From 671bd2a6295d79dcb04fd726a91bafdd0d719b0f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 1 May 2024 09:26:10 -0600 Subject: [PATCH 158/240] Added anchor cost and total line cost of semitaut option. --- ORBIT/phases/design/mooring_system_design.py | 66 +++++++++++++++----- 1 file changed, 49 insertions(+), 17 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 707943bf..3ffe8e0c 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -57,6 +57,7 @@ def __init__(self, config, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) self.num_turbines = self.config["plant"]["num_turbines"] + self.depth = self.config["site"]["depth"] self._design = self.config.get("mooring_system_design", {}) self.num_lines = self._design.get("num_lines", 4) @@ -66,15 +67,21 @@ def __init__(self, config, **kwargs): # Input hybrid mooring system design from Cooperman et al. (2022), # https://www.nrel.gov/docs/fy22osti/82341.pdf _semitaut = { - "depths": np.array([500, 750, 1000, 1250, 1500], dtype=float), + "depths": np.array([500.0, 750.0, 1000.0, 1250.0, 1500.0]), "rope_lengths": np.array( - [478.41, 830.34, 1229.98, 1183.93, 1079.62], dtype=float + [478.41, 830.34, 1229.98, 1183.93, 1079.62] ), - "rope_diameters": np.array([0.2, 0.2, 0.2, 0.2, 0.2], dtype=float), + "rope_diameters": np.array([0.2, 0.2, 0.2, 0.2, 0.2]), "chain_lengths": np.array( - [917.11, 800.36, 609.07, 896.42, 1280.57], dtype=float + [917.11, 800.36, 609.07, 896.42, 1280.57] ), "chain_diamters": np.array([0.13, 0.17, 0.22, 0.22, 0.22]), + "anchor_costs": np.array( + [112766.0, 125511.0, 148703.0, 204988.0, 246655.0] + ), + "total_line_costs": np.array( + [826598.0, 1221471.0, 1682208.0, 2380035.0, 3229700.0] + ), } self.finterp_rope_l = interp1d( @@ -89,6 +96,12 @@ def __init__(self, config, **kwargs): self.finterp_chain_d = interp1d( _semitaut["depths"], _semitaut["chain_diameters"] ) + self.finterp_anchor_cost = interp1d( + _semitaut["depths", _semitaut["anchor_costs"]] + ) + self.finterp_total_line_cost = interp1d( + _semitaut["depths"], _semitaut["total_line_costs"] + ) self._outputs = {} @@ -140,7 +153,6 @@ def calculate_line_length_mass(self): """ Returns the mooring line length and mass. """ - depth = self.config["site"]["depth"] if self.mooring_type == "Catenary": if self.anchor_type == "Drag Embedment": @@ -150,7 +162,10 @@ def calculate_line_length_mass(self): fixed = 0 self.line_length = ( - 0.0002 * (depth**2) + 1.264 * depth + 47.776 + fixed + 0.0002 * (self.depth**2) + + 1.264 * self.depth + + 47.776 + + fixed ) self.line_mass = self.line_length * self.line_mass_per_m @@ -163,11 +178,11 @@ def calculate_line_length_mass(self): fixed = 0 # Rope and chain length at project depth - self.chain_length = self.finterp_chain_l(depth) - self.rope_length = self.finterp_rope_l(depth) + self.chain_length = self.finterp_chain_l(self.depth) + self.rope_length = self.finterp_rope_l(self.depth) # Rope and chain diameter at project depth - self.rope_diameter = self.finterp_rope_d(depth) - self.chain_diameter = self.finterp_chain_d(depth) + self.rope_diameter = self.finterp_rope_d(self.depth) + self.chain_diameter = self.finterp_chain_d(self.depth) self.line_length = self.rope_length + self.chain_length @@ -193,19 +208,36 @@ def calculate_anchor_mass_cost(self): review. Should be revised when this module is overhauled in the future. """ - if self.anchor_type == "Drag Embedment": - self.anchor_mass = 20 - self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 + if self.mooring_type == "Catenary": + if self.anchor_type == "Drag Embedment": + self.anchor_mass = 20 + self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 + else: + self.anchor_mass = 50 + self.anchor_cost = ( + sqrt(self.breaking_load / 9.81 / 1250) * 150000 + ) else: - self.anchor_mass = 50 - self.anchor_cost = sqrt(self.breaking_load / 9.81 / 1250) * 150000 + if self.anchor_type == "Drag Embedment": + self.anchor_mass = 20 + + else: + self.anchor_mass = 50 + + self.anchor_cost = self.finterp_anchor_cost(self.depth) @property def line_cost(self): """Returns cost of one line mooring line.""" - return self.line_length * self.line_cost_rate + if self.mooring_type == "Catenary": + line_cost = self.line_length * self.line_cost_rate + + else: + line_cost = self.finterp_total_line_cost(self.depth) + + return line_cost @property def total_cost(self): @@ -214,7 +246,7 @@ def total_cost(self): return ( self.num_lines * self.num_turbines - * (self.anchor_cost + self.line_length * self.line_cost_rate) + * (self.anchor_cost + self.line_cost) ) @property From da759ea4b2652d20f6520d2cdae41882a2bfd621 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 1 May 2024 10:20:38 -0600 Subject: [PATCH 159/240] Cleaned up interp objects and repetitive lines. --- ORBIT/phases/design/mooring_system_design.py | 107 ++++++++----------- 1 file changed, 47 insertions(+), 60 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 3ffe8e0c..88673735 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -7,7 +7,6 @@ from math import sqrt -import numpy as np from scipy.interpolate import interp1d from ORBIT.phases.design import DesignPhase @@ -64,45 +63,24 @@ def __init__(self, config, **kwargs): self.anchor_type = self._design.get("anchor_type", "Suction Pile") self.mooring_type = self._design.get("mooring_type", "Catenary") - # Input hybrid mooring system design from Cooperman et al. (2022), - # https://www.nrel.gov/docs/fy22osti/82341.pdf - _semitaut = { - "depths": np.array([500.0, 750.0, 1000.0, 1250.0, 1500.0]), - "rope_lengths": np.array( - [478.41, 830.34, 1229.98, 1183.93, 1079.62] - ), - "rope_diameters": np.array([0.2, 0.2, 0.2, 0.2, 0.2]), - "chain_lengths": np.array( - [917.11, 800.36, 609.07, 896.42, 1280.57] - ), - "chain_diamters": np.array([0.13, 0.17, 0.22, 0.22, 0.22]), - "anchor_costs": np.array( - [112766.0, 125511.0, 148703.0, 204988.0, 246655.0] - ), - "total_line_costs": np.array( - [826598.0, 1221471.0, 1682208.0, 2380035.0, 3229700.0] - ), + # Semi-Taut mooring system design parameters based on depth + # Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf + self._semitaut = { + "depths": [500.0, 750.0, 1000.0, 1250.0, 1500.0], + "rope_lengths": [478.41, 830.34, 1229.98, 1183.93, 1079.62], + "rope_diameter": 0.2, + "chain_lengths": [917.11, 800.36, 609.07, 896.42, 1280.57], + "chain_diameters": [0.13, 0.17, 0.22, 0.22, 0.22], + "anchor_costs": [112766.0, 125511.0, 148703.0, 204988.0, 246655.0], + "total_line_costs": [ + 826598.0, + 1221471.0, + 1682208.0, + 2380035.0, + 3229700.0, + ], } - self.finterp_rope_l = interp1d( - _semitaut["depths"], _semitaut["rope_lengths"] - ) - self.finterp_rope_d = interp1d( - _semitaut["depths"], _semitaut["rope_diameters"] - ) - self.finterp_chain_l = interp1d( - _semitaut["depths"], _semitaut["chain_lengths"] - ) - self.finterp_chain_d = interp1d( - _semitaut["depths"], _semitaut["chain_diameters"] - ) - self.finterp_anchor_cost = interp1d( - _semitaut["depths", _semitaut["anchor_costs"]] - ) - self.finterp_total_line_cost = interp1d( - _semitaut["depths"], _semitaut["total_line_costs"] - ) - self._outputs = {} def run(self): @@ -162,43 +140,47 @@ def calculate_line_length_mass(self): fixed = 0 self.line_length = ( - 0.0002 * (self.depth**2) - + 1.264 * self.depth - + 47.776 - + fixed + 0.0002 * (self.depth**2) + 1.264 * self.depth + 47.776 + fixed ) self.line_mass = self.line_length * self.line_mass_per_m else: if self.anchor_type == "Drag Embedment": - fixed = self.get("drag_embedment_fixed_length", 0) + fixed = self._design.get("drag_embedment_fixed_length", 0) else: fixed = 0 - # Rope and chain length at project depth - self.chain_length = self.finterp_chain_l(self.depth) - self.rope_length = self.finterp_rope_l(self.depth) - # Rope and chain diameter at project depth - self.rope_diameter = self.finterp_rope_d(self.depth) - self.chain_diameter = self.finterp_chain_d(self.depth) + # Interpolation of rope and chain length at project depth + self.chain_length = interp1d( + self._semitaut["depths"], self._semitaut["chain_lengths"] + )(self.depth) + self.rope_length = interp1d( + self._semitaut["depths"], self._semitaut["rope_lengths"] + )(self.depth) + + # Rope and interpolated chain diameter at project depth + rope_diameter = self._semitaut["rope_diameter"] + chain_diameter = interp1d( + self._semitaut["depths"], self._semitaut["chain_diameters"] + )(self.depth) self.line_length = self.rope_length + self.chain_length - chain_kg_per_m = ( + chain_mass_per_m = ( self._design.get("mooring_chain_density", 19900) - * self.chain_diameter**2 - ) - rope_kg_per_m = ( + * chain_diameter**2 + ) # kg + rope_mass_per_m = ( self._design.get("mooring_rope_density", 797.8) - * self.rope_diameter**2 - ) + * rope_diameter**2 + ) # kg self.line_mass = ( - self.chain_length * chain_kg_per_m - + self.rope_length * rope_kg_per_m - ) / 1e3 + self.chain_length * chain_mass_per_m + + self.rope_length * rope_mass_per_m + ) / 1e3 # tonnes def calculate_anchor_mass_cost(self): """ @@ -225,7 +207,9 @@ def calculate_anchor_mass_cost(self): else: self.anchor_mass = 50 - self.anchor_cost = self.finterp_anchor_cost(self.depth) + self.anchor_cost = interp1d( + self._semitaut["depths"], self._semitaut["anchor_costs"] + )(self.depth) @property def line_cost(self): @@ -235,7 +219,10 @@ def line_cost(self): line_cost = self.line_length * self.line_cost_rate else: - line_cost = self.finterp_total_line_cost(self.depth) + + line_cost = interp1d( + self._semitaut["depths"], self._semitaut["total_line_costs"] + )(self.depth) return line_cost From 7413a00a1b7ef4f6b44e1c34407c7f2d9b85cacd Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 1 May 2024 14:58:45 -0600 Subject: [PATCH 160/240] renamed semitaut dict to semitaut_params for clarity --- ORBIT/phases/design/mooring_system_design.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 88673735..43fa6d91 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -65,7 +65,7 @@ def __init__(self, config, **kwargs): # Semi-Taut mooring system design parameters based on depth # Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf - self._semitaut = { + self._semitaut_params = { "depths": [500.0, 750.0, 1000.0, 1250.0, 1500.0], "rope_lengths": [478.41, 830.34, 1229.98, 1183.93, 1079.62], "rope_diameter": 0.2, @@ -154,16 +154,19 @@ def calculate_line_length_mass(self): # Interpolation of rope and chain length at project depth self.chain_length = interp1d( - self._semitaut["depths"], self._semitaut["chain_lengths"] + self._semitaut_params["depths"], + self._semitaut_params["chain_lengths"], )(self.depth) self.rope_length = interp1d( - self._semitaut["depths"], self._semitaut["rope_lengths"] + self._semitaut_params["depths"], + self._semitaut_params["rope_lengths"], )(self.depth) # Rope and interpolated chain diameter at project depth - rope_diameter = self._semitaut["rope_diameter"] + rope_diameter = self._semitaut_params["rope_diameter"] chain_diameter = interp1d( - self._semitaut["depths"], self._semitaut["chain_diameters"] + self._semitaut_params["depths"], + self._semitaut_params["chain_diameters"], )(self.depth) self.line_length = self.rope_length + self.chain_length @@ -208,7 +211,8 @@ def calculate_anchor_mass_cost(self): self.anchor_mass = 50 self.anchor_cost = interp1d( - self._semitaut["depths"], self._semitaut["anchor_costs"] + self._semitaut_params["depths"], + self._semitaut_params["anchor_costs"], )(self.depth) @property @@ -221,7 +225,8 @@ def line_cost(self): else: line_cost = interp1d( - self._semitaut["depths"], self._semitaut["total_line_costs"] + self._semitaut_params["depths"], + self._semitaut_params["total_line_costs"], )(self.depth) return line_cost From 0f56d8e28b8d49dc1bb42cd951b387856227d991 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 1 May 2024 18:11:55 -0600 Subject: [PATCH 161/240] Cleaned up pre-commit warnings/errors like unused kwargs and line lengths. --- .../install/quayside_assembly_tow/moored.py | 150 ++++++++++++++++-- 1 file changed, 141 insertions(+), 9 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index c087e066..cc3834bc 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -6,9 +6,12 @@ __email__ = "jake.nunemaker@nrel.gov" +from warnings import warn + import simpy from marmot import le, process -from ORBIT.core import Vessel, WetStorage + +from ORBIT.core import WetStorage from ORBIT.phases.install import InstallPhase from .common import TowingGroup, TurbineAssemblyLine, SubstructureAssemblyLine @@ -25,10 +28,12 @@ class MooredSubInstallation(InstallPhase): #: expected_config = { + "support_vessel": "str", "ahts_vessel": "str", "towing_vessel": "str", "towing_vessel_groups": { "towing_vessels": "int", + "station_keeping_vessels": "int", "ahts_vessels": "int (optional, default: 1)", "num_groups": "int (optional)", }, @@ -67,9 +72,9 @@ def __init__(self, config, weather=None, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) - self.setup_simulation(**kwargs) + self.setup_simulation() - def setup_simulation(self, **kwargs): + def setup_simulation(self): """ Sets up simulation infrastructure. - Initializes substructure production @@ -85,6 +90,7 @@ def setup_simulation(self, **kwargs): self.initialize_turbine_assembly() self.initialize_queue() self.initialize_towing_groups() + self.initialize_support_vessel() @property def system_capex(self): @@ -181,7 +187,8 @@ def initialize_towing_groups(self, **kwargs): towing_speed = self.config["substructure"].get("towing_speed", 6) ahts_vessel = self.config["ahts_vessel"] - num_ahts = self.config["towing_vessel_groups"]["ahts_vessels"] + + num_ahts = self.config["towing_vessel_groups"].get("ahts_vessels", 1) remaining_substructures = [1] * self.num_turbines @@ -212,9 +219,57 @@ def initialize_queue(self): self.active_group.vessel = None self.active_group.activate = self.env.event() + def initialize_support_vessel(self): + """ + ** DEPRECATED ** The support vessel is deprecated and an AHTS + vessel will perform the installation with the towing group. + + Initializes Multi-Purpose Support Vessel to perform installation + processes at site. + """ + + specs = self.config["support_vessel"] + + if specs is not None: + warn( + "support_vessel will be deprecated and replaced with" + " towing_vessels and to ahts_vessel in the towing groups.", + DeprecationWarning, + stacklevel=2, + ) + + # vessel = self.initialize_vessel("Multi-Purpose Support Vessel", + # specs) + + # self.env.register(vessel) + # vessel.initialize(mobilize=False) + # self.support_vessel = vessel + + station_keeping_vessels = self.config["towing_vessel_groups"][ + "station_keeping_vessels" + ] + + if station_keeping_vessels is not None: + print(station_keeping_vessels) + warn( + "station_keeping_vessels will be deprecated and replaced with" + " towing_vessels and ahts_vessels in the towing groups.", + DeprecationWarning, + stacklevel=2, + ) + + # install_moored_substructures( + # self.support_vessel, + # self.active_group, + # self.distance, + # self.num_turbines, + # station_keeping_vessels, + # **kwargs, + # ) + @property def detailed_output(self): - """""" + """return detailed outputs.""" return { "operational_delays": { @@ -234,7 +289,7 @@ def detailed_output(self): } def operational_delay(self, name): - """""" + """return operational delays""" actions = [a for a in self.env.actions if a["agent"] == name] delay = sum(a["duration"] for a in actions if "Delay" in a["action"]) @@ -283,10 +338,10 @@ def towing_group_actions( towing_vessels, ahts_vessels, towing_speed, - **kwargs, ): """ - Process logic for the towing vessel group. Assumes there is an anchor tug boat with each group + Process logic for the towing vessel group. Assumes there is an + anchor tug boat with each group Parameters ---------- @@ -308,7 +363,7 @@ def towing_group_actions( transit_time = distance / group.transit_speed start = group.env.now - assembly = yield feed.get() + _ = yield feed.get() delay = group.env.now - start if delay > 0: @@ -390,3 +445,80 @@ def towing_group_actions( "waveheight": le(group.max_waveheight), }, ) + + +@process +def install_moored_substructures( + vessel, queue, distance, substructures, station_keeping_vessels +): + """ + ** DEPRECATED ** This method is deprecated and is now performed + in towing_group_action() by the towing group with AHTS vessel. + Logic that a Multi-Purpose Support Vessel uses at site to complete the + installation of moored substructures. + + Parameters + ---------- + vessel : Vessel + queue : + distance : int | float + Distance between port and site (km). + substructures : int + Number of substructures to install before transiting back to port. + station_keeping_vessels : int + Number of vessels to use for substructure station keeping during final + installation at site. + """ + + n = 0 + while n < substructures: + if queue.vessel: + + start = vessel.env.now + if n == 0: + vessel.mobilize() + yield vessel.transit(distance) + + yield vessel.task_wrapper( + "Position Substructure", + 2, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + yield vessel.task_wrapper( + "Ballast to Operational Draft", + 6, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + yield vessel.task_wrapper( + "Connect Mooring Lines", + 22, + suspendable=True, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + yield vessel.task_wrapper( + "Check Mooring Lines", + 12, + suspendable=True, + constraints={"windspeed": le(15), "waveheight": le(2.5)}, + ) + + group_time = vessel.env.now - start + queue.vessel.submit_action_log( + "Positioning Support", + group_time, + location="site", + num_vessels=station_keeping_vessels, + ) + yield queue.vessel.release.succeed() + vessel.submit_debug_log(progress="Substructure") + n += 1 + + else: + start = vessel.env.now + yield queue.activate + delay_time = vessel.env.now - start + + if n != 0: + vessel.submit_action_log("Delay", delay_time, location="Site") + + yield vessel.transit(distance) From 4e0f5dfc58f9b116bf385ee904ebaa4f91c18d22 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 2 May 2024 09:16:17 -0600 Subject: [PATCH 162/240] Check if ahts_vessel is None rather than a KeyError. --- ORBIT/phases/install/quayside_assembly_tow/moored.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index cc3834bc..a0585011 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -186,10 +186,13 @@ def initialize_towing_groups(self, **kwargs): num_towing = self.config["towing_vessel_groups"]["towing_vessels"] towing_speed = self.config["substructure"].get("towing_speed", 6) - ahts_vessel = self.config["ahts_vessel"] - + ahts_vessel = self.config.get("ahts_vessel", None) num_ahts = self.config["towing_vessel_groups"].get("ahts_vessels", 1) + if ahts_vessel is None: + warn("No ['ahts_vessel'] specified. num_ahts set to 0.") + num_ahts = 0 + remaining_substructures = [1] * self.num_turbines for i in range(num_groups): From 6b8c2c753e423d65d1b1b21f213f22bbf6e68237 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 2 May 2024 09:30:04 -0600 Subject: [PATCH 163/240] Made ahts_vessel optional temporarily to raise warnings rather than a KeyError. --- ORBIT/phases/install/quayside_assembly_tow/moored.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index a0585011..084781f4 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -29,7 +29,7 @@ class MooredSubInstallation(InstallPhase): #: expected_config = { "support_vessel": "str", - "ahts_vessel": "str", + "ahts_vessel": "str, (optional)", "towing_vessel": "str", "towing_vessel_groups": { "towing_vessels": "int", @@ -190,7 +190,10 @@ def initialize_towing_groups(self, **kwargs): num_ahts = self.config["towing_vessel_groups"].get("ahts_vessels", 1) if ahts_vessel is None: - warn("No ['ahts_vessel'] specified. num_ahts set to 0.") + warn( + "No ['ahts_vessel'] specified. num_ahts set to 0." + " ahts_vessel will be required in future releases.\n" + ) num_ahts = 0 remaining_substructures = [1] * self.num_turbines @@ -236,7 +239,7 @@ def initialize_support_vessel(self): if specs is not None: warn( "support_vessel will be deprecated and replaced with" - " towing_vessels and to ahts_vessel in the towing groups.", + " towing_vessels and ahts_vessel in the towing groups.\n", DeprecationWarning, stacklevel=2, ) @@ -256,7 +259,7 @@ def initialize_support_vessel(self): print(station_keeping_vessels) warn( "station_keeping_vessels will be deprecated and replaced with" - " towing_vessels and ahts_vessels in the towing groups.", + " towing_vessels and ahts_vessels in the towing groups.\n", DeprecationWarning, stacklevel=2, ) From 6573b45ab691dd75567a97e6702c08f326fd1ed5 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 2 May 2024 11:19:37 -0600 Subject: [PATCH 164/240] Adjusted floating true/false logic in electrical export. Eliminate redundant class for FloatingOffshoreSubstation. --- ORBIT/phases/design/electrical_export.py | 52 +++++++++++-------- ORBIT/phases/install/oss_install/floating.py | 23 ++++++-- .../install/quayside_assembly_tow/moored.py | 8 +++ 3 files changed, 56 insertions(+), 27 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 67952c4b..19635a04 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -69,6 +69,7 @@ class ElectricalDesign(CableSystem): "converter_cost": "USD (optional)", "onshore_converter_cost": "USD (optional)", "topside_assembly_factor": "float (optional)", + "oss_substructure_type": "str (optional, default: Monopile)", "oss_substructure_cost_rate": "USD/t (optional)", "oss_pile_cost_rate": "USD/t (optional)", }, @@ -126,25 +127,24 @@ def __init__(self, config, **kwargs): "interconnection_distance", 3 ) - # SUBSTATION - try: - self._floating_oss = config["substation_design"]["floating_oss"] - except KeyError: - self._floating_oss = False - - self._outputs = {} - - def run(self): - """Main run function.""" - self.export_system_design = self.config["export_system_design"] self.offshore_substation_design = self.config.get( "substation_design", {} ) + + self.substructure_type = self.offshore_substation_design.get( + "oss_substructure_type", "Monopile" + ) + self.onshore_substation_design = self.config.get( "onshore_substation_design", {} ) + self._outputs = {} + + def run(self): + """Main run function.""" + # CABLES self._initialize_cables() self.cable = self.cables[[*self.cables][0]] @@ -188,7 +188,8 @@ def run(self): self.calc_onshore_cost() self._outputs["offshore_substation_substructure"] = { - "type": "Monopile", # Substation install only supports monopiles + "type": self.substructure_type, # Substation install + # only supports monopiles "deck_space": self.substructure_deck_space, "mass": self.substructure_mass, "length": self.substructure_length, @@ -351,19 +352,18 @@ def calc_num_substations(self): ---------- substation_capacity : int | float """ - self._design = self.config.get("substation_design", {}) # HVAC substation capacity - _substation_capacity = self._design.get( + _substation_capacity = self.offshore_substation_design.get( "substation_capacity", 1200 ) # MW if "HVDC" in self.cable.cable_type: - self.num_substations = self._design.get( + self.num_substations = self.offshore_substation_design.get( "num_substations", int(self.num_cables / 2) ) else: - self.num_substations = self._design.get( + self.num_substations = self.offshore_substation_design.get( "num_substations", int(np.ceil(self._plant_capacity / _substation_capacity)), ) @@ -499,8 +499,10 @@ def calc_assembly_cost(self): topside_assembly_factor : int | float """ - _design = self.config.get("substation_design", {}) - topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) + topside_assembly_factor = self.offshore_substation_design.get( + "topside_assembly_factor", 0.075 + ) + self.land_assembly_cost = ( self.switchgear_cost + self.shunt_reactor_cost @@ -517,18 +519,22 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate : int | float """ - _design = self.config.get("substation_design", {}) substructure_mass = 0.4 * self.topside_mass - oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) - oss_substructure_cost_rate = _design.get( + oss_pile_cost_rate = self.offshore_substation_design.get( + "oss_pile_cost_rate", 0 + ) + oss_substructure_cost_rate = self.offshore_substation_design.get( "oss_substructure_cost_rate", 3000 ) + # TODO: Determine a better method to calculate substructure mass + # for different substructure types substructure_mass = 0.4 * self.topside_mass - if self._floating_oss == False: + + if self.substructure_type == "Monopile": substructure_pile_mass = 8 * substructure_mass**0.5574 else: - substructure_pile_mass = 0 # No piles for floating OSS + substructure_pile_mass = 0 # Assume floating and no piles are used self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 471118db..4dd7e8e4 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -6,10 +6,13 @@ __email__ = "jake.nunemaker@nrel.gov" +from warnings import warn + from marmot import Agent, le, process +from marmot._exceptions import AgentNotRegistered + from ORBIT.core import WetStorage from ORBIT.core.logic import position_onsite -from marmot._exceptions import AgentNotRegistered from ORBIT.phases.install import InstallPhase from ORBIT.phases.install.mooring_install.mooring import ( install_mooring_line, @@ -37,14 +40,16 @@ class FloatingSubstationInstallation(InstallPhase): "attach_time": "int | float (optional, default: 24)", }, "offshore_substation_substructure": { - "type": "Floating", + "type": "str", "takt_time": "int | float (optional, default: 0)", "unit_cost": "USD", # "mooring_cost": "USD", "towing_speed": "int | float (optional, default: 6 km/h)", }, "mooring_system": { - # "system_cost": "USD", "}, # system cost is for all moorings in the whole farm, so you dont want this to be added to each substation + # "system_cost": "USD", "}, + # system cost is for all moorings in the whole farm, + # so you dont want this to be added to each substation "num_lines", "int", "line_cost", @@ -74,7 +79,7 @@ def __init__(self, config, weather=None, **kwargs): self.initialize_port() self.setup_simulation(**kwargs) - def setup_simulation(self, **kwargs): + def setup_simulation(self): """ Initializes required objects for simulation. - Creates port @@ -117,6 +122,16 @@ def initialize_substructure_production(self): quayside. """ + substructure_type = self.config["offshore_substation_substructure"][ + "type" + ] + + if substructure_type != "Floating": + warn( + f"Offshore substation substructure is {substructure_type}" + " and should be 'Floating'.\n" + ) + self.wet_storage = WetStorage(self.env, float("inf")) takt_time = self.config["offshore_substation_substructure"].get( "takt_time", 0 diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 084781f4..31618768 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -291,6 +291,9 @@ def detailed_output(self): k: self.operational_delay(str(k)) for k in self.installation_groups }, + # self.support_vessel: self.operational_delay( + # str(self.support_vessel) + # ), } } @@ -476,6 +479,11 @@ def install_moored_substructures( installation at site. """ + warn( + "** DEPRECATED ** This method is deprecated and is now performed" + " in towing_group_action() by the towing group with AHTS vessel.\n" + ) + n = 0 while n < substructures: if queue.vessel: From 3e2b6c83c79e8c7b81373b32d7809e8e4de2f0c8 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 21 May 2024 14:03:03 -0600 Subject: [PATCH 165/240] Updated semitaut examples. --- ...5. Example Floating Project-SemiTaut.ipynb | 327 ++++++++++-------- .../example_floating_project_SemiTaut.yaml | 8 +- 2 files changed, 189 insertions(+), 146 deletions(-) diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index aa999ce7..edf2b103 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -20,14 +20,25 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_93742/1311156483.py:7\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", + "from ORBIT import ProjectManager, load_config\n", "\n", + "import warnings\n", + "warnings.filterwarnings(\"default\")\n", "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", " .set_index(\"datetime\")" ] @@ -41,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -56,7 +67,7 @@ } ], "source": [ - "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\") \n", + "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\")\n", "\n", "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", "print(f\"Turbine: {fixed_config['turbine']}\")\n", @@ -72,14 +83,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Design phases: ['ArraySystemDesign', 'ExportSystemDesign', 'SemiTautMooringSystemDesign', 'OffshoreFloatingSubstationDesign', 'SemiSubmersibleDesign']\n", + "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'SemiTautMooringSystemDesign', 'SemiSubmersibleDesign']\n", "\n", "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" ] @@ -100,27 +111,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n", - "topside: 47826750.0\n", - "oss substructure1912800.0\n", - "mooring system6549357.6\n", - "topside: 47826750.0\n", - "oss substructure1912800.0\n", - "mooring system6549357.6\n" + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:193\n", + "No ['ahts_vessel'] specified. num_ahts set to 0. ahts_vessel will be required in future releases.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" ] } ], @@ -138,20 +148,20 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Installation CapEx: 300 M\n", - "System CapEx: 1231 M\n", + "Installation CapEx: 345 M\n", + "System CapEx: 1333 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 2850 M\n", + "Total CapEx: 2997 M\n", "\n", - "Installation Time: 22581 h\n" + "Installation Time: 35527 h\n" ] } ], @@ -174,28 +184,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'Array System': 56983076.60642063,\n", - " 'Export System': 103712476.9152,\n", + " 'Export System': 259281192.288,\n", " 'Substructure': 630709636.6,\n", " 'Mooring System': 327467880.0,\n", - " 'Offshore Substation': 112577815.2,\n", - " 'Array System Installation': 22844527.89607126,\n", - " 'Export System Installation': 135112258.0470523,\n", - " 'Substructure Installation': 78569120.05327243,\n", + " 'Offshore Substation': 58536861.93724438,\n", + " 'Array System Installation': 63027746.845681354,\n", + " 'Export System Installation': 148076127.6910655,\n", + " 'Substructure Installation': 78801350.29354209,\n", " 'Mooring System Installation': 48485331.05022831,\n", - " 'Offshore Substation Installation': 14801636.225266362,\n", + " 'Offshore Substation Installation': 7070795.281582953,\n", " 'Turbine': 780000000,\n", " 'Soft': 387000000,\n", " 'Project': 151250000.0}" ] }, - "execution_count": 6, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -206,28 +216,28 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'Array System': 94.97179434403438,\n", - " 'Export System': 172.854128192,\n", + " 'Export System': 432.13532047999996,\n", " 'Substructure': 1051.1827276666668,\n", " 'Mooring System': 545.7798,\n", - " 'Offshore Substation': 187.629692,\n", - " 'Array System Installation': 38.07421316011877,\n", - " 'Export System Installation': 225.18709674508716,\n", - " 'Substructure Installation': 130.9485334221207,\n", + " 'Offshore Substation': 97.56143656207396,\n", + " 'Array System Installation': 105.04624474280226,\n", + " 'Export System Installation': 246.79354615177581,\n", + " 'Substructure Installation': 131.33558382257016,\n", " 'Mooring System Installation': 80.80888508371386,\n", - " 'Offshore Substation Installation': 24.66939370877727,\n", + " 'Offshore Substation Installation': 11.784658802638255,\n", " 'Turbine': 1300.0,\n", " 'Soft': 645.0,\n", " 'Project': 252.08333333333334}" ] }, - "execution_count": 7, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -245,7 +255,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -283,6 +293,7 @@ " max_windspeed\n", " transit_speed\n", " num_vessels\n", + " num_ahts_vessels\n", " \n", " \n", " \n", @@ -292,7 +303,7 @@ " Array Cable Installation Vessel\n", " Mobilize\n", " 72.000000\n", - " 1.800000e+05\n", + " 3.375000e+05\n", " ACTION\n", " 0.000000\n", " ArrayCableInstallation\n", @@ -302,6 +313,7 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 1\n", @@ -309,7 +321,7 @@ " Export Cable Installation Vessel\n", " Mobilize\n", " 72.000000\n", - " 1.800000e+05\n", + " 3.375000e+05\n", " ACTION\n", " 0.000000\n", " ExportCableInstallation\n", @@ -319,6 +331,7 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 2\n", @@ -326,7 +339,7 @@ " Onshore Construction\n", " Onshore Construction\n", " 0.000000\n", - " 1.075454e+08\n", + " 1.665604e+06\n", " ACTION\n", " 0.000000\n", " ExportCableInstallation\n", @@ -336,6 +349,7 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 3\n", @@ -353,6 +367,7 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " 4\n", @@ -370,6 +385,7 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", " \n", " \n", " ...\n", @@ -387,18 +403,20 @@ " ...\n", " ...\n", " ...\n", + " ...\n", " \n", " \n", - " 2876\n", + " 2988\n", " NaN\n", - " Multi-Purpose Support Vessel\n", - " Connect Mooring Lines, Pre-tension and pre-str...\n", - " 20.000000\n", - " 8.333333e+04\n", + " Export Cable Installation Vessel\n", + " Pull In Cable\n", + " 5.500000\n", + " 5.156250e+04\n", " ACTION\n", - " 8544.500000\n", - " MooredSubInstallation\n", + " 12017.280762\n", + " ExportCableInstallation\n", " NaN\n", + " ExportCableInstallation\n", " NaN\n", " NaN\n", " NaN\n", @@ -406,16 +424,17 @@ " NaN\n", " \n", " \n", - " 2877\n", + " 2989\n", " NaN\n", - " Multi-Purpose Support Vessel\n", - " Check Mooring Lines\n", - " 6.000000\n", - " 2.500000e+04\n", + " Export Cable Installation Vessel\n", + " Terminate Cable\n", + " 5.500000\n", + " 5.156250e+04\n", " ACTION\n", - " 8550.500000\n", - " MooredSubInstallation\n", + " 12022.780762\n", + " ExportCableInstallation\n", " NaN\n", + " ExportCableInstallation\n", " NaN\n", " NaN\n", " NaN\n", @@ -423,32 +442,34 @@ " NaN\n", " \n", " \n", - " 2878\n", + " 2990\n", " NaN\n", - " Towing Group 1\n", - " Positioning Support\n", - " 34.000000\n", - " 8.500000e+04\n", + " Export Cable Installation Vessel\n", + " Transit\n", + " 8.000000\n", + " 7.500000e+04\n", " ACTION\n", - " 8550.500000\n", - " MooredSubInstallation\n", - " site\n", + " 12030.780762\n", + " ExportCableInstallation\n", + " NaN\n", + " NaN\n", + " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 2.0\n", " \n", " \n", - " 2879\n", + " 2991\n", " NaN\n", - " Multi-Purpose Support Vessel\n", - " Transit\n", - " 10.000000\n", - " 4.166667e+04\n", + " Export Cable Installation Vessel\n", + " Delay\n", + " 26.000000\n", + " 2.437500e+05\n", " ACTION\n", - " 8560.500000\n", - " MooredSubInstallation\n", + " 12056.780762\n", + " ExportCableInstallation\n", + " NaN\n", " NaN\n", " NaN\n", " NaN\n", @@ -457,25 +478,26 @@ " NaN\n", " \n", " \n", - " 2880\n", + " 2992\n", " NaN\n", - " Towing Group 1\n", + " Export Cable Installation Vessel\n", " Transit\n", - " 16.666667\n", - " 6.250000e+04\n", + " 0.695652\n", + " 6.521739e+03\n", " ACTION\n", - " 8567.166667\n", - " MooredSubInstallation\n", + " 12057.476414\n", + " ExportCableInstallation\n", + " NaN\n", + " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 3.0\n", " \n", " \n", "\n", - "

2881 rows × 14 columns

\n", + "

2993 rows × 15 columns

\n", "" ], "text/plain": [ @@ -486,68 +508,68 @@ "3 1.0 Mooring System Installation Vessel \n", "4 NaN Substation Assembly Line 1 \n", "... ... ... \n", - "2876 NaN Multi-Purpose Support Vessel \n", - "2877 NaN Multi-Purpose Support Vessel \n", - "2878 NaN Towing Group 1 \n", - "2879 NaN Multi-Purpose Support Vessel \n", - "2880 NaN Towing Group 1 \n", + "2988 NaN Export Cable Installation Vessel \n", + "2989 NaN Export Cable Installation Vessel \n", + "2990 NaN Export Cable Installation Vessel \n", + "2991 NaN Export Cable Installation Vessel \n", + "2992 NaN Export Cable Installation Vessel \n", "\n", - " action duration \\\n", - "0 Mobilize 72.000000 \n", - "1 Mobilize 72.000000 \n", - "2 Onshore Construction 0.000000 \n", - "3 Mobilize 168.000000 \n", - "4 Substation Substructure Assembly 0.000000 \n", - "... ... ... \n", - "2876 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", - "2877 Check Mooring Lines 6.000000 \n", - "2878 Positioning Support 34.000000 \n", - "2879 Transit 10.000000 \n", - "2880 Transit 16.666667 \n", + " action duration cost level \\\n", + "0 Mobilize 72.000000 3.375000e+05 ACTION \n", + "1 Mobilize 72.000000 3.375000e+05 ACTION \n", + "2 Onshore Construction 0.000000 1.665604e+06 ACTION \n", + "3 Mobilize 168.000000 7.000000e+05 ACTION \n", + "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", + "... ... ... ... ... \n", + "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", + "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", + "2990 Transit 8.000000 7.500000e+04 ACTION \n", + "2991 Delay 26.000000 2.437500e+05 ACTION \n", + "2992 Transit 0.695652 6.521739e+03 ACTION \n", "\n", - " cost level time phase \\\n", - "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", - "1 1.800000e+05 ACTION 0.000000 ExportCableInstallation \n", - "2 1.075454e+08 ACTION 0.000000 ExportCableInstallation \n", - "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", - "4 0.000000e+00 ACTION 0.000000 FloatingSubstationInstallation \n", - "... ... ... ... ... \n", - "2876 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", - "2877 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "2878 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "2879 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", - "2880 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", + " time phase location \\\n", + "0 0.000000 ArrayCableInstallation NaN \n", + "1 0.000000 ExportCableInstallation NaN \n", + "2 0.000000 ExportCableInstallation Landfall \n", + "3 0.000000 MooringSystemInstallation NaN \n", + "4 0.000000 FloatingSubstationInstallation NaN \n", + "... ... ... ... \n", + "2988 12017.280762 ExportCableInstallation NaN \n", + "2989 12022.780762 ExportCableInstallation NaN \n", + "2990 12030.780762 ExportCableInstallation NaN \n", + "2991 12056.780762 ExportCableInstallation NaN \n", + "2992 12057.476414 ExportCableInstallation NaN \n", "\n", - " location phase_name max_waveheight max_windspeed transit_speed \\\n", - "0 NaN NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN \n", - "2 Landfall NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN \n", - "... ... ... ... ... ... \n", - "2876 NaN NaN NaN NaN NaN \n", - "2877 NaN NaN NaN NaN NaN \n", - "2878 site NaN NaN NaN NaN \n", - "2879 NaN NaN NaN NaN NaN \n", - "2880 NaN NaN NaN NaN NaN \n", + " phase_name max_waveheight max_windspeed transit_speed \\\n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2988 ExportCableInstallation NaN NaN NaN \n", + "2989 ExportCableInstallation NaN NaN NaN \n", + "2990 NaN NaN NaN NaN \n", + "2991 NaN NaN NaN NaN \n", + "2992 NaN NaN NaN NaN \n", "\n", - " num_vessels \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - "... ... \n", - "2876 NaN \n", - "2877 NaN \n", - "2878 2.0 \n", - "2879 NaN \n", - "2880 3.0 \n", + " num_vessels num_ahts_vessels \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "... ... ... \n", + "2988 NaN NaN \n", + "2989 NaN NaN \n", + "2990 NaN NaN \n", + "2991 NaN NaN \n", + "2992 NaN NaN \n", "\n", - "[2881 rows x 14 columns]" + "[2993 rows x 15 columns]" ] }, - "execution_count": 8, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -558,10 +580,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "{'type': 'Monopile',\n", + " 'deck_space': 1,\n", + " 'mass': 1606.7690784724548,\n", + " 'length': 910,\n", + " 'unit_cost': 3576000.0}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.design_results[\"offshore_substation_substructure\"]" + ] } ], "metadata": { @@ -580,7 +619,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15" + "version": "3.8.18" } }, "nbformat": 4, diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml index c43de907..c0890c62 100644 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -19,9 +19,11 @@ export_cable_install_vessel: example_cable_lay_vessel mooring_install_vessel: example_support_vessel oss_install_vessel: floating_heavy_lift_vessel support_vessel: example_support_vessel +#ahts_vessel: example_ahts_vessel towing_vessel: example_towing_vessel towing_vessel_groups: station_keeping_vessels: 2 + ahts_vessels: 1 towing_vessels: 3 wtiv: floating_heavy_lift_vessel # Module Specific @@ -35,12 +37,14 @@ array_system_design: export_system_design: cables: XLPE_500mm_132kV percent_added_length: 0.0 +offshore_substation_substructure: + type: Floating # Configured Phases design_phases: - ArraySystemDesign -- ExportSystemDesign +- ElectricalDesign - SemiTautMooringSystemDesign -- OffshoreFloatingSubstationDesign +#- OffshoreFloatingSubstationDesign - SemiSubmersibleDesign install_phases: ArrayCableInstallation: 0 From fab774bd1cff7731ecaaa891d43f2491c355bab8 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 11:34:50 -0600 Subject: [PATCH 166/240] Updated electrical_design testing to check floating/fixed offshore substation --- tests/phases/design/test_electrical_design.py | 80 ++++++++++++++++++- 1 file changed, 76 insertions(+), 4 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 2ca93e26..5539e928 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -20,7 +20,9 @@ "plant": {"capacity": 500}, "export_system_design": {"cables": "XLPE_630mm_220kV"}, "landfall": {}, - "substation_design": {}, + "substation_design": { + "oss_pile_cost_rate": 1200, # need to set this for kwarg tests + }, } @@ -59,6 +61,78 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): assert 1e6 <= o.total_substation_cost <= 1e9 +def test_calc_substructure_mass_and_cost(): + + o = ElectricalDesign(base) + o.run() + + floating = deepcopy(base) + floating["substation_design"]["oss_substructure_type"] = "Floating" + o_floating = ElectricalDesign(floating) + o_floating.run() + + assert ( + o.detailed_output["substation_substructure_cost"] + != o_floating.detailed_output["substation_substructure_cost"] + ) + assert ( + o.detailed_output["substation_substructure_mass"] + != o_floating.detailed_output["substation_substructure_mass"] + ) + + +def test_calc_topside_mass_and_cost(): + """Test topside mass and cost for HVDC compared to HVDC-Monopole and HVDC-Bipole""" + + o = ElectricalDesign(base) + o.run() + + base_dc = deepcopy(base) + cables = ["HVDC_2000mm_320kV", "HVDC_2500mm_525kV"] + + for cable in cables: + base_dc["export_system_design"]["cables"] = cable + + o_dc = ElectricalDesign(base_dc) + o_dc.run() + + assert ( + o.detailed_output["substation_topside_mass"] + == o_dc.detailed_output["substation_topside_mass"] + ) + assert ( + o.detailed_output["substation_topside_cost"] + != o_dc.detailed_output["substation_topside_cost"] + ) + + +def test_oss_substructure_kwargs(): + test_kwargs = { + "oss_substructure_type": "Floating", + "oss_substructure_cost_rate": 7250, + "oss_pile_cost_rate": 2500, + "num_substations": 4, + } + + o = ElectricalDesign(base) + o.run() + base_cost_total = o.detailed_output["total_substation_cost"] + base_cost_subst = o.detailed_output["substation_substructure_cost"] + + for k, v in test_kwargs.items(): + config = deepcopy(base) + config["substation_design"] = {} + config["substation_design"][k] = v + + o = ElectricalDesign(config) + o.run() + cost_total = o.detailed_output["total_substation_cost"] + cost_subst = o.detailed_output["substation_substructure_cost"] + + assert cost_total != base_cost_total + assert cost_subst != base_cost_subst + + def test_ac_oss_kwargs(): test_kwargs = { "mpt_unit_cost": 13500, @@ -70,8 +144,6 @@ def test_ac_oss_kwargs(): "workspace_cost": 3e6, "other_ancillary_cost": 4e6, "topside_assembly_factor": 0.09, - "oss_substructure_cost_rate": 7250, - "oss_pile_cost_rate": 2500, "num_substations": 4, } @@ -109,7 +181,7 @@ def test_dc_oss_kwargs(): o = ElectricalDesign(config) o.run() cost = o.detailed_output["total_substation_cost"] - print("passed") + assert cost != base_cost From c10f253f8f95749a1b0eab3678edc193d473074e Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 11:39:42 -0600 Subject: [PATCH 167/240] Updated oss_design test for floating/fixed options --- tests/phases/design/test_oss_design.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/phases/design/test_oss_design.py b/tests/phases/design/test_oss_design.py index b2dd6316..b6257e2d 100644 --- a/tests/phases/design/test_oss_design.py +++ b/tests/phases/design/test_oss_design.py @@ -62,6 +62,7 @@ def test_oss_kwargs(): "workspace_cost": 3e6, "other_ancillary_cost": 4e6, "topside_assembly_factor": 0.08, + "oss_substructure_type": "Floating", "oss_substructure_cost_rate": 7250, "oss_pile_cost_rate": 2500, "num_substations": 2, @@ -75,6 +76,7 @@ def test_oss_kwargs(): config = deepcopy(base) config["substation_design"] = {} + config["substation_design"]["oss_pile_cost_rate"] = 1500 config["substation_design"][k] = v o = OffshoreSubstationDesign(config) From 3aa5aa5becc006dabdeef65a1d43ebe8aff2b332 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 12:00:22 -0600 Subject: [PATCH 168/240] Adjusted floating/standard oss install to count for floating and fix pylint warnings --- ORBIT/phases/install/oss_install/floating.py | 2 +- ORBIT/phases/install/oss_install/standard.py | 9 ++++++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 4dd7e8e4..69c53f76 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -77,7 +77,7 @@ def __init__(self, config, weather=None, **kwargs): self.config = self.validate_config(config) self.initialize_port() - self.setup_simulation(**kwargs) + self.setup_simulation() def setup_simulation(self): """ diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index f3da2a3f..f931bc24 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -9,7 +9,6 @@ import simpy from marmot import process -from ORBIT.core import Vessel from ORBIT.core.logic import shuttle_items_to_queue, prep_for_site_operations from ORBIT.phases.install import InstallPhase from ORBIT.phases.install.monopile_install.common import ( @@ -48,7 +47,7 @@ class OffshoreSubstationInstallation(InstallPhase): "unit_cost": "USD", }, "offshore_substation_substructure": { - "type": "Monopile", + "type": "str", "deck_space": "m2", "mass": "t", "length": "m", @@ -257,7 +256,11 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): start = vessel.env.now yield queue.activate delay_time = vessel.env.now - start - vessel.submit_action_log("Delay: Not enough vessels for oss", delay_time, location="Site") + vessel.submit_action_log( + "Delay: Not enough vessels for oss", + delay_time, + location="Site", + ) # Transit to port vessel.at_site = False From 6d8e4111d9b4142b46b920c5717d393e42689bf3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 12:40:48 -0600 Subject: [PATCH 169/240] Cleaned up line length and mass calc and included TLP option --- ORBIT/phases/design/mooring_system_design.py | 59 ++++++++++++-------- 1 file changed, 36 insertions(+), 23 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 43fa6d91..384139d7 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -24,7 +24,8 @@ class MooringSystemDesign(DesignPhase): "anchor_type": "str (optional, default: 'Suction Pile')", "mooring_type": "str (optional, default: 'Catenary')", "mooring_line_cost_rate": "int | float (optional)", - "drag_embedment_fixed_length": "int | float (optional, default: .5km)", + "drag_embedment_fixed_length": "int (optional, default: 500m)", + "draft_depth": "int (optional, default: 20m)", "chain_density": "int | float (optional, default: 19900 kg/m**3)", "rope_density": "int | float (optional, default: 797.8 kg/m**3)", }, @@ -37,6 +38,7 @@ class MooringSystemDesign(DesignPhase): "line_mass": "t", "line_cost": "USD", "line_length": "m", + "mooring_type": "str", "anchor_mass": "t", "anchor_type": "str", "anchor_cost": "USD", @@ -130,46 +132,42 @@ def calculate_breaking_load(self): def calculate_line_length_mass(self): """ Returns the mooring line length and mass. - """ - - if self.mooring_type == "Catenary": - if self.anchor_type == "Drag Embedment": - fixed = self._design.get("drag_embedment_fixed_length", 500) - else: - fixed = 0 - - self.line_length = ( - 0.0002 * (self.depth**2) + 1.264 * self.depth + 47.776 + fixed - ) + Parameters + ---------- + drag_embedment_fixed_length + draft_depth + """ - self.line_mass = self.line_length * self.line_mass_per_m + # Add extra fixed line length for drag embedments + if self.anchor_type == "Drag Embedment": + fixed = self._design.get("drag_embedment_fixed_length", 500) else: - if self.anchor_type == "Drag Embedment": - fixed = self._design.get("drag_embedment_fixed_length", 0) + fixed = 0 - else: - fixed = 0 + draft = self._design.get("draft_depth", 20) + + if self.mooring_type == "SemiTaut": # Interpolation of rope and chain length at project depth self.chain_length = interp1d( self._semitaut_params["depths"], self._semitaut_params["chain_lengths"], - )(self.depth) + )(self.depth).item() self.rope_length = interp1d( self._semitaut_params["depths"], self._semitaut_params["rope_lengths"], - )(self.depth) + )(self.depth).item() # Rope and interpolated chain diameter at project depth rope_diameter = self._semitaut_params["rope_diameter"] chain_diameter = interp1d( self._semitaut_params["depths"], self._semitaut_params["chain_diameters"], - )(self.depth) + )(self.depth).item() - self.line_length = self.rope_length + self.chain_length + self.line_length = self.rope_length + self.chain_length + fixed chain_mass_per_m = ( self._design.get("mooring_chain_density", 19900) @@ -185,6 +183,20 @@ def calculate_line_length_mass(self): + self.rope_length * rope_mass_per_m ) / 1e3 # tonnes + elif self.mooring_type == "TLP": + + self.line_length = self.depth - draft + + self.line_mass = self.line_length * self.line_mass_per_m + + else: + + self.line_length = ( + 0.0002 * (self.depth**2) + 1.264 * self.depth + 47.776 + fixed + ) + + self.line_mass = self.line_length * self.line_mass_per_m + def calculate_anchor_mass_cost(self): """ Returns the mass and cost of anchors. @@ -213,7 +225,7 @@ def calculate_anchor_mass_cost(self): self.anchor_cost = interp1d( self._semitaut_params["depths"], self._semitaut_params["anchor_costs"], - )(self.depth) + )(self.depth).item() @property def line_cost(self): @@ -227,7 +239,7 @@ def line_cost(self): line_cost = interp1d( self._semitaut_params["depths"], self._semitaut_params["total_line_costs"], - )(self.depth) + )(self.depth).item() return line_cost @@ -251,6 +263,7 @@ def detailed_output(self): "line_mass": self.line_mass, "line_length": self.line_length, "line_cost": self.line_cost, + "mooring_type": self.mooring_type, "anchor_type": self.anchor_type, "anchor_mass": self.anchor_mass, "anchor_cost": self.anchor_cost, From b36453f3effacfa189c108752b71e9a6b8aa1430 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 14:52:43 -0600 Subject: [PATCH 170/240] Rearranged floating or fixed logic. Set substructure length=0 for floating --- ORBIT/phases/design/electrical_export.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 19635a04..9c10bce8 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -188,8 +188,7 @@ def run(self): self.calc_onshore_cost() self._outputs["offshore_substation_substructure"] = { - "type": self.substructure_type, # Substation install - # only supports monopiles + "type": self.substructure_type, "deck_space": self.substructure_deck_space, "mass": self.substructure_mass, "length": self.substructure_length, @@ -531,10 +530,11 @@ def calc_substructure_mass_and_cost(self): # for different substructure types substructure_mass = 0.4 * self.topside_mass - if self.substructure_type == "Monopile": - substructure_pile_mass = 8 * substructure_mass**0.5574 + if self.substructure_type == "Floating": + substructure_pile_mass = 0 # No piles used for floating platform + else: - substructure_pile_mass = 0 # Assume floating and no piles are used + substructure_pile_mass = 8 * substructure_mass**0.5574 self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate @@ -548,7 +548,11 @@ def calc_substructure_length(self): Calculates substructure length as the site depth + 10m """ - self.substructure_length = self.config["site"]["depth"] + 10 + if self.substructure_type == "Floating": + self.substructure_length = 0 + + else: + self.substructure_length = self.config["site"]["depth"] + 10 def calc_substructure_deck_space(self): """ From 1bf24728c170d50d96b6ab95a04d45b2531550a7 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 14:54:30 -0600 Subject: [PATCH 171/240] Rearranged mooring type logic to default to catenary --- ORBIT/phases/design/mooring_system_design.py | 38 +++++++++++++------- 1 file changed, 26 insertions(+), 12 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 384139d7..f02240f9 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -100,6 +100,8 @@ def run(self): def determine_mooring_line(self): """ Returns the diameter of the mooring lines based on the turbine rating. + + TODO: Add TLP option and consider merging SemiTaut interp here """ tr = self.config["turbine"]["turbine_rating"] @@ -133,6 +135,8 @@ def calculate_line_length_mass(self): """ Returns the mooring line length and mass. + TODO: Improve TLP line length and mass + Parameters ---------- drag_embedment_fixed_length @@ -203,44 +207,54 @@ def calculate_anchor_mass_cost(self): TODO: Anchor masses are rough estimates based on initial literature review. Should be revised when this module is overhauled in the future. + TODO: Mooring types for Catenary, TLP, SemiTaut will likely have + different anchors. """ - if self.mooring_type == "Catenary": + if self.mooring_type == "SemiTaut": + if self.anchor_type == "Drag Embedment": self.anchor_mass = 20 - self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 + + # Interpolation of anchor cost at project depth + self.anchor_cost = interp1d( + self._semitaut_params["depths"], + self._semitaut_params["anchor_costs"], + )(self.depth).item() else: self.anchor_mass = 50 self.anchor_cost = ( sqrt(self.breaking_load / 9.81 / 1250) * 150000 ) + else: + if self.anchor_type == "Drag Embedment": self.anchor_mass = 20 + self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 else: self.anchor_mass = 50 - - self.anchor_cost = interp1d( - self._semitaut_params["depths"], - self._semitaut_params["anchor_costs"], - )(self.depth).item() + self.anchor_cost = ( + sqrt(self.breaking_load / 9.81 / 1250) * 150000 + ) @property def line_cost(self): """Returns cost of one line mooring line.""" - if self.mooring_type == "Catenary": - line_cost = self.line_length * self.line_cost_rate - - else: - + if self.mooring_type == "SemiTaut": + # Interpolation of line cost at project depth line_cost = interp1d( self._semitaut_params["depths"], self._semitaut_params["total_line_costs"], )(self.depth).item() + else: + + line_cost = self.line_length * self.line_cost_rate + return line_cost @property From c358c3d03ea66e54eeb4a7ad282b316847652338 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 16:38:19 -0600 Subject: [PATCH 172/240] Made interp1d extrapolate outside range and connected mooring_list_cost_rate kwarg. Updated tests --- ORBIT/phases/design/mooring_system_design.py | 13 ++- .../design/test_mooring_system_design.py | 88 ++++++++++++++++++- 2 files changed, 96 insertions(+), 5 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index f02240f9..1fb11678 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -104,23 +104,25 @@ def determine_mooring_line(self): TODO: Add TLP option and consider merging SemiTaut interp here """ + _design = self.config.get("mooring_system_design", {}) + tr = self.config["turbine"]["turbine_rating"] fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 if fit <= 0.09: self.line_diam = 0.09 self.line_mass_per_m = 0.161 - self.line_cost_rate = 399.0 + self.line_cost_rate = _design.get("mooring_line_cost_rate", 399.0) elif fit <= 0.12: self.line_diam = 0.12 self.line_mass_per_m = 0.288 - self.line_cost_rate = 721.0 + self.line_cost_rate = _design.get("mooring_line_cost_rate", 721.0) else: self.line_diam = 0.15 self.line_mass_per_m = 0.450 - self.line_cost_rate = 1088.0 + self.line_cost_rate = _design.get("mooring_line_cost_rate", 1088.0) def calculate_breaking_load(self): """ @@ -158,10 +160,12 @@ def calculate_line_length_mass(self): self.chain_length = interp1d( self._semitaut_params["depths"], self._semitaut_params["chain_lengths"], + fill_value="extrapolate", )(self.depth).item() self.rope_length = interp1d( self._semitaut_params["depths"], self._semitaut_params["rope_lengths"], + fill_value="extrapolate", )(self.depth).item() # Rope and interpolated chain diameter at project depth @@ -169,6 +173,7 @@ def calculate_line_length_mass(self): chain_diameter = interp1d( self._semitaut_params["depths"], self._semitaut_params["chain_diameters"], + fill_value="extrapolate", )(self.depth).item() self.line_length = self.rope_length + self.chain_length + fixed @@ -220,6 +225,7 @@ def calculate_anchor_mass_cost(self): self.anchor_cost = interp1d( self._semitaut_params["depths"], self._semitaut_params["anchor_costs"], + fill_value="extrapolate", )(self.depth).item() else: @@ -249,6 +255,7 @@ def line_cost(self): line_cost = interp1d( self._semitaut_params["depths"], self._semitaut_params["total_line_costs"], + fill_value="extrapolate", )(self.depth).item() else: diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index 88a7a747..cd4261e2 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -10,12 +10,16 @@ import pytest -from ORBIT.phases.design import MooringSystemDesign +from ORBIT.phases.design import ( + MooringSystemDesign, + SemiTaut_mooring_system_design, +) base = { "site": {"depth": 200}, "turbine": {"turbine_rating": 6}, "plant": {"num_turbines": 50}, + "mooring_system_design": {}, } @@ -33,7 +37,7 @@ def test_depth_sweep(depth): @pytest.mark.parametrize("rating", range(3, 15, 1)) -def test_rating_sweeip(rating): +def test_rating_sweep(rating): config = deepcopy(base) config["turbine"]["turbine_rating"] = rating @@ -45,6 +49,86 @@ def test_rating_sweeip(rating): assert m.total_cost +def test_catenary_mooring_system_kwargs(): + + test_kwargs = { + "num_lines": 6, + "anchor_type": "Drag Embedment", + "mooring_line_cost_rate": 2500, + } + + m = MooringSystemDesign(base) + m.run() + + base_cost = m.detailed_output["system_cost"] + + for k, v in test_kwargs.items(): + config = deepcopy(base) + config["mooring_system_design"] = {} + config["mooring_system_design"][k] = v + + m = MooringSystemDesign(config) + m.run() + + assert m.detailed_output["system_cost"] != base_cost + + +def test_semitaut_mooring_system_kwargs(): + + semi_base = deepcopy(base) + semi_base["mooring_system_design"]["mooring_type"] = "SemiTaut" + + test_kwargs = { + "num_lines": 6, + "anchor_type": "Drag Embedment", + "chain_density": 10000, + "rope_density": 1000, + } + + m = MooringSystemDesign(semi_base) + m.run() + + base_cost = m.detailed_output["system_cost"] + + for k, v in test_kwargs.items(): + config = deepcopy(semi_base) + config["mooring_system_design"] = {} + config["mooring_system_design"][k] = v + + m = MooringSystemDesign(config) + m.run() + + assert m.detailed_output["system_cost"] != base_cost + + +def test_tlp_mooring_system_kwargs(): + + tlp_base = deepcopy(base) + tlp_base["mooring_system_design"]["mooring_type"] = "TLP" + + test_kwargs = { + "num_lines": 6, + "anchor_type": "Drag Embedment", + "mooring_line_cost_rate": 2500, + "draft_depth": 10, + } + + m = MooringSystemDesign(tlp_base) + m.run() + + base_cost = m.detailed_output["system_cost"] + + for k, v in test_kwargs.items(): + config = deepcopy(tlp_base) + config["mooring_system_design"] = {} + config["mooring_system_design"][k] = v + + m = MooringSystemDesign(config) + m.run() + + assert m.detailed_output["system_cost"] != base_cost + + def test_drag_embedment_fixed_length(): m = MooringSystemDesign(base) From eaee68a23563ab2fd495a6cd95c964f2e34dd2a1 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 31 May 2024 17:28:45 -0600 Subject: [PATCH 173/240] Updated floating example and config yaml --- examples/5. Example Floating Project.ipynb | 1138 +++++++++-------- .../configs/example_floating_project.yaml | 20 +- 2 files changed, 604 insertions(+), 554 deletions(-) diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 8c8c12d6..7513d223 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -1,560 +1,604 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Jake Nunemaker\n", - "\n", - "National Renewable Energy Lab\n", - "\n", - "Last updated: 12/23/2020" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "from ORBIT import ProjectManager, load_config\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" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num turbines: 50\n", - "Turbine: 12MW_generic\n", - "\n", - "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" - ] - } - ], - "source": [ - "fixed_config = load_config(\"configs/example_floating_project.yaml\") \n", - "\n", - "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", - "print(f\"Turbine: {fixed_config['turbine']}\")\n", - "print(f\"\\nSite: {fixed_config['site']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Phases" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Example Floating Project\n", + "\n", + "This tutorial uses prepared ORBIT configs that are stored as .yaml files in the `~/configs/` folder. These example projects each exhibit different functionalities within ORBIT. Using these examples and combinations of them, most project configurations can be modeled. \n", + "\n", + "Last updated: May 2024" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design phases: ['ArraySystemDesign', 'ExportSystemDesign', 'MooringSystemDesign', 'OffshoreSubstationDesign', 'SemiSubmersibleDesign']\n", - "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'OffshoreSubstationInstallation', 'TurbineInstallation']\n" - ] - } - ], - "source": [ - "print(f\"Design phases: {fixed_config['design_phases']}\")\n", - "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_74288/2795185578.py:8\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 pandas as pd\n", + "from pprint import pprint\n", + "from ORBIT import ProjectManager, load_config\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"default\")\n", + "\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at 'C:\\Users\\rrolph\\OneDrive - NREL\\ORBIT\\library'\n" - ] - } - ], - "source": [ - "project = ProjectManager(fixed_config, weather=weather)\n", - "project.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Top Level Outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the project configuration\n", + "`~/configs/example_floating_project.yaml`" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 420 M\n", - "System CapEx: 1222 M\n", - "Turbine CapEx: 780 M\n", - "Soft CapEx: 387 M\n", - "Total CapEx: 2960 M\n", - "\n", - "Installation Time: 27734 h\n" - ] - } - ], - "source": [ - "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", - "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", - "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", - "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", - "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", - "\n", - "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### CapEx Breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num turbines: 50\n", + "Turbine: 12MW_generic\n", + "\n", + "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" + ] + } + ], + "source": [ + "floating_config = load_config(\"configs/example_floating_project.yaml\")\n", + "\n", + "print(f\"Num turbines: {floating_config['plant']['num_turbines']}\")\n", + "print(f\"Turbine: {floating_config['turbine']}\")\n", + "print(f\"\\nSite: {floating_config['site']}\")" + ] + }, { - "data": { - "text/plain": [ - "{'Array System': 94.97179434403438,\n", - " 'Export System': 172.854128192,\n", - " 'Substructure': 1051.1827276666668,\n", - " 'Mooring System': 552.2987080136722,\n", - " 'Offshore Substation': 165.7985,\n", - " 'Array System Installation': 38.07421316011877,\n", - " 'Export System Installation': 225.18709674508716,\n", - " 'Substructure Installation': 130.9485334221207,\n", - " 'Mooring System Installation': 83.49086757990867,\n", - " 'Offshore Substation Installation': 9.165548186199898,\n", - " 'Turbine Installation': 212.89678462709279,\n", - " 'Turbine': 1300.0,\n", - " 'Soft': 645.0,\n", - " 'Project': 252.08333333333334}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Phases" ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown_per_kw" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Installation Actions" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "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_multiplieragentactiondurationcostleveltimephaselocationsite_depthhub_heightphase_namemax_waveheightmax_windspeedtransit_speednum_vessels
00.5Array Cable Installation VesselMobilize72.0000001.800000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000001.800000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.075454e+08ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaNNaN
40.5Heavy Lift VesselMobilize72.0000007.500000e+05ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaNNaN
...................................................
4397NaNMulti-Purpose Support VesselConnect Mooring Lines, Pre-tension and pre-str...20.0000008.333333e+04ACTION8544.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4398NaNMulti-Purpose Support VesselCheck Mooring Lines6.0000002.500000e+04ACTION8550.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4399NaNTowing Group 1Positioning Support34.0000008.500000e+04ACTION8550.500000MooredSubInstallationsiteNaNNaNNaNNaNNaNNaN2.0
4400NaNMulti-Purpose Support VesselTransit10.0000004.166667e+04ACTION8560.500000MooredSubInstallationNaNNaNNaNNaNNaNNaNNaNNaN
4401NaNTowing Group 1Transit16.6666676.250000e+04ACTION8567.166667MooredSubInstallationNaNNaNNaNNaNNaNNaNNaN3.0
\n", - "

4402 rows × 16 columns

\n", - "
" + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'MooringSystemDesign', 'OffshoreFloatingSubstationDesign', 'SemiSubmersibleDesign']\n", + "\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" + ] + } ], - "text/plain": [ - " cost_multiplier agent \\\n", - "0 0.5 Array Cable Installation Vessel \n", - "1 0.5 Export Cable Installation Vessel \n", - "2 NaN Onshore Construction \n", - "3 1.0 Mooring System Installation Vessel \n", - "4 0.5 Heavy Lift Vessel \n", - "... ... ... \n", - "4397 NaN Multi-Purpose Support Vessel \n", - "4398 NaN Multi-Purpose Support Vessel \n", - "4399 NaN Towing Group 1 \n", - "4400 NaN Multi-Purpose Support Vessel \n", - "4401 NaN Towing Group 1 \n", - "\n", - " action duration \\\n", - "0 Mobilize 72.000000 \n", - "1 Mobilize 72.000000 \n", - "2 Onshore Construction 0.000000 \n", - "3 Mobilize 168.000000 \n", - "4 Mobilize 72.000000 \n", - "... ... ... \n", - "4397 Connect Mooring Lines, Pre-tension and pre-str... 20.000000 \n", - "4398 Check Mooring Lines 6.000000 \n", - "4399 Positioning Support 34.000000 \n", - "4400 Transit 10.000000 \n", - "4401 Transit 16.666667 \n", - "\n", - " cost level time phase \\\n", - "0 1.800000e+05 ACTION 0.000000 ArrayCableInstallation \n", - "1 1.800000e+05 ACTION 0.000000 ExportCableInstallation \n", - "2 1.075454e+08 ACTION 0.000000 ExportCableInstallation \n", - "3 7.000000e+05 ACTION 0.000000 MooringSystemInstallation \n", - "4 7.500000e+05 ACTION 0.000000 OffshoreSubstationInstallation \n", - "... ... ... ... ... \n", - "4397 8.333333e+04 ACTION 8544.500000 MooredSubInstallation \n", - "4398 2.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4399 8.500000e+04 ACTION 8550.500000 MooredSubInstallation \n", - "4400 4.166667e+04 ACTION 8560.500000 MooredSubInstallation \n", - "4401 6.250000e+04 ACTION 8567.166667 MooredSubInstallation \n", - "\n", - " location site_depth hub_height phase_name max_waveheight \\\n", - "0 NaN NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN NaN \n", - "2 Landfall NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN NaN \n", - "... ... ... ... ... ... \n", - "4397 NaN NaN NaN NaN NaN \n", - "4398 NaN NaN NaN NaN NaN \n", - "4399 site NaN NaN NaN NaN \n", - "4400 NaN NaN NaN NaN NaN \n", - "4401 NaN NaN NaN NaN NaN \n", - "\n", - " max_windspeed transit_speed num_vessels \n", - "0 NaN NaN NaN \n", - "1 NaN NaN NaN \n", - "2 NaN NaN NaN \n", - "3 NaN NaN NaN \n", - "4 NaN NaN NaN \n", - "... ... ... ... \n", - "4397 NaN NaN NaN \n", - "4398 NaN NaN NaN \n", - "4399 NaN NaN 2.0 \n", - "4400 NaN NaN NaN \n", - "4401 NaN NaN 3.0 \n", - "\n", - "[4402 rows x 16 columns]" + "source": [ + "print(f\"Design phases: {floating_config['design_phases']}\")\n", + "print(f\"\\nInstall phases: {list(floating_config['install_phases'].keys())}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/nriccobo/GitHub/ORBIT/library'\n", + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" + ] + } + ], + "source": [ + "project = ProjectManager(floating_config, weather=weather)\n", + "project.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top Level Outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 392 M\n", + "System CapEx: 1333 M\n", + "Turbine CapEx: 780 M\n", + "Soft CapEx: 387 M\n", + "Total CapEx: 3043 M\n", + "\n", + "Installation Time: 35527 h\n" + ] + } + ], + "source": [ + "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", + "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", + "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", + "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", + "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", + "\n", + "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 94.97179434403438,\n", + " 'Export System': 432.13532047999996,\n", + " 'Substructure': 1051.1827276666668,\n", + " 'Mooring System': 545.7798,\n", + " 'Offshore Substation': 97.56143656207396,\n", + " 'Array System Installation': 105.04624474280226,\n", + " 'Export System Installation': 246.79354615177581,\n", + " 'Substructure Installation': 208.2509277379141,\n", + " 'Mooring System Installation': 80.80888508371386,\n", + " 'Offshore Substation Installation': 11.784658802638255,\n", + " 'Turbine': 1300.0,\n", + " 'Soft': 645.0,\n", + " 'Project': 252.08333333333334}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.capex_breakdown_per_kw" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Actions" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
cost_multiplieragentactiondurationcostleveltimephaselocationphase_namemax_waveheightmax_windspeedtransit_speednum_vesselsnum_ahts_vessels
00.5Array Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.665604e+06ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSubstation Assembly Line 1Substation Substructure Assembly0.0000000.000000e+00ACTION0.000000FloatingSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
................................................
2988NaNExport Cable Installation VesselPull In Cable5.5000005.156250e+04ACTION12017.280762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2989NaNExport Cable Installation VesselTerminate Cable5.5000005.156250e+04ACTION12022.780762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2990NaNExport Cable Installation VesselTransit8.0000007.500000e+04ACTION12030.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2991NaNExport Cable Installation VesselDelay26.0000002.437500e+05ACTION12056.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2992NaNExport Cable Installation VesselTransit0.6956526.521739e+03ACTION12057.476414ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
\n", + "

2993 rows \u00d7 15 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent \\\n", + "0 0.5 Array Cable Installation Vessel \n", + "1 0.5 Export Cable Installation Vessel \n", + "2 NaN Onshore Construction \n", + "3 1.0 Mooring System Installation Vessel \n", + "4 NaN Substation Assembly Line 1 \n", + "... ... ... \n", + "2988 NaN Export Cable Installation Vessel \n", + "2989 NaN Export Cable Installation Vessel \n", + "2990 NaN Export Cable Installation Vessel \n", + "2991 NaN Export Cable Installation Vessel \n", + "2992 NaN Export Cable Installation Vessel \n", + "\n", + " action duration cost level \\\n", + "0 Mobilize 72.000000 3.375000e+05 ACTION \n", + "1 Mobilize 72.000000 3.375000e+05 ACTION \n", + "2 Onshore Construction 0.000000 1.665604e+06 ACTION \n", + "3 Mobilize 168.000000 7.000000e+05 ACTION \n", + "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", + "... ... ... ... ... \n", + "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", + "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", + "2990 Transit 8.000000 7.500000e+04 ACTION \n", + "2991 Delay 26.000000 2.437500e+05 ACTION \n", + "2992 Transit 0.695652 6.521739e+03 ACTION \n", + "\n", + " time phase location \\\n", + "0 0.000000 ArrayCableInstallation NaN \n", + "1 0.000000 ExportCableInstallation NaN \n", + "2 0.000000 ExportCableInstallation Landfall \n", + "3 0.000000 MooringSystemInstallation NaN \n", + "4 0.000000 FloatingSubstationInstallation NaN \n", + "... ... ... ... \n", + "2988 12017.280762 ExportCableInstallation NaN \n", + "2989 12022.780762 ExportCableInstallation NaN \n", + "2990 12030.780762 ExportCableInstallation NaN \n", + "2991 12056.780762 ExportCableInstallation NaN \n", + "2992 12057.476414 ExportCableInstallation NaN \n", + "\n", + " phase_name max_waveheight max_windspeed transit_speed \\\n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2988 ExportCableInstallation NaN NaN NaN \n", + "2989 ExportCableInstallation NaN NaN NaN \n", + "2990 NaN NaN NaN NaN \n", + "2991 NaN NaN NaN NaN \n", + "2992 NaN NaN NaN NaN \n", + "\n", + " num_vessels num_ahts_vessels \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "... ... ... \n", + "2988 NaN NaN \n", + "2989 NaN NaN \n", + "2990 NaN NaN \n", + "2991 NaN NaN \n", + "2992 NaN NaN \n", + "\n", + "[2993 rows x 15 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(project.actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'deck_space': 1,\n", + " 'length': 0,\n", + " 'mass': 1192.0,\n", + " 'type': 'Floating',\n", + " 'unit_cost': 3576000.0}\n", + "{'anchor_cost': 139426.2,\n", + " 'anchor_mass': 20,\n", + " 'anchor_type': 'Drag Embedment',\n", + " 'line_cost': 1497913.2,\n", + " 'line_diam': 0.15,\n", + " 'line_length': 2255.71,\n", + " 'line_mass': 579.8762530880001,\n", + " 'mooring_type': 'SemiTaut',\n", + " 'num_lines': 4,\n", + " 'system_cost': 327467880.0}\n", + "'Mooring System: $/kW'\n", + "545.7798\n", + "80.80888508371386\n" + ] + } + ], + "source": [ + "pprint(project.design_results[\"offshore_substation_substructure\"])\n", + "pprint(project.design_results[\"mooring_system\"])\n", + "\n", + "pprint(\"Mooring System: $/kW\")\n", + "pprint(project.capex_breakdown_per_kw['Mooring System'])\n", + "\n", + "pprint(project.capex_breakdown_per_kw['Mooring System Installation'])" ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" } - ], - "source": [ - "pd.DataFrame(project.actions)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" + ], + "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.8.18" + } }, - "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.9.15" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/configs/example_floating_project.yaml b/examples/configs/example_floating_project.yaml index baad61c0..36769569 100644 --- a/examples/configs/example_floating_project.yaml +++ b/examples/configs/example_floating_project.yaml @@ -19,6 +19,7 @@ export_cable_install_vessel: example_cable_lay_vessel mooring_install_vessel: example_support_vessel oss_install_vessel: floating_heavy_lift_vessel support_vessel: example_support_vessel +ahts_vessel: example_ahts_vessel towing_vessel: example_towing_vessel towing_vessel_groups: station_keeping_vessels: 2 @@ -27,8 +28,11 @@ wtiv: floating_heavy_lift_vessel # Module Specific substructure: takt_time: 168 -OffshoreSubstationInstallation: - feeder: floating_barge +substation_design: + oss_substructure_type: Floating +mooring_system_design: + anchor_type: Drag Embedment + mooring_type: SemiTaut array_system: free_cable_length: 0.5 array_system_design: @@ -40,16 +44,18 @@ export_system_design: # Configured Phases design_phases: - ArraySystemDesign -- ExportSystemDesign +#- ExportSystemDesign +- ElectricalDesign - MooringSystemDesign -- OffshoreSubstationDesign +#- SemiTautMooringSystemDesign +- OffshoreFloatingSubstationDesign - SemiSubmersibleDesign install_phases: ArrayCableInstallation: 0 ExportCableInstallation: 0 MooredSubInstallation: 0 MooringSystemInstallation: 0 - OffshoreSubstationInstallation: 0 - TurbineInstallation: 0 + FloatingSubstationInstallation: 0 +# TurbineInstallation: 0 # Project Inputs -turbine: 12MW_generic +turbine: 15MW_generic From adc16712b15b6e687bde16706b5949806a638dd3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 3 Jun 2024 11:39:25 -0600 Subject: [PATCH 174/240] cleaned up fixed added length for semitaut. Updated test --- ORBIT/phases/design/mooring_system_design.py | 15 ++++++---- .../design/test_mooring_system_design.py | 29 ++++++++++++++++++- 2 files changed, 38 insertions(+), 6 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 1fb11678..bda8cb8b 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -104,25 +104,29 @@ def determine_mooring_line(self): TODO: Add TLP option and consider merging SemiTaut interp here """ - _design = self.config.get("mooring_system_design", {}) - tr = self.config["turbine"]["turbine_rating"] fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 if fit <= 0.09: self.line_diam = 0.09 self.line_mass_per_m = 0.161 - self.line_cost_rate = _design.get("mooring_line_cost_rate", 399.0) + self.line_cost_rate = self._design.get( + "mooring_line_cost_rate", 399.0 + ) elif fit <= 0.12: self.line_diam = 0.12 self.line_mass_per_m = 0.288 - self.line_cost_rate = _design.get("mooring_line_cost_rate", 721.0) + self.line_cost_rate = self._design.get( + "mooring_line_cost_rate", 721.0 + ) else: self.line_diam = 0.15 self.line_mass_per_m = 0.450 - self.line_cost_rate = _design.get("mooring_line_cost_rate", 1088.0) + self.line_cost_rate = self._design.get( + "mooring_line_cost_rate", 1088.0 + ) def calculate_breaking_load(self): """ @@ -176,6 +180,7 @@ def calculate_line_length_mass(self): fill_value="extrapolate", )(self.depth).item() + fixed = self._design.get("drag_embedment_fixed_length", 0) self.line_length = self.rope_length + self.chain_length + fixed chain_mass_per_m = ( diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index cd4261e2..93fb714b 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -12,7 +12,7 @@ from ORBIT.phases.design import ( MooringSystemDesign, - SemiTaut_mooring_system_design, + SemiTautMooringSystemDesign, ) base = { @@ -167,3 +167,30 @@ def test_custom_num_lines(): m.run() assert m.design_result["mooring_system"]["num_lines"] == 5 + + +def test_new_old_semitaut_mooring_system(): + """Temporary test until we delete the SemiTaut_mooring_system""" + + config = deepcopy(base) + config["site"]["depth"] = 900.0 + config["mooring_system_design"]["mooring_type"] = "SemiTaut" + config["mooring_system_design"]["anchor_type"] = "Drag Embedment" + + old = SemiTautMooringSystemDesign(config) + old.run() + old_anchor_cost = old.anchor_cost.item() + old_line_cost = old.line_cost.item() + + new = MooringSystemDesign(config) + new.run() + + # same values + assert old.total_cost == new.total_cost + assert old_anchor_cost == new.anchor_cost + assert old.anchor_mass == new.anchor_mass + assert old_line_cost == new.line_cost + assert old.line_length == new.line_length + + # different values + assert len(old.detailed_output) != len(new.detailed_output) From 959e46b9efaf3db8f335249089caafa62fc4aadc Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 3 Jun 2024 13:27:17 -0600 Subject: [PATCH 175/240] Updated yaml configs and example notebooks --- ...5. Example Floating Project-SemiTaut.ipynb | 1229 +++++++++-------- examples/5. Example Floating Project.ipynb | 27 +- .../configs/example_floating_project.yaml | 2 +- .../example_floating_project_SemiTaut.yaml | 2 + 4 files changed, 639 insertions(+), 621 deletions(-) diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb index edf2b103..d3090455 100644 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ b/examples/5. Example Floating Project-SemiTaut.ipynb @@ -1,627 +1,642 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Jake Nunemaker\n", - "\n", - "National Renewable Energy Lab\n", - "\n", - "Last updated: 12/23/2020" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_93742/1311156483.py:7\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", - "\n", - "import warnings\n", - "warnings.filterwarnings(\"default\")\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" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num turbines: 50\n", - "Turbine: 12MW_generic\n", - "\n", - "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" - ] - } - ], - "source": [ - "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\")\n", - "\n", - "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", - "print(f\"Turbine: {fixed_config['turbine']}\")\n", - "print(f\"\\nSite: {fixed_config['site']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Phases" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Jake Nunemaker\n", + "\n", + "National Renewable Energy Lab\n", + "\n", + "Last updated: 12/23/2020" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'SemiTautMooringSystemDesign', 'SemiSubmersibleDesign']\n", - "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" - ] - } - ], - "source": [ - "print(f\"Design phases: {fixed_config['design_phases']}\")\n", - "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")\n", - "# This now says \"SemiTautMooringSystemDesign\" in the design phases" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_31846/3472246521.py:7\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 pandas as pd\n", + "from pprint import pprint\n", + "from ORBIT import ProjectManager, load_config\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"default\")\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the project configuration" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:193\n", - "No ['ahts_vessel'] specified. num_ahts set to 0. ahts_vessel will be required in future releases.\n", - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", - "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", - "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" - ] - } - ], - "source": [ - "project = ProjectManager(fixed_config, weather=weather)\n", - "project.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Top Level Outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num turbines: 50\n", + "Turbine: 12MW_generic\n", + "\n", + "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" + ] + } + ], + "source": [ + "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\")\n", + "\n", + "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", + "print(f\"Turbine: {fixed_config['turbine']}\")\n", + "print(f\"\\nSite: {fixed_config['site']}\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 345 M\n", - "System CapEx: 1333 M\n", - "Turbine CapEx: 780 M\n", - "Soft CapEx: 387 M\n", - "Total CapEx: 2997 M\n", - "\n", - "Installation Time: 35527 h\n" - ] - } - ], - "source": [ - "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", - "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", - "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", - "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", - "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", - "\n", - "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### CapEx Breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Phases" + ] + }, { - "data": { - "text/plain": [ - "{'Array System': 56983076.60642063,\n", - " 'Export System': 259281192.288,\n", - " 'Substructure': 630709636.6,\n", - " 'Mooring System': 327467880.0,\n", - " 'Offshore Substation': 58536861.93724438,\n", - " 'Array System Installation': 63027746.845681354,\n", - " 'Export System Installation': 148076127.6910655,\n", - " 'Substructure Installation': 78801350.29354209,\n", - " 'Mooring System Installation': 48485331.05022831,\n", - " 'Offshore Substation Installation': 7070795.281582953,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'SemiTautMooringSystemDesign', 'SemiSubmersibleDesign']\n", + "\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" + ] + } + ], + "source": [ + "print(f\"Design phases: {fixed_config['design_phases']}\")\n", + "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")\n", + "# This now says \"SemiTautMooringSystemDesign\" in the design phases" ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ + }, { - "data": { - "text/plain": [ - "{'Array System': 94.97179434403438,\n", - " 'Export System': 432.13532047999996,\n", - " 'Substructure': 1051.1827276666668,\n", - " 'Mooring System': 545.7798,\n", - " 'Offshore Substation': 97.56143656207396,\n", - " 'Array System Installation': 105.04624474280226,\n", - " 'Export System Installation': 246.79354615177581,\n", - " 'Substructure Installation': 131.33558382257016,\n", - " 'Mooring System Installation': 80.80888508371386,\n", - " 'Offshore Substation Installation': 11.784658802638255,\n", - " 'Turbine': 1300.0,\n", - " 'Soft': 645.0,\n", - " 'Project': 252.08333333333334}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run" ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown_per_kw" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Installation Actions" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "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", - "
cost_multiplieragentactiondurationcostleveltimephaselocationphase_namemax_waveheightmax_windspeedtransit_speednum_vesselsnum_ahts_vessels
00.5Array Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.665604e+06ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSubstation Assembly Line 1Substation Substructure Assembly0.0000000.000000e+00ACTION0.000000FloatingSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
................................................
2988NaNExport Cable Installation VesselPull In Cable5.5000005.156250e+04ACTION12017.280762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2989NaNExport Cable Installation VesselTerminate Cable5.5000005.156250e+04ACTION12022.780762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2990NaNExport Cable Installation VesselTransit8.0000007.500000e+04ACTION12030.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2991NaNExport Cable Installation VesselDelay26.0000002.437500e+05ACTION12056.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2992NaNExport Cable Installation VesselTransit0.6956526.521739e+03ACTION12057.476414ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
\n", - "

2993 rows × 15 columns

\n", - "
" + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:193\n", + "No ['ahts_vessel'] specified. num_ahts set to 0. ahts_vessel will be required in future releases.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" + ] + } ], - "text/plain": [ - " cost_multiplier agent \\\n", - "0 0.5 Array Cable Installation Vessel \n", - "1 0.5 Export Cable Installation Vessel \n", - "2 NaN Onshore Construction \n", - "3 1.0 Mooring System Installation Vessel \n", - "4 NaN Substation Assembly Line 1 \n", - "... ... ... \n", - "2988 NaN Export Cable Installation Vessel \n", - "2989 NaN Export Cable Installation Vessel \n", - "2990 NaN Export Cable Installation Vessel \n", - "2991 NaN Export Cable Installation Vessel \n", - "2992 NaN Export Cable Installation Vessel \n", - "\n", - " action duration cost level \\\n", - "0 Mobilize 72.000000 3.375000e+05 ACTION \n", - "1 Mobilize 72.000000 3.375000e+05 ACTION \n", - "2 Onshore Construction 0.000000 1.665604e+06 ACTION \n", - "3 Mobilize 168.000000 7.000000e+05 ACTION \n", - "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", - "... ... ... ... ... \n", - "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", - "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", - "2990 Transit 8.000000 7.500000e+04 ACTION \n", - "2991 Delay 26.000000 2.437500e+05 ACTION \n", - "2992 Transit 0.695652 6.521739e+03 ACTION \n", - "\n", - " time phase location \\\n", - "0 0.000000 ArrayCableInstallation NaN \n", - "1 0.000000 ExportCableInstallation NaN \n", - "2 0.000000 ExportCableInstallation Landfall \n", - "3 0.000000 MooringSystemInstallation NaN \n", - "4 0.000000 FloatingSubstationInstallation NaN \n", - "... ... ... ... \n", - "2988 12017.280762 ExportCableInstallation NaN \n", - "2989 12022.780762 ExportCableInstallation NaN \n", - "2990 12030.780762 ExportCableInstallation NaN \n", - "2991 12056.780762 ExportCableInstallation NaN \n", - "2992 12057.476414 ExportCableInstallation NaN \n", - "\n", - " phase_name max_waveheight max_windspeed transit_speed \\\n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "2988 ExportCableInstallation NaN NaN NaN \n", - "2989 ExportCableInstallation NaN NaN NaN \n", - "2990 NaN NaN NaN NaN \n", - "2991 NaN NaN NaN NaN \n", - "2992 NaN NaN NaN NaN \n", - "\n", - " num_vessels num_ahts_vessels \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 NaN NaN \n", - "4 NaN NaN \n", - "... ... ... \n", - "2988 NaN NaN \n", - "2989 NaN NaN \n", - "2990 NaN NaN \n", - "2991 NaN NaN \n", - "2992 NaN NaN \n", - "\n", - "[2993 rows x 15 columns]" + "source": [ + "project = ProjectManager(fixed_config, weather=weather)\n", + "project.run()" ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.DataFrame(project.actions)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top Level Outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 345 M\n", + "System CapEx: 1333 M\n", + "Turbine CapEx: 780 M\n", + "Soft CapEx: 387 M\n", + "Total CapEx: 2997 M\n", + "\n", + "Installation Time: 35527 h\n" + ] + } + ], + "source": [ + "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", + "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", + "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", + "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", + "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", + "\n", + "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 56983076.60642063,\n", + " 'Export System': 259281192.288,\n", + " 'Substructure': 630709636.6,\n", + " 'Mooring System': 327467880.0,\n", + " 'Offshore Substation': 58536861.93724438,\n", + " 'Array System Installation': 63027746.845681354,\n", + " 'Export System Installation': 148076127.6910655,\n", + " 'Substructure Installation': 78801350.29354209,\n", + " 'Mooring System Installation': 48485331.05022831,\n", + " 'Offshore Substation Installation': 7070795.281582953,\n", + " 'Turbine': 780000000,\n", + " 'Soft': 387000000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.capex_breakdown" + ] + }, { - "data": { - "text/plain": [ - "{'type': 'Monopile',\n", - " 'deck_space': 1,\n", - " 'mass': 1606.7690784724548,\n", - " 'length': 910,\n", - " 'unit_cost': 3576000.0}" + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 94.97179434403438,\n", + " 'Export System': 432.13532047999996,\n", + " 'Substructure': 1051.1827276666668,\n", + " 'Mooring System': 545.7798,\n", + " 'Offshore Substation': 97.56143656207396,\n", + " 'Array System Installation': 105.04624474280226,\n", + " 'Export System Installation': 246.79354615177581,\n", + " 'Substructure Installation': 131.33558382257016,\n", + " 'Mooring System Installation': 80.80888508371386,\n", + " 'Offshore Substation Installation': 11.784658802638255,\n", + " 'Turbine': 1300.0,\n", + " 'Soft': 645.0,\n", + " 'Project': 252.08333333333334}" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.capex_breakdown_per_kw" ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Actions" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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", + "
cost_multiplieragentactiondurationcostleveltimephaselocationphase_namemax_waveheightmax_windspeedtransit_speednum_vesselsnum_ahts_vessels
00.5Array Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.665604e+06ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSubstation Assembly Line 1Substation Substructure Assembly0.0000000.000000e+00ACTION0.000000FloatingSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
................................................
2988NaNExport Cable Installation VesselPull In Cable5.5000005.156250e+04ACTION12017.280762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2989NaNExport Cable Installation VesselTerminate Cable5.5000005.156250e+04ACTION12022.780762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2990NaNExport Cable Installation VesselTransit8.0000007.500000e+04ACTION12030.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2991NaNExport Cable Installation VesselDelay26.0000002.437500e+05ACTION12056.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2992NaNExport Cable Installation VesselTransit0.6956526.521739e+03ACTION12057.476414ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
\n", + "

2993 rows \u00d7 15 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent \\\n", + "0 0.5 Array Cable Installation Vessel \n", + "1 0.5 Export Cable Installation Vessel \n", + "2 NaN Onshore Construction \n", + "3 1.0 Mooring System Installation Vessel \n", + "4 NaN Substation Assembly Line 1 \n", + "... ... ... \n", + "2988 NaN Export Cable Installation Vessel \n", + "2989 NaN Export Cable Installation Vessel \n", + "2990 NaN Export Cable Installation Vessel \n", + "2991 NaN Export Cable Installation Vessel \n", + "2992 NaN Export Cable Installation Vessel \n", + "\n", + " action duration cost level \\\n", + "0 Mobilize 72.000000 3.375000e+05 ACTION \n", + "1 Mobilize 72.000000 3.375000e+05 ACTION \n", + "2 Onshore Construction 0.000000 1.665604e+06 ACTION \n", + "3 Mobilize 168.000000 7.000000e+05 ACTION \n", + "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", + "... ... ... ... ... \n", + "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", + "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", + "2990 Transit 8.000000 7.500000e+04 ACTION \n", + "2991 Delay 26.000000 2.437500e+05 ACTION \n", + "2992 Transit 0.695652 6.521739e+03 ACTION \n", + "\n", + " time phase location \\\n", + "0 0.000000 ArrayCableInstallation NaN \n", + "1 0.000000 ExportCableInstallation NaN \n", + "2 0.000000 ExportCableInstallation Landfall \n", + "3 0.000000 MooringSystemInstallation NaN \n", + "4 0.000000 FloatingSubstationInstallation NaN \n", + "... ... ... ... \n", + "2988 12017.280762 ExportCableInstallation NaN \n", + "2989 12022.780762 ExportCableInstallation NaN \n", + "2990 12030.780762 ExportCableInstallation NaN \n", + "2991 12056.780762 ExportCableInstallation NaN \n", + "2992 12057.476414 ExportCableInstallation NaN \n", + "\n", + " phase_name max_waveheight max_windspeed transit_speed \\\n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2988 ExportCableInstallation NaN NaN NaN \n", + "2989 ExportCableInstallation NaN NaN NaN \n", + "2990 NaN NaN NaN NaN \n", + "2991 NaN NaN NaN NaN \n", + "2992 NaN NaN NaN NaN \n", + "\n", + " num_vessels num_ahts_vessels \n", + "0 NaN NaN \n", + "1 NaN NaN \n", + "2 NaN NaN \n", + "3 NaN NaN \n", + "4 NaN NaN \n", + "... ... ... \n", + "2988 NaN NaN \n", + "2989 NaN NaN \n", + "2990 NaN NaN \n", + "2991 NaN NaN \n", + "2992 NaN NaN \n", + "\n", + "[2993 rows x 15 columns]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame(project.actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'deck_space': 1,\n", + " 'length': 0,\n", + " 'mass': 1192.0,\n", + " 'type': 'Floating',\n", + " 'unit_cost': 3576000.0}\n", + "{'deck_space': 1, 'mass': 2980.0, 'unit_cost': 48411504.33724438}\n", + "{'anchor_cost': array(139426.2),\n", + " 'anchor_mass': 20,\n", + " 'anchor_type': 'Drag Embedment',\n", + " 'line_cost': array(1497913.2),\n", + " 'line_length': 1755.71,\n", + " 'line_mass': 579.8762530880001,\n", + " 'num_lines': 4,\n", + " 'system_cost': 327467880.0}\n", + "'Mooring System: $/kW'\n", + "545.7798\n", + "80.80888508371386\n" + ] + } + ], + "source": [ + "pprint(project.design_results[\"offshore_substation_substructure\"])\n", + "pprint(project.design_results[\"offshore_substation_topside\"])\n", + "pprint(project.design_results[\"mooring_system\"])\n", + "\n", + "pprint(\"Mooring System: $/kW\")\n", + "pprint(project.capex_breakdown_per_kw['Mooring System'])\n", + "pprint(project.capex_breakdown_per_kw['Mooring System Installation'])" + ] + } + ], + "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.8.18" } - ], - "source": [ - "project.design_results[\"offshore_substation_substructure\"]" - ] - } - ], - "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.8.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 7513d223..09b98d0b 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -13,14 +13,14 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_74288/2795185578.py:8\n", + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_32264/2795185578.py:8\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." ] } @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -105,14 +105,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at '/Users/nriccobo/GitHub/ORBIT/library'\n", "2\n" ] }, @@ -141,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 30, "metadata": {}, "outputs": [ { @@ -177,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -198,7 +197,7 @@ " 'Project': 252.08333333333334}" ] }, - "execution_count": 6, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -216,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -530,7 +529,7 @@ "[2993 rows x 15 columns]" ] }, - "execution_count": 7, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -541,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 33, "metadata": {}, "outputs": [ { @@ -553,12 +552,13 @@ " 'mass': 1192.0,\n", " 'type': 'Floating',\n", " 'unit_cost': 3576000.0}\n", + "{'deck_space': 1, 'mass': 2980.0, 'unit_cost': 48411504.33724438}\n", "{'anchor_cost': 139426.2,\n", " 'anchor_mass': 20,\n", " 'anchor_type': 'Drag Embedment',\n", " 'line_cost': 1497913.2,\n", " 'line_diam': 0.15,\n", - " 'line_length': 2255.71,\n", + " 'line_length': 1755.71,\n", " 'line_mass': 579.8762530880001,\n", " 'mooring_type': 'SemiTaut',\n", " 'num_lines': 4,\n", @@ -571,6 +571,7 @@ ], "source": [ "pprint(project.design_results[\"offshore_substation_substructure\"])\n", + "pprint(project.design_results[\"offshore_substation_topside\"])\n", "pprint(project.design_results[\"mooring_system\"])\n", "\n", "pprint(\"Mooring System: $/kW\")\n", diff --git a/examples/configs/example_floating_project.yaml b/examples/configs/example_floating_project.yaml index 36769569..e7d23af8 100644 --- a/examples/configs/example_floating_project.yaml +++ b/examples/configs/example_floating_project.yaml @@ -58,4 +58,4 @@ install_phases: FloatingSubstationInstallation: 0 # TurbineInstallation: 0 # Project Inputs -turbine: 15MW_generic +turbine: 12MW_generic diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml index c0890c62..cba486b6 100644 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ b/examples/configs/example_floating_project_SemiTaut.yaml @@ -29,6 +29,8 @@ wtiv: floating_heavy_lift_vessel # Module Specific substructure: takt_time: 168 +substation_design: + oss_substructure_type: Floating array_system: free_cable_length: 0.5 array_system_design: From f628d04e02173370346bd89c3a70049280fb2bbb Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 3 Jun 2024 15:11:11 -0600 Subject: [PATCH 176/240] Updated moored deprecated warnings and a test --- .../install/quayside_assembly_tow/moored.py | 19 ++++++++-------- .../quayside_assembly_tow/test_moored.py | 22 ++++++++++++++++++- 2 files changed, 31 insertions(+), 10 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 31618768..e4d8d752 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -28,12 +28,12 @@ class MooredSubInstallation(InstallPhase): #: expected_config = { - "support_vessel": "str", - "ahts_vessel": "str, (optional)", + "support_vessel": "str, (optional)", + "ahts_vessel": "str", "towing_vessel": "str", "towing_vessel_groups": { "towing_vessels": "int", - "station_keeping_vessels": "int", + "station_keeping_vessels": "int (optional)", "ahts_vessels": "int (optional, default: 1)", "num_groups": "int (optional)", }, @@ -234,7 +234,7 @@ def initialize_support_vessel(self): processes at site. """ - specs = self.config["support_vessel"] + specs = self.config.get("support_vessel", None) if specs is not None: warn( @@ -251,15 +251,16 @@ def initialize_support_vessel(self): # vessel.initialize(mobilize=False) # self.support_vessel = vessel - station_keeping_vessels = self.config["towing_vessel_groups"][ - "station_keeping_vessels" - ] + station_keeping_vessels = self.config["towing_vessel_groups"].get( + "station_keeping_vessels", None + ) if station_keeping_vessels is not None: print(station_keeping_vessels) warn( - "station_keeping_vessels will be deprecated and replaced with" - " towing_vessels and ahts_vessels in the towing groups.\n", + "['towing_vessl_groups]['station_keeping_vessels']" + " will be deprecated and replaced with" + " ['towing_vessl_groups]['ahts_vessels'].\n", DeprecationWarning, stacklevel=2, ) diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index c2ebba3f..3892495b 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -5,6 +5,8 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" +import warnings +from copy import deepcopy import pandas as pd import pytest @@ -14,6 +16,8 @@ from ORBIT.phases.install import MooredSubInstallation config = extract_library_specs("config", "moored_install") +no_supply = extract_library_specs("config", "moored_install_no_supply") + multi_assembly = extract_library_specs( "config", "moored_install_multi_assembly" ) @@ -21,7 +25,6 @@ multi_assembly_multi_tow = extract_library_specs( "config", "moored_install_multi_assembly_multi_tow" ) -no_supply = extract_library_specs("config", "moored_install_no_supply") def test_simulation_setup(): @@ -75,3 +78,20 @@ def test_for_complete_logging(weather, config): [a for a in sim.env.actions if a["action"] == "Position Substructure"] ) assert installed_mooring_lines == sim.num_turbines + + +def test_deprecated_landfall(): + + deprecated = deepcopy(config) + deprecated["support_vessel"] = "test_support_vessel" + + with pytest.deprecated_call(): + sim = MooredSubInstallation(deprecated) + sim.run() + + deprecated2 = deepcopy(config) + deprecated2["towing_vessel_groups"]["station_keeping_vessels"] = 2 + + with pytest.deprecated_call(): + sim = MooredSubInstallation(deprecated2) + sim.run() From 909ee373fd8b2b10f3745524e7c3de97190f6bd6 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 4 Jun 2024 10:26:06 -0600 Subject: [PATCH 177/240] WISDEM api test failed because of new ahts vessel logic. --- ORBIT/api/wisdem.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index f0a80256..6147c937 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -95,6 +95,11 @@ def setup(self): 3, desc="Number of station keeping vessels that attach to floating platforms under tow-out.", ) + self.add_discrete_input( + "ahts_vessels", + 1, + desc="Number of ahts vessels that attach to floating platforms under tow-out.", + ) self.add_discrete_input( "oss_install_vessel", "example_heavy_lift_vessel", @@ -378,11 +383,13 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o if floating_flag: vessels = { "support_vessel": "example_support_vessel", + "ahts_vessel" : "example_ahts_vessel", "towing_vessel": "example_towing_vessel", "mooring_install_vessel": "example_support_vessel", "towing_vessel_groups": { "towing_vessels": int(discrete_inputs["num_towing"]), "station_keeping_vessels": int(discrete_inputs["num_station_keeping"]), + "ahts_vessels" : int(discrete_inputs["ahts_vessels"]) }, } else: From d990832417e701ab67c03f25e95d8d71503469e3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 4 Jun 2024 10:40:00 -0600 Subject: [PATCH 178/240] Updated test yaml configs to deal with ahts and support vessel calls --- .../library/project/config/complete_floating_project.yaml | 1 + tests/data/library/project/config/floating_oss_install.yaml | 4 ++++ tests/data/library/project/config/moored_install.yaml | 2 ++ .../data/library/project/config/moored_install_no_supply.yaml | 2 ++ 4 files changed, 9 insertions(+) diff --git a/tests/data/library/project/config/complete_floating_project.yaml b/tests/data/library/project/config/complete_floating_project.yaml index 45fbc3ec..dff5b427 100644 --- a/tests/data/library/project/config/complete_floating_project.yaml +++ b/tests/data/library/project/config/complete_floating_project.yaml @@ -42,6 +42,7 @@ site: substructure: takt_time: 168 support_vessel: test_support_vessel +ahts_vessel: test_ahts_vessel towing_vessel: test_towing_vessel towing_vessel_groups: station_keeping_vessels: 2 diff --git a/tests/data/library/project/config/floating_oss_install.yaml b/tests/data/library/project/config/floating_oss_install.yaml index 3b10e637..816b2679 100644 --- a/tests/data/library/project/config/floating_oss_install.yaml +++ b/tests/data/library/project/config/floating_oss_install.yaml @@ -6,6 +6,10 @@ offshore_substation_substructure: mooring_cost: 5e6 offshore_substation_topside: unit_cost: 100e6 +mooring_system: + num_lines: 3 + line_cost: 1e4 + anchor_cost: 1e5 site: depth: 500 distance: 40 diff --git a/tests/data/library/project/config/moored_install.yaml b/tests/data/library/project/config/moored_install.yaml index 631f0e44..242bb802 100644 --- a/tests/data/library/project/config/moored_install.yaml +++ b/tests/data/library/project/config/moored_install.yaml @@ -13,9 +13,11 @@ substructure: towing_speed: 6 unit_cost: 12e6 ahts_vessel: test_ahts_vessel +support_vessel: test_support_vessel towing_vessel: test_towing_vessel towing_vessel_groups: num_groups: 1 ahts_vessels: 1 + station_keeping_vessels: 3 towing_vessels: 1 turbine: 12MW_generic diff --git a/tests/data/library/project/config/moored_install_no_supply.yaml b/tests/data/library/project/config/moored_install_no_supply.yaml index 57d48179..a91dd2ba 100644 --- a/tests/data/library/project/config/moored_install_no_supply.yaml +++ b/tests/data/library/project/config/moored_install_no_supply.yaml @@ -11,9 +11,11 @@ substructure: towing_speed: 6 unit_cost: 12e6 ahts_vessel: test_ahts_vessel +support_vessel: test_support_vessel towing_vessel: test_towing_vessel towing_vessel_groups: num_groups: 1 + station_keeping_vessels: 3 ahts_vessels: 1 towing_vessels: 1 turbine: 12MW_generic From b352386821d58ebf540ca52e5d2d7330c0f999a8 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 5 Jun 2024 13:31:43 -0600 Subject: [PATCH 179/240] adjusted the name and comments for this temporary class. --- .../design/SemiTaut_mooring_system_design.py | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py index b04b0887..e6db2abd 100644 --- a/ORBIT/phases/design/SemiTaut_mooring_system_design.py +++ b/ORBIT/phases/design/SemiTaut_mooring_system_design.py @@ -12,7 +12,7 @@ class SemiTautMooringSystemDesign(DesignPhase): - """Mooring System and Anchor Design.""" + """SemiTaut Mooring System and Anchor Design.""" expected_config = { "site": {"depth": "float"}, @@ -33,7 +33,7 @@ class SemiTautMooringSystemDesign(DesignPhase): "line_mass": "t", # you need this for mooring.py (mooring installation module) "line_cost": "USD", # you can calculate this based on each rope&chain length & diameter. "line_length": "m", # this can be calculated from rope length and chain length (which you get from an empirical eqn as function of depth) - "anchor_mass": "t", # you need this for mooring.py (mooring installation module) + "anchor_mass": "t", # you need this for mooring.py (mooring installation module) "anchor_type": "str", # keep, changed default to drag embedment. "anchor_cost": "USD", # this can be calculated also as a function of (depth?) from the empirical data you have. } @@ -41,7 +41,7 @@ class SemiTautMooringSystemDesign(DesignPhase): def __init__(self, config, **kwargs): """ - Creates an instance of MooringSystemDesign. + Creates an instance of SemiTautMooringSystemDesign. Parameters ---------- @@ -82,29 +82,29 @@ def calculate_line_length_mass(self): rope_diameters = np.array([0.2, 0.2, 0.2, 0.2, 0.2]) # you need the diameter for the cost data chain_lengths = np.array([917.11, 800.36, 609.07, 896.42, 1280.57]) chain_diameters = np.array([0.13, 0.17, 0.22, 0.22, 0.22]) - + # Interpolate finterp_rope = interp1d(depths, rope_lengths) finterp_chain = interp1d(depths, chain_lengths) finterp_rope_diam = interp1d(depths, rope_diameters) finterp_chain_diam = interp1d(depths, chain_diameters) - + # Rope and chain length at project depth self.chain_length = finterp_chain(depth) self.rope_length = finterp_rope(depth) # Rope and chain diameter at project depth self.rope_diameter = finterp_rope_diam(depth) self.chain_diameter = finterp_chain_diam(depth) - + self.line_length = self.rope_length + self.chain_length - + chain_kg_per_m = 19900 * (self.chain_diameter**2) # 19,900 kg/m^2 (diameter)/m (length) - rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) + rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) self.line_mass = (self.chain_length * chain_kg_per_m) + (self.rope_length * rope_kg_per_m) # kg #print('total hybrid line mass is ' + str(self.line_mass) + 'kg') # convert kg to metric tonnes self.line_mass = self.line_mass/1e3 - + def calculate_anchor_mass_cost(self): """ Returns the mass and cost of anchors. @@ -118,7 +118,7 @@ def calculate_anchor_mass_cost(self): # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California depths = np.array([500, 750, 1000, 1250, 1500]) anchor_costs = np.array([112766, 125511, 148703, 204988, 246655]) # [USD] - + # interpolate anchor cost to project depth depth = self.config["site"]["depth"] finterp_anchor_cost = interp1d(depths, anchor_costs) From 411e45bf2619abd53077a6e9818945ca44dcb4ac Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 5 Jun 2024 13:37:34 -0600 Subject: [PATCH 180/240] Added comment for oss substructure mass calcs. --- ORBIT/phases/design/electrical_export.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 9c10bce8..78404528 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -526,6 +526,10 @@ def calc_substructure_mass_and_cost(self): "oss_substructure_cost_rate", 3000 ) + # Substructure mass components calculated by curve fits in + # equations 81-84 from Maness et al. 2017 + # https://www.nrel.gov/docs/fy17osti/66874.pdf + # # TODO: Determine a better method to calculate substructure mass # for different substructure types substructure_mass = 0.4 * self.topside_mass From 50ae6a1ab60050742faf13947b1929b5eab5c8e3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 6 Jun 2024 11:16:29 -0600 Subject: [PATCH 181/240] Updated electrical design tests and fixed duplicate line in ElectricalDesign --- ORBIT/phases/design/electrical_export.py | 1 - tests/phases/design/test_electrical_design.py | 21 +++++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 78404528..0e44f83c 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -518,7 +518,6 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate : int | float """ - substructure_mass = 0.4 * self.topside_mass oss_pile_cost_rate = self.offshore_substation_design.get( "oss_pile_cost_rate", 0 ) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 5539e928..b248d28f 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -61,6 +61,20 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): assert 1e6 <= o.total_substation_cost <= 1e9 +def test_detailed_design_length(): + """Ensure that the same # of output variables are used for a floating and fixed offshore substation.""" + + o = ElectricalDesign(base) + o.run() + + floating = deepcopy(base) + floating["substation_design"]["oss_substructure_type"] = "Floating" + o_floating = ElectricalDesign(floating) + o_floating.run() + + assert len(o.detailed_output) == len(o_floating.detailed_output) + + def test_calc_substructure_mass_and_cost(): o = ElectricalDesign(base) @@ -335,6 +349,13 @@ def test_total_cable(): assert export.total_length == pytest.approx(length * 9, abs=1e-10) +def test_total_cable_cost(): + export = ElectricalDesign(config) + export.run() + + assert export.total_cable_cost == 135068310.0 + + def test_cables_property(): export = ElectricalDesign(config) export.run() From 5e27035e7ae7cf219673bd8af018837364d40ca9 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 7 Jun 2024 15:15:00 -0600 Subject: [PATCH 182/240] Updating floating example and cleaned comments in oss_floating. --- ORBIT/phases/install/oss_install/floating.py | 4 - examples/5. Example Floating Project.ipynb | 164 ++++++++++-------- .../configs/example_floating_project.yaml | 4 +- 3 files changed, 96 insertions(+), 76 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 69c53f76..53353021 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -43,13 +43,9 @@ class FloatingSubstationInstallation(InstallPhase): "type": "str", "takt_time": "int | float (optional, default: 0)", "unit_cost": "USD", - # "mooring_cost": "USD", "towing_speed": "int | float (optional, default: 6 km/h)", }, "mooring_system": { - # "system_cost": "USD", "}, - # system cost is for all moorings in the whole farm, - # so you dont want this to be added to each substation "num_lines", "int", "line_cost", diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 09b98d0b..911922e2 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -13,14 +13,14 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_32264/2795185578.py:8\n", + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_71795/2795185578.py:8\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." ] } @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -87,7 +87,7 @@ "text": [ "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'MooringSystemDesign', 'OffshoreFloatingSubstationDesign', 'SemiSubmersibleDesign']\n", "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation', 'TurbineInstallation']\n" ] } ], @@ -105,13 +105,14 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "ORBIT library intialized at '/Users/nriccobo/GitHub/ORBIT/library'\n", "2\n" ] }, @@ -122,7 +123,7 @@ "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", - "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" + "['towing_vessl_groups]['station_keeping_vessels'] will be deprecated and replaced with ['towing_vessl_groups]['ahts_vessels'].\n" ] } ], @@ -140,20 +141,20 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Installation CapEx: 392 M\n", + "Installation CapEx: 519 M\n", "System CapEx: 1333 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 3043 M\n", + "Total CapEx: 3171 M\n", "\n", - "Installation Time: 35527 h\n" + "Installation Time: 40914 h\n" ] } ], @@ -176,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -192,12 +193,13 @@ " 'Substructure Installation': 208.2509277379141,\n", " 'Mooring System Installation': 80.80888508371386,\n", " 'Offshore Substation Installation': 11.784658802638255,\n", + " 'Turbine Installation': 212.89678462709279,\n", " 'Turbine': 1300.0,\n", " 'Soft': 645.0,\n", " 'Project': 252.08333333333334}" ] }, - "execution_count": 31, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -215,7 +217,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -248,6 +250,8 @@ " time\n", " phase\n", " location\n", + " site_depth\n", + " hub_height\n", " phase_name\n", " max_waveheight\n", " max_windspeed\n", @@ -274,6 +278,8 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 1\n", @@ -292,6 +298,8 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 2\n", @@ -310,6 +318,8 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 3\n", @@ -328,6 +338,8 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 4\n", @@ -346,6 +358,8 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " ...\n", @@ -364,9 +378,11 @@ " ...\n", " ...\n", " ...\n", + " ...\n", + " ...\n", " \n", " \n", - " 2988\n", + " 4458\n", " NaN\n", " Export Cable Installation Vessel\n", " Pull In Cable\n", @@ -376,6 +392,8 @@ " 12017.280762\n", " ExportCableInstallation\n", " NaN\n", + " NaN\n", + " NaN\n", " ExportCableInstallation\n", " NaN\n", " NaN\n", @@ -384,7 +402,7 @@ " NaN\n", " \n", " \n", - " 2989\n", + " 4459\n", " NaN\n", " Export Cable Installation Vessel\n", " Terminate Cable\n", @@ -394,6 +412,8 @@ " 12022.780762\n", " ExportCableInstallation\n", " NaN\n", + " NaN\n", + " NaN\n", " ExportCableInstallation\n", " NaN\n", " NaN\n", @@ -402,7 +422,7 @@ " NaN\n", " \n", " \n", - " 2990\n", + " 4460\n", " NaN\n", " Export Cable Installation Vessel\n", " Transit\n", @@ -418,9 +438,11 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", - " 2991\n", + " 4461\n", " NaN\n", " Export Cable Installation Vessel\n", " Delay\n", @@ -436,9 +458,11 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", - " 2992\n", + " 4462\n", " NaN\n", " Export Cable Installation Vessel\n", " Transit\n", @@ -454,10 +478,12 @@ " NaN\n", " NaN\n", " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", "\n", - "

2993 rows \u00d7 15 columns

\n", + "

4463 rows \u00d7 17 columns

\n", "" ], "text/plain": [ @@ -468,11 +494,11 @@ "3 1.0 Mooring System Installation Vessel \n", "4 NaN Substation Assembly Line 1 \n", "... ... ... \n", - "2988 NaN Export Cable Installation Vessel \n", - "2989 NaN Export Cable Installation Vessel \n", - "2990 NaN Export Cable Installation Vessel \n", - "2991 NaN Export Cable Installation Vessel \n", - "2992 NaN Export Cable Installation Vessel \n", + "4458 NaN Export Cable Installation Vessel \n", + "4459 NaN Export Cable Installation Vessel \n", + "4460 NaN Export Cable Installation Vessel \n", + "4461 NaN Export Cable Installation Vessel \n", + "4462 NaN Export Cable Installation Vessel \n", "\n", " action duration cost level \\\n", "0 Mobilize 72.000000 3.375000e+05 ACTION \n", @@ -481,55 +507,55 @@ "3 Mobilize 168.000000 7.000000e+05 ACTION \n", "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", "... ... ... ... ... \n", - "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", - "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", - "2990 Transit 8.000000 7.500000e+04 ACTION \n", - "2991 Delay 26.000000 2.437500e+05 ACTION \n", - "2992 Transit 0.695652 6.521739e+03 ACTION \n", + "4458 Pull In Cable 5.500000 5.156250e+04 ACTION \n", + "4459 Terminate Cable 5.500000 5.156250e+04 ACTION \n", + "4460 Transit 8.000000 7.500000e+04 ACTION \n", + "4461 Delay 26.000000 2.437500e+05 ACTION \n", + "4462 Transit 0.695652 6.521739e+03 ACTION \n", "\n", - " time phase location \\\n", - "0 0.000000 ArrayCableInstallation NaN \n", - "1 0.000000 ExportCableInstallation NaN \n", - "2 0.000000 ExportCableInstallation Landfall \n", - "3 0.000000 MooringSystemInstallation NaN \n", - "4 0.000000 FloatingSubstationInstallation NaN \n", - "... ... ... ... \n", - "2988 12017.280762 ExportCableInstallation NaN \n", - "2989 12022.780762 ExportCableInstallation NaN \n", - "2990 12030.780762 ExportCableInstallation NaN \n", - "2991 12056.780762 ExportCableInstallation NaN \n", - "2992 12057.476414 ExportCableInstallation NaN \n", + " time phase location site_depth \\\n", + "0 0.000000 ArrayCableInstallation NaN NaN \n", + "1 0.000000 ExportCableInstallation NaN NaN \n", + "2 0.000000 ExportCableInstallation Landfall NaN \n", + "3 0.000000 MooringSystemInstallation NaN NaN \n", + "4 0.000000 FloatingSubstationInstallation NaN NaN \n", + "... ... ... ... ... \n", + "4458 12017.280762 ExportCableInstallation NaN NaN \n", + "4459 12022.780762 ExportCableInstallation NaN NaN \n", + "4460 12030.780762 ExportCableInstallation NaN NaN \n", + "4461 12056.780762 ExportCableInstallation NaN NaN \n", + "4462 12057.476414 ExportCableInstallation NaN NaN \n", "\n", - " phase_name max_waveheight max_windspeed transit_speed \\\n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "2988 ExportCableInstallation NaN NaN NaN \n", - "2989 ExportCableInstallation NaN NaN NaN \n", - "2990 NaN NaN NaN NaN \n", - "2991 NaN NaN NaN NaN \n", - "2992 NaN NaN NaN NaN \n", + " hub_height phase_name max_waveheight max_windspeed \\\n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "4458 NaN ExportCableInstallation NaN NaN \n", + "4459 NaN ExportCableInstallation NaN NaN \n", + "4460 NaN NaN NaN NaN \n", + "4461 NaN NaN NaN NaN \n", + "4462 NaN NaN NaN NaN \n", "\n", - " num_vessels num_ahts_vessels \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 NaN NaN \n", - "4 NaN NaN \n", - "... ... ... \n", - "2988 NaN NaN \n", - "2989 NaN NaN \n", - "2990 NaN NaN \n", - "2991 NaN NaN \n", - "2992 NaN NaN \n", + " transit_speed num_vessels num_ahts_vessels \n", + "0 NaN NaN NaN \n", + "1 NaN NaN NaN \n", + "2 NaN NaN NaN \n", + "3 NaN NaN NaN \n", + "4 NaN NaN NaN \n", + "... ... ... ... \n", + "4458 NaN NaN NaN \n", + "4459 NaN NaN NaN \n", + "4460 NaN NaN NaN \n", + "4461 NaN NaN NaN \n", + "4462 NaN NaN NaN \n", "\n", - "[2993 rows x 15 columns]" + "[4463 rows x 17 columns]" ] }, - "execution_count": 32, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -540,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 8, "metadata": {}, "outputs": [ { diff --git a/examples/configs/example_floating_project.yaml b/examples/configs/example_floating_project.yaml index e7d23af8..28e7fd24 100644 --- a/examples/configs/example_floating_project.yaml +++ b/examples/configs/example_floating_project.yaml @@ -44,10 +44,8 @@ export_system_design: # Configured Phases design_phases: - ArraySystemDesign -#- ExportSystemDesign - ElectricalDesign - MooringSystemDesign -#- SemiTautMooringSystemDesign - OffshoreFloatingSubstationDesign - SemiSubmersibleDesign install_phases: @@ -56,6 +54,6 @@ install_phases: MooredSubInstallation: 0 MooringSystemInstallation: 0 FloatingSubstationInstallation: 0 -# TurbineInstallation: 0 + TurbineInstallation: 0 # Project Inputs turbine: 12MW_generic From 65728e8bfb89abc96267d7c86ed1360fff356cb3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 10 Jun 2024 09:28:09 -0600 Subject: [PATCH 183/240] Added reference for semitaut line constants --- ORBIT/phases/design/mooring_system_design.py | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index bda8cb8b..e14bb09c 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -1,9 +1,12 @@ """`MooringSystemDesign` and related functionality.""" -__author__ = "Jake Nunemaker, modified by Becca Fuchs" +__author__ = "Jake Nunemaker, Becca Fuchs" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" -__maintainer__ = "Jake Nunemaker" -__email__ = "jake.nunemaker@nrel.gov, rebecca.fuchs@nrel.gov" +__maintainer__ = "Nicholas Riccobono" +__email__ = ( + "jake.nunemaker@nrel.gov, rebecca.fuchs@nrel.gov," + "nicholas.riccobono@nrel.gov" +) from math import sqrt @@ -141,12 +144,10 @@ def calculate_line_length_mass(self): """ Returns the mooring line length and mass. + SemiTaut model based on: + https://github.com/NREL/MoorPy/blob/dev/moorpy/MoorProps_default.yaml TODO: Improve TLP line length and mass - Parameters - ---------- - drag_embedment_fixed_length - draft_depth """ # Add extra fixed line length for drag embedments @@ -183,14 +184,15 @@ def calculate_line_length_mass(self): fixed = self._design.get("drag_embedment_fixed_length", 0) self.line_length = self.rope_length + self.chain_length + fixed + # line characteristics based on MoorPy defaults, chain_mass_per_m = ( self._design.get("mooring_chain_density", 19900) * chain_diameter**2 - ) # kg + ) # kg/m rope_mass_per_m = ( self._design.get("mooring_rope_density", 797.8) * rope_diameter**2 - ) # kg + ) # kg/m self.line_mass = ( self.chain_length * chain_mass_per_m From 8749076ea76dde32d346bd2fd77902e5711bfe67 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 10 Jun 2024 11:13:32 -0600 Subject: [PATCH 184/240] Removed commented anchor install cost method. Added to process_time --- .../phases/install/mooring_install/mooring.py | 27 +------------------ 1 file changed, 1 insertion(+), 26 deletions(-) diff --git a/ORBIT/phases/install/mooring_install/mooring.py b/ORBIT/phases/install/mooring_install/mooring.py index 296d82fc..a8997f39 100644 --- a/ORBIT/phases/install/mooring_install/mooring.py +++ b/ORBIT/phases/install/mooring_install/mooring.py @@ -268,7 +268,7 @@ def install_mooring_line(vessel, depth, **kwargs): ------ vessel.task representing time to install mooring line. """ - + install_time = 0.005 * depth yield vessel.task_wrapper( @@ -319,28 +319,3 @@ def release(**kwargs): """Dummy method to work with `get_list_of_items_from_port`.""" return "", 0 - -''' # commented anchor_install_time because this overwrites what is called from process_times.yaml . - def anchor_install_time(self, depth): - """ - Returns time to install anchor. Varies by depth. - - Parameters - ---------- - depth : int | float - Depth at site (m). - """ - - if self.anchor_type == "Suction Pile": - fixed = 11 - - elif self.anchor_type == "Drag Embedment": - fixed = 5 - - else: - raise ValueError( - f"Mooring System Anchor Type: {self.anchor_type} not recognized." - ) - - return fixed + 0.005 * depth -''' \ No newline at end of file From 90bb8c55f04e2b786f15d9a43fbd48c5f76e1b6d Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 10 Jun 2024 11:38:26 -0600 Subject: [PATCH 185/240] Updated tests to verify defaults. Cleaned up single character object names. --- tests/phases/design/test_electrical_design.py | 146 +++++++++--------- .../design/test_mooring_system_design.py | 96 +++++++----- 2 files changed, 133 insertions(+), 109 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index b248d28f..45e03155 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -43,63 +43,69 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): "substation_design": {}, } - o = ElectricalDesign(config) - o.run() + elect = ElectricalDesign(config) + elect.run() # Check valid substructure length - assert 10 <= o._outputs["offshore_substation_substructure"]["length"] <= 80 + assert ( + 10 + <= elect._outputs["offshore_substation_substructure"]["length"] + <= 80 + ) # Check valid substructure mass assert ( - 200 <= o._outputs["offshore_substation_substructure"]["mass"] <= 2700 + 200 + <= elect._outputs["offshore_substation_substructure"]["mass"] + <= 2700 ) # Check valid topside mass - assert 200 <= o._outputs["offshore_substation_topside"]["mass"] <= 5500 + assert 200 <= elect._outputs["offshore_substation_topside"]["mass"] <= 5500 # Check valid substation cost - assert 1e6 <= o.total_substation_cost <= 1e9 + assert 1e6 <= elect.total_substation_cost <= 1e9 def test_detailed_design_length(): """Ensure that the same # of output variables are used for a floating and fixed offshore substation.""" - o = ElectricalDesign(base) - o.run() + elect = ElectricalDesign(base) + elect.run() floating = deepcopy(base) floating["substation_design"]["oss_substructure_type"] = "Floating" - o_floating = ElectricalDesign(floating) - o_floating.run() + elect_floating = ElectricalDesign(floating) + elect_floating.run() - assert len(o.detailed_output) == len(o_floating.detailed_output) + assert len(elect.detailed_output) == len(elect_floating.detailed_output) def test_calc_substructure_mass_and_cost(): - o = ElectricalDesign(base) - o.run() + elect = ElectricalDesign(base) + elect.run() floating = deepcopy(base) floating["substation_design"]["oss_substructure_type"] = "Floating" - o_floating = ElectricalDesign(floating) - o_floating.run() + elect_floating = ElectricalDesign(floating) + elect_floating.run() assert ( - o.detailed_output["substation_substructure_cost"] - != o_floating.detailed_output["substation_substructure_cost"] + elect.detailed_output["substation_substructure_cost"] + != elect_floating.detailed_output["substation_substructure_cost"] ) assert ( - o.detailed_output["substation_substructure_mass"] - != o_floating.detailed_output["substation_substructure_mass"] + elect.detailed_output["substation_substructure_mass"] + != elect_floating.detailed_output["substation_substructure_mass"] ) def test_calc_topside_mass_and_cost(): """Test topside mass and cost for HVDC compared to HVDC-Monopole and HVDC-Bipole""" - o = ElectricalDesign(base) - o.run() + elect = ElectricalDesign(base) + elect.run() base_dc = deepcopy(base) cables = ["HVDC_2000mm_320kV", "HVDC_2500mm_525kV"] @@ -107,16 +113,16 @@ def test_calc_topside_mass_and_cost(): for cable in cables: base_dc["export_system_design"]["cables"] = cable - o_dc = ElectricalDesign(base_dc) - o_dc.run() + elect_dc = ElectricalDesign(base_dc) + elect_dc.run() assert ( - o.detailed_output["substation_topside_mass"] - == o_dc.detailed_output["substation_topside_mass"] + elect.detailed_output["substation_topside_mass"] + == elect_dc.detailed_output["substation_topside_mass"] ) assert ( - o.detailed_output["substation_topside_cost"] - != o_dc.detailed_output["substation_topside_cost"] + elect.detailed_output["substation_topside_cost"] + != elect_dc.detailed_output["substation_topside_cost"] ) @@ -128,20 +134,20 @@ def test_oss_substructure_kwargs(): "num_substations": 4, } - o = ElectricalDesign(base) - o.run() - base_cost_total = o.detailed_output["total_substation_cost"] - base_cost_subst = o.detailed_output["substation_substructure_cost"] + elect = ElectricalDesign(base) + elect.run() + base_cost_total = elect.detailed_output["total_substation_cost"] + base_cost_subst = elect.detailed_output["substation_substructure_cost"] for k, v in test_kwargs.items(): config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v - o = ElectricalDesign(config) - o.run() - cost_total = o.detailed_output["total_substation_cost"] - cost_subst = o.detailed_output["substation_substructure_cost"] + elect = ElectricalDesign(config) + elect.run() + cost_total = elect.detailed_output["total_substation_cost"] + cost_subst = elect.detailed_output["substation_substructure_cost"] assert cost_total != base_cost_total assert cost_subst != base_cost_subst @@ -161,18 +167,18 @@ def test_ac_oss_kwargs(): "num_substations": 4, } - o = ElectricalDesign(base) - o.run() - base_cost = o.detailed_output["total_substation_cost"] + elect = ElectricalDesign(base) + elect.run() + base_cost = elect.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): config = deepcopy(base) config["substation_design"] = {} config["substation_design"][k] = v - o = ElectricalDesign(config) - o.run() - cost = o.detailed_output["total_substation_cost"] + elect = ElectricalDesign(config) + elect.run() + cost = elect.detailed_output["total_substation_cost"] print("passed") assert cost != base_cost @@ -182,9 +188,9 @@ def test_dc_oss_kwargs(): dc_base = deepcopy(base) dc_base["export_system_design"]["cables"] = "HVDC_2000mm_320kV" - o = ElectricalDesign(dc_base) - o.run() - base_cost = o.detailed_output["total_substation_cost"] + elect = ElectricalDesign(dc_base) + elect.run() + base_cost = elect.detailed_output["total_substation_cost"] for k, v in test_kwargs.items(): config = deepcopy(base) @@ -192,9 +198,9 @@ def test_dc_oss_kwargs(): config["substation_design"] = {} config["substation_design"][k] = v - o = ElectricalDesign(config) - o.run() - cost = o.detailed_output["total_substation_cost"] + elect = ElectricalDesign(config) + elect.run() + cost = elect.detailed_output["total_substation_cost"] assert cost != base_cost @@ -232,35 +238,35 @@ def test_new_old_hvac_substation(): def test_hvdc_substation(): config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} - o = ElectricalDesign(config) - o.run() - assert o.converter_cost != 0 - assert o.shunt_reactor_cost == 0 - assert o.dc_breaker_cost != 0 - assert o.switchgear_cost == 0 - assert o.mpt_cost == 0 - # assert o.num_cables / o.num_converters == 2 # breaks + elect = ElectricalDesign(config) + elect.run() + assert elect.converter_cost != 0 + assert elect.shunt_reactor_cost == 0 + assert elect.dc_breaker_cost != 0 + assert elect.switchgear_cost == 0 + assert elect.mpt_cost == 0 + # assert elect.num_cables / elect.num_converters == 2 # breaks config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} - o = ElectricalDesign(config) - o.run() + elect = ElectricalDesign(config) + elect.run() - # assert o.num_converters == o.num_cables # breaks + # assert elect.num_converters == elect.num_cables # breaks def test_onshore_substation(): config = deepcopy(base) - o = ElectricalDesign(config) - o.run() - assert o.onshore_cost == pytest.approx(95.487e6, abs=1e2) # 109.32e6 + elect = ElectricalDesign(config) + elect.run() + assert elect.onshore_cost == pytest.approx(95.487e6, abs=1e2) # 109.32e6 config_mono = deepcopy(config) config_mono["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} - o_mono = ElectricalDesign(config_mono) - o_mono.run() - assert o_mono.onshore_cost == 244.3e6 + o_monelect = ElectricalDesign(config_mono) + o_monelect.run() + assert o_monelect.onshore_cost == 244.3e6 config_bi = deepcopy(config) config_bi["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} @@ -280,18 +286,18 @@ def test_export_kwargs(): # "interconnection_distance": 6, } - o = ElectricalDesign(base) - o.run() - base_cost = o.total_cost + elect = ElectricalDesign(base) + elect.run() + base_cost = elect.total_cost for k, v in test_kwargs.items(): config = deepcopy(base) config["export_system_design"] = {"cables": "XLPE_630mm_220kV"} config["export_system_design"][k] = v - o = ElectricalDesign(config) - o.run() - cost = o.total_cost + elect = ElectricalDesign(config) + elect.run() + cost = elect.total_cost assert cost != base_cost diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index 93fb714b..bf0e7021 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -29,11 +29,11 @@ def test_depth_sweep(depth): config = deepcopy(base) config["site"]["depth"] = depth - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.design_result - assert m.total_cost + assert moor.design_result + assert moor.total_cost @pytest.mark.parametrize("rating", range(3, 15, 1)) @@ -42,11 +42,29 @@ def test_rating_sweep(rating): config = deepcopy(base) config["turbine"]["turbine_rating"] = rating - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.design_result - assert m.total_cost + assert moor.design_result + assert moor.total_cost + + +def test_mooring_system_defaults(): + + moor_base = MooringSystemDesign(base) + moor_base.run() + + base_cost = moor_base.detailed_output["system_cost"] + + config_defs = deepcopy(base) + config_defs["mooring_system_design"] = {} + config_defs["mooring_system_design"]["mooring_type"] = "Catenary" + config_defs["mooring_system_design"]["anchor_type"] = "Suction Pile" + + moor_defs = MooringSystemDesign(config_defs) + moor_defs.run() + + assert moor_defs.detailed_output["system_cost"] == base_cost def test_catenary_mooring_system_kwargs(): @@ -57,20 +75,20 @@ def test_catenary_mooring_system_kwargs(): "mooring_line_cost_rate": 2500, } - m = MooringSystemDesign(base) - m.run() + moor = MooringSystemDesign(base) + moor.run() - base_cost = m.detailed_output["system_cost"] + base_cost = moor.detailed_output["system_cost"] for k, v in test_kwargs.items(): config = deepcopy(base) config["mooring_system_design"] = {} config["mooring_system_design"][k] = v - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.detailed_output["system_cost"] != base_cost + assert moor.detailed_output["system_cost"] != base_cost def test_semitaut_mooring_system_kwargs(): @@ -85,20 +103,20 @@ def test_semitaut_mooring_system_kwargs(): "rope_density": 1000, } - m = MooringSystemDesign(semi_base) - m.run() + moor = MooringSystemDesign(semi_base) + moor.run() - base_cost = m.detailed_output["system_cost"] + base_cost = moor.detailed_output["system_cost"] for k, v in test_kwargs.items(): config = deepcopy(semi_base) config["mooring_system_design"] = {} config["mooring_system_design"][k] = v - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.detailed_output["system_cost"] != base_cost + assert moor.detailed_output["system_cost"] != base_cost def test_tlp_mooring_system_kwargs(): @@ -113,36 +131,36 @@ def test_tlp_mooring_system_kwargs(): "draft_depth": 10, } - m = MooringSystemDesign(tlp_base) - m.run() + moor = MooringSystemDesign(tlp_base) + moor.run() - base_cost = m.detailed_output["system_cost"] + base_cost = moor.detailed_output["system_cost"] for k, v in test_kwargs.items(): config = deepcopy(tlp_base) config["mooring_system_design"] = {} config["mooring_system_design"][k] = v - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.detailed_output["system_cost"] != base_cost + assert moor.detailed_output["system_cost"] != base_cost def test_drag_embedment_fixed_length(): - m = MooringSystemDesign(base) - m.run() + moor = MooringSystemDesign(base) + moor.run() - baseline = m.line_length + baseline = moor.line_length default = deepcopy(base) default["mooring_system_design"] = {"anchor_type": "Drag Embedment"} - m = MooringSystemDesign(default) - m.run() + moor = MooringSystemDesign(default) + moor.run() - with_default = m.line_length + with_default = moor.line_length assert with_default > baseline custom = deepcopy(base) @@ -151,11 +169,11 @@ def test_drag_embedment_fixed_length(): "drag_embedment_fixed_length": 1000, } - m = MooringSystemDesign(custom) - m.run() + moor = MooringSystemDesign(custom) + moor.run() - assert m.line_length > with_default - assert m.line_length > baseline + assert moor.line_length > with_default + assert moor.line_length > baseline def test_custom_num_lines(): @@ -163,10 +181,10 @@ def test_custom_num_lines(): config = deepcopy(base) config["mooring_system_design"] = {"num_lines": 5} - m = MooringSystemDesign(config) - m.run() + moor = MooringSystemDesign(config) + moor.run() - assert m.design_result["mooring_system"]["num_lines"] == 5 + assert moor.design_result["mooring_system"]["num_lines"] == 5 def test_new_old_semitaut_mooring_system(): From bdcff41dd594b2f6ae3abb38e5ec2e2610c7cf41 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 10 Jun 2024 11:41:56 -0600 Subject: [PATCH 186/240] Updated changelog and docs. --- docs/source/changelog.rst | 11 ++++++++++- .../phases/design/doc_OffshoreSubstationDesign.rst | 2 +- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 0b8e1003..17be76bd 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -5,7 +5,16 @@ ORBIT Changelog Unreleased (TBD) ---------------- - +- merged SemiTaut_Mooring_Update +- The ``MooringSystemDesign`` module now can use a Catenary or SemiTaut mooring system. User can specify "mooring_type". +- The ``FloatingOffshoreSubstation`` and ``ElectricalDesign`` modules now actually have a floating option to remove any substructure mass (and cost) from older versions. User can specify "oss_substructure_type" +- The ``MoredSubInstallation`` now utilizes an AHTS vessel which must be added to any config file as (ahts_vessel) +- "drag_embedment_install_time" increased from 5 to 12 hours +- quayside turbine tower section lift time from 12 to 4 hours per section. User specifies number of sections (default =1) +- quayside nacelle lift time changed from 7 to 12 hours +Unreleased (TBD) +---------------- +- merged electrical-refactor - Updated ``ElectricalDesign`` module. This class combines the elements of ``ExportSystemDesign`` and the ``OffshoreSubstationDesign`` modules. Its purpose is to represent the export system more accurately by linking the type of cable (AC versus DC) and substation’s components (i.e. transformers versus converters).Figure 1 shows how to add ElectricalDesign() to a yaml diff --git a/docs/source/phases/design/doc_OffshoreSubstationDesign.rst b/docs/source/phases/design/doc_OffshoreSubstationDesign.rst index ec393be6..ef309b47 100644 --- a/docs/source/phases/design/doc_OffshoreSubstationDesign.rst +++ b/docs/source/phases/design/doc_OffshoreSubstationDesign.rst @@ -16,4 +16,4 @@ References ---------- .. [#maness2017] Michael Maness, Benjamin Maples, Aaron Smith, - NREL Offshore Balance-of-System Model, 2017 + NREL Offshore Balance-of-System Model, 2017. https://www.nrel.gov/docs/fy17osti/66874.pdf From 08cae489ca9d2b73d694cbb6532ad796d619c4f0 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 10 Jun 2024 11:44:23 -0600 Subject: [PATCH 187/240] changelog and floating.py clean up and update after file save. --- ORBIT/phases/install/oss_install/floating.py | 4 +--- docs/source/changelog.rst | 5 +++++ 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 53353021..1170ad7e 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -105,9 +105,7 @@ def system_capex(self): mooring_system_for_each_oss = num_mooring_lines * ( line_cost + anchor_cost ) - # print('topside: ' + str(topside)) - # print('oss substructure' + str(substructure)) - # print('mooring system' + str(mooring_system_for_each_oss)) + return self.num_substations * ( topside + substructure + mooring_system_for_each_oss ) diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 17be76bd..914f37a6 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -12,6 +12,11 @@ Unreleased (TBD) - "drag_embedment_install_time" increased from 5 to 12 hours - quayside turbine tower section lift time from 12 to 4 hours per section. User specifies number of sections (default =1) - quayside nacelle lift time changed from 7 to 12 hours +- XLPE_500mm_132kV cost_per_km changed from 200k to 500k +- example_cable_lay_vessel min_draft changed from 4.8m to 8.5m, overall_length 99m to 171m, max_mass 4000t to 13000t +- example_towing_vessel max_waveheight changed from 2.5m to 3.0m, max_windspeed 20m to 15m, transit_speed 6km/h to 14 km/h, day_rate 30k to 35k + + Unreleased (TBD) ---------------- - merged electrical-refactor From 41e57c2dd69d905cd0aec4b4108b949dafbf6839 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 14 Jun 2024 11:20:51 -0600 Subject: [PATCH 188/240] Addressed the deprecated support_vessel call in gravity-base install. Aligned install with moored install --- .../quayside_assembly_tow/gravity_base.py | 47 ++++++++++++++++--- .../test_gravity_based.py | 18 +++++++ .../quayside_assembly_tow/test_moored.py | 2 +- 3 files changed, 59 insertions(+), 8 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index 665f6d7c..a25e4404 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -5,9 +5,11 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" +from warnings import warn import simpy from marmot import le, process + from ORBIT.core import Vessel, WetStorage from ORBIT.phases.install import InstallPhase @@ -25,11 +27,13 @@ class GravityBasedInstallation(InstallPhase): #: expected_config = { - "support_vessel": "str", + "support_vessel": "str, (optional)", + "ahts_vessel": "str", "towing_vessel": "str", "towing_vessel_groups": { "towing_vessels": "int", - "station_keeping_vessels": "int", + "station_keeping_vessels": "int (optional)", + "ahts_vessels": "int (optional, default: 1)", "num_groups": "int (optional)", }, "substructure": { @@ -210,20 +214,49 @@ def initialize_queue(self): def initialize_support_vessel(self, **kwargs): """ + ** The support vessel is deprecated and an AHTS + vessel will perform the installation with the towing group. + # TODO: determine if the installation process for GBF is still + sound. + Initializes Multi-Purpose Support Vessel to perform installation processes at site. """ - specs = self.config["support_vessel"] - vessel = self.initialize_vessel("Multi-Purpose Support Vessel", specs) + specs = self.config.get("support_vessel", None) + + if specs is not None: + warn( + "support_vessel will be deprecated and replaced with" + " towing_vessels and ahts_vessel in the towing groups.\n", + DeprecationWarning, + stacklevel=2, + ) + + specs = self.config["ahts_vessel"] + vessel = self.initialize_vessel("Multi-Purpose AHTS Vessel", specs) self.env.register(vessel) vessel.initialize(mobilize=False) self.support_vessel = vessel - station_keeping_vessels = self.config["towing_vessel_groups"][ - "station_keeping_vessels" - ] + station_keeping_vessels = self.config["towing_vessel_groups"].get( + "station_keeping_vessels", None + ) + + if station_keeping_vessels is not None: + print(station_keeping_vessels) + warn( + "['towing_vessl_groups]['station_keeping_vessels']" + " will be deprecated and replaced with" + " ['towing_vessl_groups]['ahts_vessels'].\n", + DeprecationWarning, + stacklevel=2, + ) + + station_keeping_vessels = self.config["towing_vessel_groups"].get( + "ahts_vessels", 1 + ) install_gravity_base_foundations( self.support_vessel, diff --git a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py index dafad84b..84c57b9d 100644 --- a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py +++ b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py @@ -5,6 +5,7 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" +from copy import deepcopy import pandas as pd import pytest @@ -56,3 +57,20 @@ def test_for_complete_logging(weather, config): assert ~df["cost"].isnull().any() _ = sim.agent_efficiencies _ = sim.detailed_output + + +def test_deprecated_vessel(): + + deprecated = deepcopy(config) + deprecated["support_vessel"] = "test_support_vessel" + + with pytest.deprecated_call(): + sim = GravityBasedInstallation(deprecated) + sim.run() + + deprecated2 = deepcopy(config) + deprecated2["towing_vessel_groups"]["station_keeping_vessels"] = 2 + + with pytest.deprecated_call(): + sim = GravityBasedInstallation(deprecated2) + sim.run() diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index 3892495b..17dd0cb0 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -80,7 +80,7 @@ def test_for_complete_logging(weather, config): assert installed_mooring_lines == sim.num_turbines -def test_deprecated_landfall(): +def test_deprecated_vessel(): deprecated = deepcopy(config) deprecated["support_vessel"] = "test_support_vessel" From 90dd2cfea3a08a4325cdc25c48a2398792617222 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 17 Jun 2024 13:57:18 -0600 Subject: [PATCH 189/240] Had to remove a print statement that I left. --- ORBIT/phases/install/quayside_assembly_tow/gravity_base.py | 1 - ORBIT/phases/install/quayside_assembly_tow/moored.py | 1 - 2 files changed, 2 deletions(-) diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index a25e4404..1e80b1fc 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -245,7 +245,6 @@ def initialize_support_vessel(self, **kwargs): ) if station_keeping_vessels is not None: - print(station_keeping_vessels) warn( "['towing_vessl_groups]['station_keeping_vessels']" " will be deprecated and replaced with" diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index e4d8d752..916a09fc 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -256,7 +256,6 @@ def initialize_support_vessel(self): ) if station_keeping_vessels is not None: - print(station_keeping_vessels) warn( "['towing_vessl_groups]['station_keeping_vessels']" " will be deprecated and replaced with" From a133c01942f3ef8d091ab755ab57c5573e78e6ff Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 18 Jun 2024 15:23:24 -0600 Subject: [PATCH 190/240] Updated sim setup test to sweep different configs. --- .../install/quayside_assembly_tow/test_moored.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index 17dd0cb0..8f36ef4c 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -27,7 +27,17 @@ ) -def test_simulation_setup(): +@pytest.mark.parametrize( + "config", + (config, multi_assembly, multi_tow, multi_assembly_multi_tow), + ids=[ + "1 assembly, 1 tow", + "3 assembly, 1 tow", + "1 assembly, 3 tow", + "3 assembly, 3 tow", + ], +) +def test_simulation_setup(config): sim = MooredSubInstallation(config) assert sim.config == config assert sim.env From 2087b3871217926ab4b7ae43f5d70e9498a10f16 Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Thu, 20 Jun 2024 11:19:23 -0700 Subject: [PATCH 191/240] Enhancement/pyproject setup (#165) * start converting project settings to TOML configuration * convert versioneer and pylint to toml format * configure isort to use toml * update flake8 to use toml correctly * reformat isort and black pre-commit sections * add missing comma * fix isort bug * add names for flake8 adn pylint * fix flake8 call * put isort version back * add the dynamic version integration * remove versioneer for version management and revert to latest PyPI * allow Python 3.11 --- .flake8 | 5 - .isort.cfg | 9 - .pre-commit-config.yaml | 22 +- .pylintrc | 678 --------------- ORBIT/__init__.py | 14 +- ORBIT/_version.py | 520 ----------- pyproject.toml | 891 ++++++++++++++++++- setup.cfg | 7 - setup.py | 58 -- versioneer.py | 1822 --------------------------------------- 10 files changed, 908 insertions(+), 3118 deletions(-) delete mode 100644 .flake8 delete mode 100644 .isort.cfg delete mode 100644 .pylintrc delete mode 100644 ORBIT/_version.py delete mode 100644 setup.cfg delete mode 100644 setup.py delete mode 100644 versioneer.py diff --git a/.flake8 b/.flake8 deleted file mode 100644 index 93563482..00000000 --- a/.flake8 +++ /dev/null @@ -1,5 +0,0 @@ -[flake8] -ignore = E731,E402,F,W504,W503 -exclude = .git,__pycache__,docs/source/conf.py,old,build,dist -max-complexity = 10 -max-line-length=79 diff --git a/.isort.cfg b/.isort.cfg deleted file mode 100644 index 558bcb28..00000000 --- a/.isort.cfg +++ /dev/null @@ -1,9 +0,0 @@ -[settings] -multi_line_output=3 -include_trailing_comma=True -force_grid_wrap=0 -use_parentheses=True -line_length=79 -sections=FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER -known_first_party=ORBIT,tests,library -length_sort=1 diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a78c9c13..3458113f 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -2,20 +2,19 @@ ci: skip: [isort, black, pylint] repos: -- repo: https://github.com/timothycrosley/isort - rev: 5.13.2 +- repo: https://github.com/pycqa/isort + rev: 5.13.2 hooks: - - id: isort - name: isort - stages: [commit] + - id: isort + name: isort (python) - repo: https://github.com/psf/black rev: 24.2.0 hooks: - - id: black - name: black - stages: [commit] - exclude: ^ORBIT/api/wisdem + - id: black + name: black + stages: [commit] + exclude: ^ORBIT/api/wisdem - repo: https://github.com/pre-commit/pre-commit-hooks rev: v2.3.0 @@ -28,14 +27,15 @@ repos: - id: check-merge-conflict - id: check-symlinks - id: flake8 - exclude: ^tests/ + name: flake8 + additional_dependencies: [Flake8-pyproject] - id: mixed-line-ending - id: pretty-format-json args: [--autofix] - repo: https://github.com/pre-commit/mirrors-pylint - rev: v3.0.0a5 rev: v3.0.0a5 hooks: - id: pylint + name: pylint exclude: ^tests/ diff --git a/.pylintrc b/.pylintrc deleted file mode 100644 index 9a585314..00000000 --- a/.pylintrc +++ /dev/null @@ -1,678 +0,0 @@ -[MASTER] - -# A comma-separated list of package or module names from where C extensions may -# be loaded. Extensions are loading into the active Python interpreter and may -# run arbitrary code -extension-pkg-whitelist= - -# Add files or directories to the blacklist. They should be base names, not -# paths. -ignore=CVS - -# Add files or directories matching the regex patterns to the blacklist. The -# regex matches against base names, not paths. -ignore-patterns= - -# Python code to execute, usually for sys.path manipulation such as -# pygtk.require(). -#init-hook= - -# Use multiple processes to speed up Pylint. -jobs=4 - -# List of plugins (as comma separated values of python modules names) to load, -# usually to register additional checkers. -load-plugins= - -# Pickle collected data for later comparisons. -persistent=yes - -# Specify a configuration file. -#rcfile= - -# When enabled, pylint would attempt to guess common misconfiguration and emit -# user-friendly hints instead of false-positive error messages -suggestion-mode=yes - -# Allow loading of arbitrary C extensions. Extensions are imported into the -# active Python interpreter and may run arbitrary code. -unsafe-load-any-extension=no - - -[MESSAGES CONTROL] - -# Only show warnings with the listed confidence levels. Leave empty to show -# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED -confidence= - -# Disable the message, report, category or checker with the given id(s). You -# can either give multiple identifiers separated by comma (,) or put this -# option multiple times (only on the command line, not in the configuration -# file where it should appear only once).You can also use "--disable=all" to -# disable everything first and then reenable specific checks. For example, if -# you want to run only the similarities checker, you can use "--disable=all -# --enable=similarities". If you want to run only the classes checker, but have -# no Warning level messages displayed, use"--disable=all --enable=classes -# --disable=W" -disable=all - -enable=unused-import, - unused-argument, - unused-variable, - unused-wildcard-import, - used-before-assignment, - undefined-variable, - undefined-all-variable, - missing-docstring, - empty-docstring, - unneeded-not, - singleton-comparison, - unidiomatic-typecheck, - consider-using-enumerate, - consider-iterating-dictionary, - no-member, - no-self-use, - duplicate-code, - len-as-condition, - missing-format-argument-key, - import-self, - reimported, - wildcard-import, - relative-import, - deprecated-module, - unpacking-non-sequence, - invalid-all-object, - undefined-all-variable, - used-before-assignment, - cell-var-from-loop, - global-variable-undefined, - redefine-in-handler, - global-variable-not-assigned, - undefined-loop-variable, - global-statement, - global-at-module-level, - bad-open-mode, - redundant-unittest-assert, - -# Things we'd like to enable someday: -# redefined-outer-name (requires a bunch of work to clean up our code first) -# undefined-variable (re-enable when pylint fixes https://github.com/PyCQA/pylint/issues/760) -# no-name-in-module (giving us spurious warnings https://github.com/PyCQA/pylint/issues/73) -# unused-argument (need to clean up or code a lot, e.g. prefix unused_?) - -# Things we'd like to try. -# Procedure: -# 1. Enable a bunch. -# 2. See if there's spurious ones; if so disable. -# 3. Record above. -# 4. Remove from this list. - # deprecated-method, - # anomalous-unicode-escape-in-string, - # anomalous-backslash-in-string, - # not-in-loop, - # function-redefined, - # continue-in-finally, - # abstract-class-instantiated, - # star-needs-assignment-target, - # duplicate-argument-name, - # return-in-init, - # too-many-star-expressions, - # nonlocal-and-global, - # return-outside-function, - # return-arg-in-generator, - # invalid-star-assignment-target, - # bad-reversed-sequence, - # nonexistent-operator, - # yield-outside-function, - # init-is-generator, - # nonlocal-without-binding, - # lost-exception, - # assert-on-tuple, - # dangerous-default-value, - # duplicate-key, - # useless-else-on-loop, - # expression-not-assigned, - # confusing-with-statement, - # unnecessary-lambda, - # pointless-statement, - # pointless-string-statement, - # unnecessary-pass, - # unreachable, - # eval-used, - # exec-used, - # bad-builtin, - # using-constant-test, - # deprecated-lambda, - # bad-super-call, - # missing-super-argument, - # slots-on-old-class, - # super-on-old-class, - # property-on-old-class, - # not-an-iterable, - # not-a-mapping, - # format-needs-mapping, - # truncated-format-string, - # missing-format-string-key, - # mixed-format-string, - # too-few-format-args, - # bad-str-strip-call, - # too-many-format-args, - # bad-format-character, - # format-combined-specification, - # bad-format-string-key, - # bad-format-string, - # missing-format-attribute, - # missing-format-argument-key, - # unused-format-string-argument, - # unused-format-string-key, - # invalid-format-index, - # bad-indentation, - # mixed-indentation, - # unnecessary-semicolon, - # lowercase-l-suffix, - # fixme, - # invalid-encoded-data, - # unpacking-in-except, - # import-star-module-level, - # parameter-unpacking, - # long-suffix, - # old-octal-literal, - # old-ne-operator, - # backtick, - # old-raise-syntax, - # print-statement, - # metaclass-assignment, - # next-method-called, - # dict-iter-method, - # dict-view-method, - # indexing-exception, - # raising-string, - # standarderror-builtin, - # using-cmp-argument, - # cmp-method, - # coerce-method, - # delslice-method, - # getslice-method, - # hex-method, - # nonzero-method, - # oct-method, - # setslice-method, - # apply-builtin, - # basestring-builtin, - # buffer-builtin, - # cmp-builtin, - # coerce-builtin, - # old-division, - # execfile-builtin, - # file-builtin, - # filter-builtin-not-iterating, - # no-absolute-import, - # input-builtin, - # intern-builtin, - # long-builtin, - # map-builtin-not-iterating, - # range-builtin-not-iterating, - # raw_input-builtin, - # reduce-builtin, - # reload-builtin, - # round-builtin, - # unichr-builtin, - # unicode-builtin, - # xrange-builtin, - # zip-builtin-not-iterating, - # logging-format-truncated, - # logging-too-few-args, - # logging-too-many-args, - # logging-unsupported-format, - # logging-not-lazy, - # logging-format-interpolation, - # invalid-unary-operand-type, - # unsupported-binary-operation, - # no-member, - # not-callable, - # redundant-keyword-arg, - # assignment-from-no-return, - # assignment-from-none, - # not-context-manager, - # repeated-keyword, - # missing-kwoa, - # no-value-for-parameter, - # invalid-sequence-index, - # invalid-slice-index, - # too-many-function-args, - # unexpected-keyword-arg, - # unsupported-membership-test, - # unsubscriptable-object, - # access-member-before-definition, - # method-hidden, - # assigning-non-slot, - # duplicate-bases, - # inconsistent-mro, - # inherit-non-class, - # invalid-slots, - # invalid-slots-object, - # no-method-argument, - # no-self-argument, - # unexpected-special-method-signature, - # non-iterator-returned, - # protected-access, - # arguments-differ, - # attribute-defined-outside-init, - # no-init, - # abstract-method, - # signature-differs, - # bad-staticmethod-argument, - # non-parent-init-called, - # super-init-not-called, - # bad-except-order, - # catching-non-exception, - # bad-exception-context, - # notimplemented-raised, - # raising-bad-type, - # raising-non-exception, - # misplaced-bare-raise, - # duplicate-except, - # broad-except, - # nonstandard-exception, - # binary-op-exception, - # bare-except, - # not-async-context-manager, - # yield-inside-async-function, - - -[REPORTS] - -# Python expression which should return a note less than 10 (10 is the highest -# note). You have access to the variables errors warning, statement which -# respectively contain the number of errors / warnings messages and the total -# number of statements analyzed. This is used by the global evaluation report -# (RP0004). -evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) - -# Template used to display messages. This is a python new-style format string -# used to format the message information. See doc for all details -#msg-template= - -# Set the output format. Available formats are text, parseable, colorized, json -# and msvs (visual studio).You can also give a reporter class, eg -# mypackage.mymodule.MyReporterClass. -output-format=text - -# Tells whether to display a full report or only the messages -reports=no - -# Activate the evaluation score. -score=yes - - -[REFACTORING] - -# Maximum number of nested blocks for function / method body -max-nested-blocks=5 - - -[BASIC] - -# Naming style matching correct argument names -argument-naming-style=snake_case - -# Regular expression matching correct argument names. Overrides argument- -# naming-style -#argument-rgx= - -# Naming style matching correct attribute names -attr-naming-style=snake_case - -# Regular expression matching correct attribute names. Overrides attr-naming- -# style -#attr-rgx= - -# Bad variable names which should always be refused, separated by a comma -bad-names=foo, - bar, - baz, - toto, - tutu, - tata - -# Naming style matching correct class attribute names -class-attribute-naming-style=any - -# Regular expression matching correct class attribute names. Overrides class- -# attribute-naming-style -#class-attribute-rgx= - -# Naming style matching correct class names -class-naming-style=PascalCase - -# Regular expression matching correct class names. Overrides class-naming-style -#class-rgx= - -# Naming style matching correct constant names -const-naming-style=UPPER_CASE - -# Regular expression matching correct constant names. Overrides const-naming- -# style -#const-rgx= - -# Minimum line length for functions/classes that require docstrings, shorter -# ones are exempt. -docstring-min-length=-1 - -# Naming style matching correct function names -function-naming-style=snake_case - -# Regular expression matching correct function names. Overrides function- -# naming-style -#function-rgx= - -# Good variable names which should always be accepted, separated by a comma -good-names=i, - j, - k, - ex, - Run, - _ - -# Include a hint for the correct naming format with invalid-name -include-naming-hint=no - -# Naming style matching correct inline iteration names -inlinevar-naming-style=any - -# Regular expression matching correct inline iteration names. Overrides -# inlinevar-naming-style -#inlinevar-rgx= - -# Naming style matching correct method names -method-naming-style=snake_case - -# Regular expression matching correct method names. Overrides method-naming- -# style -#method-rgx= - -# Naming style matching correct module names -module-naming-style=snake_case - -# Regular expression matching correct module names. Overrides module-naming- -# style -#module-rgx= - -# Colon-delimited sets of names that determine each other's naming style when -# the name regexes allow several styles. -name-group= - -# Regular expression which should only match function or class names that do -# not require a docstring. -no-docstring-rgx=^_ - -# List of decorators that produce properties, such as abc.abstractproperty. Add -# to this list to register other decorators that produce valid properties. -property-classes=abc.abstractproperty - -# Naming style matching correct variable names -variable-naming-style=snake_case - -# Regular expression matching correct variable names. Overrides variable- -# naming-style -#variable-rgx= - - -[FORMAT] - -# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. -expected-line-ending-format= - -# Regexp for a line that is allowed to be longer than the limit. -ignore-long-lines=^\s*(# )??$ - -# Number of spaces of indent required inside a hanging or continued line. -indent-after-paren=4 - -# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 -# tab). -indent-string=' ' - -# Maximum number of characters on a single line. -max-line-length=79 - -# Maximum number of lines in a module -max-module-lines=1000 - -# List of optional constructs for which whitespace checking is disabled. `dict- -# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. -# `trailing-comma` allows a space between comma and closing bracket: (a, ). -# `empty-line` allows space-only lines. -no-space-check=trailing-comma, - dict-separator - -# Allow the body of a class to be on the same line as the declaration if body -# contains single statement. -single-line-class-stmt=no - -# Allow the body of an if to be on the same line as the test if there is no -# else. -single-line-if-stmt=no - - -[LOGGING] - -# Logging modules to check that the string format arguments are in logging -# function parameter format -logging-modules=logging - - -[MISCELLANEOUS] - -# List of note tags to take in consideration, separated by a comma. -notes=FIXME, - XXX, - TODO - - -[SIMILARITIES] - -# Ignore comments when computing similarities. -ignore-comments=yes - -# Ignore docstrings when computing similarities. -ignore-docstrings=yes - -# Ignore imports when computing similarities. -ignore-imports=no - -# Minimum lines number of a similarity. -min-similarity-lines=4 - - -[SPELLING] - -# Limits count of emitted suggestions for spelling mistakes -max-spelling-suggestions=4 - -# Spelling dictionary name. Available dictionaries: none. To make it working -# install python-enchant package. -spelling-dict= - -# List of comma separated words that should not be checked. -spelling-ignore-words= - -# A path to a file that contains private dictionary; one word per line. -spelling-private-dict-file= - -# Tells whether to store unknown words to indicated private dictionary in -# --spelling-private-dict-file option instead of raising a message. -spelling-store-unknown-words=no - - -[TYPECHECK] - -# List of decorators that produce context managers, such as -# contextlib.contextmanager. Add to this list to register other decorators that -# produce valid context managers. -contextmanager-decorators=contextlib.contextmanager - -# List of members which are set dynamically and missed by pylint inference -# system, and so shouldn't trigger E1101 when accessed. Python regular -# expressions are accepted. -generated-members= - -# Tells whether missing members accessed in mixin class should be ignored. A -# mixin class is detected if its name ends with "mixin" (case insensitive). -ignore-mixin-members=yes - -# This flag controls whether pylint should warn about no-member and similar -# checks whenever an opaque object is returned when inferring. The inference -# can return multiple potential results while evaluating a Python object, but -# some branches might not be evaluated, which results in partial inference. In -# that case, it might be useful to still emit no-member and other checks for -# the rest of the inferred objects. -ignore-on-opaque-inference=yes - -# List of class names for which member attributes should not be checked (useful -# for classes with dynamically set attributes). This supports the use of -# qualified names. -ignored-classes=optparse.Values,thread._local,_thread._local - -# List of module names for which member attributes should not be checked -# (useful for modules/projects where namespaces are manipulated during runtime -# and thus existing member attributes cannot be deduced by static analysis. It -# supports qualified module names, as well as Unix pattern matching. -ignored-modules= - -# Show a hint with possible names when a member name was not found. The aspect -# of finding the hint is based on edit distance. -missing-member-hint=yes - -# The minimum edit distance a name should have in order to be considered a -# similar match for a missing member name. -missing-member-hint-distance=1 - -# The total number of similar names that should be taken in consideration when -# showing a hint for a missing member. -missing-member-max-choices=1 - - -[VARIABLES] - -# List of additional names supposed to be defined in builtins. Remember that -# you should avoid to define new builtins when possible. -additional-builtins= - -# Tells whether unused global variables should be treated as a violation. -allow-global-unused-variables=yes - -# List of strings which can identify a callback function by name. A callback -# name must start or end with one of those strings. -callbacks=cb_, - _cb - -# A regular expression matching the name of dummy variables (i.e. expectedly -# not used). -dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ - -# Argument names that match this expression will be ignored. Default to name -# with leading underscore -ignored-argument-names=_.*|^ignored_|^unused_ - -# Tells whether we should check for unused import in __init__ files. -init-import=no - -# List of qualified module names which can have objects that can redefine -# builtins. -redefining-builtins-modules=six.moves,past.builtins,future.builtins - - -[CLASSES] - -# List of method names used to declare (i.e. assign) instance attributes. -defining-attr-methods=__init__, - __new__, - setUp - -# List of member names, which should be excluded from the protected access -# warning. -exclude-protected=_asdict, - _fields, - _replace, - _source, - _make - -# List of valid names for the first argument in a class method. -valid-classmethod-first-arg=cls - -# List of valid names for the first argument in a metaclass class method. -valid-metaclass-classmethod-first-arg=mcs - - -[DESIGN] - -# Maximum number of arguments for function / method -max-args=5 - -# Maximum number of attributes for a class (see R0902). -max-attributes=7 - -# Maximum number of boolean expressions in a if statement -max-bool-expr=5 - -# Maximum number of branch for function / method body -max-branches=12 - -# Maximum number of locals for function / method body -max-locals=15 - -# Maximum number of parents for a class (see R0901). -max-parents=7 - -# Maximum number of public methods for a class (see R0904). -max-public-methods=20 - -# Maximum number of return / yield for function / method body -max-returns=6 - -# Maximum number of statements in function / method body -max-statements=50 - -# Minimum number of public methods for a class (see R0903). -min-public-methods=2 - - -[IMPORTS] - -# Allow wildcard imports from modules that define __all__. -allow-wildcard-with-all=no - -# Analyse import fallback blocks. This can be used to support both Python 2 and -# 3 compatible code, which means that the block might have code that exists -# only in one or another interpreter, leading to false positives when analysed. -analyse-fallback-blocks=no - -# Deprecated modules which should not be used, separated by a comma -deprecated-modules=optparse,tkinter.tix - -# Create a graph of external dependencies in the given file (report RP0402 must -# not be disabled) -ext-import-graph= - -# Create a graph of every (i.e. internal and external) dependencies in the -# given file (report RP0402 must not be disabled) -import-graph= - -# Create a graph of internal dependencies in the given file (report RP0402 must -# not be disabled) -int-import-graph= - -# Force import order to recognize a module as part of the standard -# compatibility libraries. -known-standard-library= - -# Force import order to recognize a module as part of a third party library. -known-third-party=enchant - - -[EXCEPTIONS] - -# Exceptions that will emit a warning when being caught. Defaults to -# "Exception" -overgeneral-exceptions=Exception diff --git a/ORBIT/__init__.py b/ORBIT/__init__.py index 5d213327..b354d0a4 100644 --- a/ORBIT/__init__.py +++ b/ORBIT/__init__.py @@ -1,3 +1,5 @@ +""" Initializes ORBIT and provides the top-level import objects.""" + __author__ = ["Jake Nunemaker", "Matt Shields", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" @@ -5,11 +7,9 @@ __status__ = "Development" -from .manager import ProjectManager # isort:skip -from .config import load_config, save_config -from ._version import get_versions -from .parametric import ParametricManager -from .supply_chain import SupplyChainManager +from ORBIT.manager import ProjectManager # isort:skip +from ORBIT.config import load_config, save_config +from ORBIT.parametric import ParametricManager +from ORBIT.supply_chain import SupplyChainManager -__version__ = get_versions()["version"] -del get_versions +__version__ = "1.0.8" diff --git a/ORBIT/_version.py b/ORBIT/_version.py deleted file mode 100644 index fa1e63bc..00000000 --- a/ORBIT/_version.py +++ /dev/null @@ -1,520 +0,0 @@ - -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.18 (https://github.com/warner/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "$Format:%d$" - git_full = "$Format:%H$" - git_date = "$Format:%ci$" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "pep440" - cfg.tag_prefix = "" - cfg.parentdir_prefix = "ORBIT-" - cfg.versionfile_source = "ORBIT/_version.py" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} diff --git a/pyproject.toml b/pyproject.toml index 498624e1..81b09129 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,89 @@ +[build-system] +requires = ["setuptools", "setuptools-scm"] +build-backend = "setuptools.build_meta" + +[project] +name = "orbit-nrel" +dynamic = ["version"] +authors = [ + {name = "Nick Riccobono", email = "nicholas.riccobono@nrel.gov"}, + {name = "Rob Hammond", email = "rob.hammond@nrel.gov"}, + {name = "Jake Nunemaker", email = "jacob.nunemaker@nrel.gov"}, +] +readme = {file = "README.rst", content-type = "text/x-rst"} +description = "Offshore Renewables Balance of system and Installation Tool" +requires-python = ">=3.9, <3.12" +license = {file = "LICENSE"} +dependencies = [ + "numpy", + "matplotlib", + "simpy", + "marmot-agents>=0.2.5", + "scipy", + "pandas", + "pyyaml", + "openmdao>=3.2", + "python-benedict<0.33.2", + "statsmodels", +] +keywords = [ + "python3", + "wind-energy", + "balance-of-system", + "wind-installation", + "discrete-event-simulation", + "simulation", +] +classifiers = [ + "Development Status :: 4 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Science/Research", + "Intended Audience :: Other Audience", + "License :: OSI Approved :: Apache Software License", + "Natural Language :: English", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Topic :: Scientific/Engineering", + "Topic :: Software Development :: Libraries :: Python Modules", +] + +[project.urls] +source = "https://github.com/WISDEM/ORBIT" +documentation = "https://wisdem.github.io/ORBIT/" +issues = "https://github.com/WISDEM/ORBIT/issues" +changelog = "https://github.com/WISDEM/ORBIT/blob/main/docs/source/changelog.rst" # TODO + +[project.optional-dependencies] +dev = [ + "pre-commit", + "pylint", + "flake8", + "Flake8-pyproject", + "black", + "isort", + "pytest", + "pytest-cov", + "sphinx", + "sphinx-rtd-theme", +] + +[tool.setuptools] +include-package-data = true + +[tool.setuptools.packages.find] +include = ["ORBIT", "library", "*.yaml", "*.csv"] +exclude = ["*.tests", "*.tests.*", "tests.*", "tests"] + +[tool.setuptools.dynamic] +version = {attr = "ORBIT.__version__"} + [tool.black] line-length = 79 -target-version = ['py37'] +target-version = ['py39'] include = '\.pyi?$' exclude = ''' /( @@ -15,3 +98,809 @@ exclude = ''' | dist )/ ''' + +[tool.isort] +multi_line_output = 3 +include_trailing_comma = true +force_grid_wrap = 0 +use_parentheses = true +line_length = 79 +sections = [ + "FUTURE", + "STDLIB", + "THIRDPARTY", + "FIRSTPARTY", + "LOCALFOLDER", +] +known_first_party = [ + "ORBIT", + "tests", + "library", +] +length_sort = "1" + +[tool.flake8] +ignore = [ + "E731", + "E402", + "F", + "W504", + "W503", +] +exclude = [ + ".git", + "__pycache__", + "docs/source/conf.py", + "old", + "build", + "dist", + "^tests/", +] +max-complexity = 10 +max-line-length = 79 + +[tool.pylint.main] +# Analyse import fallback blocks. This can be used to support both Python 2 and 3 +# compatible code, which means that the block might have code that exists only in +# one or another interpreter, leading to false positives when analysed. +# analyse-fallback-blocks = + +# Clear in-memory caches upon conclusion of linting. Useful if running pylint in +# a server-like mode. +# clear-cache-post-run = + +# Always return a 0 (non-error) status code, even if lint errors are found. This +# is primarily useful in continuous integration scripts. +# exit-zero = + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +# extension-pkg-allow-list = + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. (This is an alternative name to extension-pkg-allow-list +# for backward compatibility.) +# extension-pkg-whitelist = + +# Return non-zero exit code if any of these messages/categories are detected, +# even if score is above --fail-under value. Syntax same as enable. Messages +# specified are enabled, while categories only check already-enabled messages. +# fail-on = + +# Specify a score threshold under which the program will exit with error. +fail-under = 10 + +# Interpret the stdin as a python script, whose filename needs to be passed as +# the module_or_package argument. +# from-stdin = + +# Files or directories to be skipped. They should be base names, not paths. +ignore = ["CVS"] + +# Add files or directories matching the regular expressions patterns to the +# ignore-list. The regex matches against paths and can be in Posix or Windows +# format. Because '\\' represents the directory delimiter on Windows systems, it +# can't be used as an escape character. +# ignore-paths = + +# Files or directories matching the regular expression patterns are skipped. The +# regex matches against base names, not paths. The default value ignores Emacs +# file locks +# ignore-patterns = + +# List of module names for which member attributes should not be checked (useful +# for modules/projects where namespaces are manipulated during runtime and thus +# existing member attributes cannot be deduced by static analysis). It supports +# qualified module names, as well as Unix pattern matching. +# ignored-modules = + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +# init-hook = + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use, and will cap the count on Windows to +# avoid hangs. +jobs = 4 + +# Control the amount of potential inferred values when inferring a single object. +# This can help the performance when dealing with large functions or complex, +# nested conditions. +limit-inference-results = 100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +# load-plugins = + +# Pickle collected data for later comparisons. +persistent = true + +# Minimum Python version to use for version dependent checks. Will default to the +# version used to run pylint. +py-version = "3.10" + +# Discover python modules and packages in the file system subtree. +# recursive = + +# Add paths to the list of the source roots. Supports globbing patterns. The +# source root is an absolute path or a path relative to the current working +# directory used to determine a package namespace for modules located under the +# source root. +# source-roots = + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode = true + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +# unsafe-load-any-extension = + +[tool.pylint.basic] +# Naming style matching correct argument names. +argument-naming-style = "snake_case" + +# Regular expression matching correct argument names. Overrides argument-naming- +# style. If left empty, argument names will be checked with the set naming style. +# argument-rgx = + +# Naming style matching correct attribute names. +attr-naming-style = "snake_case" + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. If left empty, attribute names will be checked with the set naming +# style. +# attr-rgx = + +# Bad variable names which should always be refused, separated by a comma. +bad-names = ["foo", "bar", "baz", "toto", "tutu", "tata"] + +# Bad variable names regexes, separated by a comma. If names match any regex, +# they will always be refused +# bad-names-rgxs = + +# Naming style matching correct class attribute names. +class-attribute-naming-style = "any" + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. If left empty, class attribute names will be checked +# with the set naming style. +# class-attribute-rgx = + +# Naming style matching correct class constant names. +class-const-naming-style = "UPPER_CASE" + +# Regular expression matching correct class constant names. Overrides class- +# const-naming-style. If left empty, class constant names will be checked with +# the set naming style. +# class-const-rgx = + +# Naming style matching correct class names. +class-naming-style = "PascalCase" + +# Regular expression matching correct class names. Overrides class-naming-style. +# If left empty, class names will be checked with the set naming style. +# class-rgx = + +# Naming style matching correct constant names. +const-naming-style = "UPPER_CASE" + +# Regular expression matching correct constant names. Overrides const-naming- +# style. If left empty, constant names will be checked with the set naming style. +# const-rgx = + +# Minimum line length for functions/classes that require docstrings, shorter ones +# are exempt. +docstring-min-length = -1 + +# Naming style matching correct function names. +function-naming-style = "snake_case" + +# Regular expression matching correct function names. Overrides function-naming- +# style. If left empty, function names will be checked with the set naming style. +# function-rgx = + +# Good variable names which should always be accepted, separated by a comma. +good-names = ["i", "j", "k", "ex", "Run", "_"] + +# Good variable names regexes, separated by a comma. If names match any regex, +# they will always be accepted +# good-names-rgxs = + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint = false + +# Naming style matching correct inline iteration names. +inlinevar-naming-style = "any" + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. If left empty, inline iteration names will be checked +# with the set naming style. +# inlinevar-rgx = + +# Naming style matching correct method names. +method-naming-style = "snake_case" + +# Regular expression matching correct method names. Overrides method-naming- +# style. If left empty, method names will be checked with the set naming style. +# method-rgx = + +# Naming style matching correct module names. +module-naming-style = "snake_case" + +# Regular expression matching correct module names. Overrides module-naming- +# style. If left empty, module names will be checked with the set naming style. +# module-rgx = + +# Colon-delimited sets of names that determine each other's naming style when the +# name regexes allow several styles. +# name-group = + +# Regular expression which should only match function or class names that do not +# require a docstring. +no-docstring-rgx = "^_" + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. These +# decorators are taken in consideration only for invalid-name. +property-classes = ["abc.abstractproperty"] + +# Regular expression matching correct type alias names. If left empty, type alias +# names will be checked with the set naming style. +# typealias-rgx = + +# Regular expression matching correct type variable names. If left empty, type +# variable names will be checked with the set naming style. +# typevar-rgx = + +# Naming style matching correct variable names. +variable-naming-style = "snake_case" + +# Regular expression matching correct variable names. Overrides variable-naming- +# style. If left empty, variable names will be checked with the set naming style. +# variable-rgx = + +[tool.pylint.classes] +# Warn about protected attribute access inside special methods +# check-protected-access-in-special-methods = + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods = ["__init__", "__new__", "setUp"] + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected = ["_asdict", "_fields", "_replace", "_source", "_make"] + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg = ["cls"] + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg = ["mcs"] + +[tool.pylint.design] +# List of regular expressions of class ancestor names to ignore when counting +# public methods (see R0903) +# exclude-too-few-public-methods = + +# List of qualified class names to ignore when counting class parents (see R0901) +# ignored-parents = + +# Maximum number of arguments for function / method. +max-args = 5 + +# Maximum number of attributes for a class (see R0902). +max-attributes = 7 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr = 5 + +# Maximum number of branch for function / method body. +max-branches = 12 + +# Maximum number of locals for function / method body. +max-locals = 15 + +# Maximum number of parents for a class (see R0901). +max-parents = 7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods = 20 + +# Maximum number of return / yield for function / method body. +max-returns = 6 + +# Maximum number of statements in function / method body. +max-statements = 50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods = 2 + +[tool.pylint.exceptions] +# Exceptions that will emit a warning when caught. +overgeneral-exceptions = ["Exception"] + +[tool.pylint.format] +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +# expected-line-ending-format = + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines = "^\\s*(# )??$" + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren = 4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string = " " + +# Maximum number of characters on a single line. +max-line-length = 79 + +# Maximum number of lines in a module. +max-module-lines = 1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt = false + +# Allow the body of an if to be on the same line as the test if there is no else. +single-line-if-stmt = false + +# List of optional constructs for which whitespace checking is disabled. `dict- +# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. +# `trailing-comma` allows a space between comma and closing bracket: (a, ). +# `empty-line` allows space-only lines. +no-space-check= ["trailing-comma", "dict-separator"] + +[tool.pylint.imports] +# List of modules that can be imported at any level, not just the top level one. +# allow-any-import-level = + +# Allow explicit reexports by alias from a package __init__. +# allow-reexport-from-package = + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all = false + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules = ["optparse", "tkinter.tix"] + +# Output a graph (.gv or any supported image format) of external dependencies to +# the given file (report RP0402 must not be disabled). +# ext-import-graph = + +# Output a graph (.gv or any supported image format) of all (i.e. internal and +# external) dependencies to the given file (report RP0402 must not be disabled). +# import-graph = + +# Output a graph (.gv or any supported image format) of internal dependencies to +# the given file (report RP0402 must not be disabled). +# int-import-graph = + +# Force import order to recognize a module as part of the standard compatibility +# libraries. +# known-standard-library = + +# Force import order to recognize a module as part of a third party library. +known-third-party = ["enchant"] + +# Couples of modules and preferred modules, separated by a comma. +# preferred-modules = + +[tool.pylint.logging] +# The type of string formatting that logging methods do. `old` means using % +# formatting, `new` is for `{}` formatting. +logging-format-style = "new" + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules = ["logging"] + +[tool.pylint."messages control"] +# Only show warnings with the listed confidence levels. Leave empty to show all. +# Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, UNDEFINED. +confidence = ["HIGH", "CONTROL_FLOW", "INFERENCE", "INFERENCE_FAILURE", "UNDEFINED"] + +# Disable the message, report, category or checker with the given id(s). You can +# either give multiple identifiers separated by comma (,) or put this option +# multiple times (only on the command line, not in the configuration file where +# it should appear only once). You can also use "--disable=all" to disable +# everything first and then re-enable specific checks. For example, if you want +# to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable = ["all"] + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where it +# should appear only once). See also the "--disable" option for examples. +enable = [ + "unused-import", + "unused-argument", + "unused-variable", + "unused-wildcard-import", + "used-before-assignment", + "undefined-variable", + "undefined-all-variable", + "missing-docstring", + "empty-docstring", + "unneeded-not", + "singleton-comparison", + "unidiomatic-typecheck", + "consider-using-enumerate", + "consider-iterating-dictionary", + "no-member", + "no-self-use", + "duplicate-code", + "len-as-condition", + "missing-format-argument-key", + "import-self", + "reimported", + "wildcard-import", + "relative-import", + "deprecated-module", + "unpacking-non-sequence", + "invalid-all-object", + "undefined-all-variable", + "used-before-assignment", + "cell-var-from-loop", + "global-variable-undefined", + "redefine-in-handler", + "global-variable-not-assigned", + "undefined-loop-variable", + "global-statement", + "global-at-module-level", + "bad-open-mode", + "redundant-unittest-assert", +] + +# Things we'd like to enable someday: +# redefined-outer-name (requires a bunch of work to clean up our code first) +# undefined-variable (re-enable when pylint fixes https://github.com/PyCQA/pylint/issues/760) +# no-name-in-module (giving us spurious warnings https://github.com/PyCQA/pylint/issues/73) +# unused-argument (need to clean up or code a lot, e.g. prefix unused_?) + +# Things we'd like to try. +# Procedure: +# 1. Enable a bunch. +# 2. See if there's spurious ones; if so disable. +# 3. Record above. +# 4. Remove from this list. + # deprecated-method, + # anomalous-unicode-escape-in-string, + # anomalous-backslash-in-string, + # not-in-loop, + # function-redefined, + # continue-in-finally, + # abstract-class-instantiated, + # star-needs-assignment-target, + # duplicate-argument-name, + # return-in-init, + # too-many-star-expressions, + # nonlocal-and-global, + # return-outside-function, + # return-arg-in-generator, + # invalid-star-assignment-target, + # bad-reversed-sequence, + # nonexistent-operator, + # yield-outside-function, + # init-is-generator, + # nonlocal-without-binding, + # lost-exception, + # assert-on-tuple, + # dangerous-default-value, + # duplicate-key, + # useless-else-on-loop, + # expression-not-assigned, + # confusing-with-statement, + # unnecessary-lambda, + # pointless-statement, + # pointless-string-statement, + # unnecessary-pass, + # unreachable, + # eval-used, + # exec-used, + # bad-builtin, + # using-constant-test, + # deprecated-lambda, + # bad-super-call, + # missing-super-argument, + # slots-on-old-class, + # super-on-old-class, + # property-on-old-class, + # not-an-iterable, + # not-a-mapping, + # format-needs-mapping, + # truncated-format-string, + # missing-format-string-key, + # mixed-format-string, + # too-few-format-args, + # bad-str-strip-call, + # too-many-format-args, + # bad-format-character, + # format-combined-specification, + # bad-format-string-key, + # bad-format-string, + # missing-format-attribute, + # missing-format-argument-key, + # unused-format-string-argument, + # unused-format-string-key, + # invalid-format-index, + # bad-indentation, + # mixed-indentation, + # unnecessary-semicolon, + # lowercase-l-suffix, + # fixme, + # invalid-encoded-data, + # unpacking-in-except, + # import-star-module-level, + # parameter-unpacking, + # long-suffix, + # old-octal-literal, + # old-ne-operator, + # backtick, + # old-raise-syntax, + # print-statement, + # metaclass-assignment, + # next-method-called, + # dict-iter-method, + # dict-view-method, + # indexing-exception, + # raising-string, + # standarderror-builtin, + # using-cmp-argument, + # cmp-method, + # coerce-method, + # delslice-method, + # getslice-method, + # hex-method, + # nonzero-method, + # oct-method, + # setslice-method, + # apply-builtin, + # basestring-builtin, + # buffer-builtin, + # cmp-builtin, + # coerce-builtin, + # old-division, + # execfile-builtin, + # file-builtin, + # filter-builtin-not-iterating, + # no-absolute-import, + # input-builtin, + # intern-builtin, + # long-builtin, + # map-builtin-not-iterating, + # range-builtin-not-iterating, + # raw_input-builtin, + # reduce-builtin, + # reload-builtin, + # round-builtin, + # unichr-builtin, + # unicode-builtin, + # xrange-builtin, + # zip-builtin-not-iterating, + # logging-format-truncated, + # logging-too-few-args, + # logging-too-many-args, + # logging-unsupported-format, + # logging-not-lazy, + # logging-format-interpolation, + # invalid-unary-operand-type, + # unsupported-binary-operation, + # no-member, + # not-callable, + # redundant-keyword-arg, + # assignment-from-no-return, + # assignment-from-none, + # not-context-manager, + # repeated-keyword, + # missing-kwoa, + # no-value-for-parameter, + # invalid-sequence-index, + # invalid-slice-index, + # too-many-function-args, + # unexpected-keyword-arg, + # unsupported-membership-test, + # unsubscriptable-object, + # access-member-before-definition, + # method-hidden, + # assigning-non-slot, + # duplicate-bases, + # inconsistent-mro, + # inherit-non-class, + # invalid-slots, + # invalid-slots-object, + # no-method-argument, + # no-self-argument, + # unexpected-special-method-signature, + # non-iterator-returned, + # protected-access, + # arguments-differ, + # attribute-defined-outside-init, + # no-init, + # abstract-method, + # signature-differs, + # bad-staticmethod-argument, + # non-parent-init-called, + # super-init-not-called, + # bad-except-order, + # catching-non-exception, + # bad-exception-context, + # notimplemented-raised, + # raising-bad-type, + # raising-non-exception, + # misplaced-bare-raise, + # duplicate-except, + # broad-except, + # nonstandard-exception, + # binary-op-exception, + # bare-except, + # not-async-context-manager, + # yield-inside-async-function, + +[tool.pylint.method_args] +# List of qualified names (i.e., library.method) which require a timeout +# parameter e.g. 'requests.api.get,requests.api.post' +timeout-methods = ["requests.api.delete", "requests.api.get", "requests.api.head", "requests.api.options", "requests.api.patch", "requests.api.post", "requests.api.put", "requests.api.request"] + +[tool.pylint.miscellaneous] +# List of note tags to take in consideration, separated by a comma. +notes = ["FIXME", "XXX", "TODO"] + +# Regular expression of note tags to take in consideration. +# notes-rgx = + +[tool.pylint.refactoring] +# Maximum number of nested blocks for function / method body +max-nested-blocks = 5 + +# Complete name of functions that never returns. When checking for inconsistent- +# return-statements if a never returning function is called then it will be +# considered as an explicit return statement and no message will be printed. +never-returning-functions = ["sys.exit", "argparse.parse_error"] + +[tool.pylint.reports] +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'fatal', 'error', 'warning', 'refactor', +# 'convention', and 'info' which contain the number of messages in each category, +# as well as 'statement' which is the total number of statements analyzed. This +# score is used by the global evaluation report (RP0004). +evaluation = "10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)" + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +# msg-template = + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +output-format = ["text"] + +# Tells whether to display a full report or only the messages. +reports = false + +# Activate the evaluation score. +score = true + +[tool.pylint.similarities] +# Comments are removed from the similarity computation +ignore-comments = true + +# Docstrings are removed from the similarity computation +ignore-docstrings = true + +# Imports are removed from the similarity computation +ignore-imports = false + +# Signatures are removed from the similarity computation +ignore-signatures = true + +# Minimum lines number of a similarity. +min-similarity-lines = 4 + +[tool.pylint.spelling] +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions = 4 + +# Spelling dictionary name. No available dictionaries : You need to install both +# the python package and the system dependency for enchant to work.. +# spelling-dict = + +# List of comma separated words that should be considered directives if they +# appear at the beginning of a comment and should not be checked. +spelling-ignore-comment-directives = "fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:" + +# List of comma separated words that should not be checked. +# spelling-ignore-words = + +# A path to a file that contains the private dictionary; one word per line. +# spelling-private-dict-file = + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words = false + +[tool.pylint.typecheck] +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators = ["contextlib.contextmanager"] + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +# generated-members = + +# Tells whether missing members accessed in mixin class should be ignored. A +# class is considered mixin if its name matches the mixin-class-rgx option. +# Tells whether to warn about missing members when the owner of the attribute is +# inferred to be None. +ignore-none = true + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference can +# return multiple potential results while evaluating a Python object, but some +# branches might not be evaluated, which results in partial inference. In that +# case, it might be useful to still emit no-member and other checks for the rest +# of the inferred objects. +ignore-on-opaque-inference = true + +# List of symbolic message names to ignore for Mixin members. +ignored-checks-for-mixins = ["no-member", "not-async-context-manager", "not-context-manager", "attribute-defined-outside-init"] + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes = ["optparse.Values", "thread._local", "_thread._local"] + +# Show a hint with possible names when a member name was not found. The aspect of +# finding the hint is based on edit distance. +missing-member-hint = true + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance = 1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices = 1 + +# Regex pattern to define which classes are considered mixins. +mixin-class-rgx = ".*[Mm]ixin" + +# List of decorators that change the signature of a decorated function. +# signature-mutators = + +[tool.pylint.variables] +# List of additional names supposed to be defined in builtins. Remember that you +# should avoid defining new builtins when possible. +# additional-builtins = + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables = true + +# List of names allowed to shadow builtins +# allowed-redefined-builtins = + +# List of strings which can identify a callback function by name. A callback name +# must start or end with one of those strings. +callbacks = ["cb_", "_cb"] + +# A regular expression matching the name of dummy variables (i.e. expected to not +# be used). +dummy-variables-rgx = "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_" + +# Argument names that match this expression will be ignored. +ignored-argument-names = "_.*|^ignored_|^unused_" + +# Tells whether we should check for unused import in __init__ files. +# init-import = + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules = ["six.moves", "past.builtins", "future.builtins"] diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 7ab0038d..00000000 --- a/setup.cfg +++ /dev/null @@ -1,7 +0,0 @@ -[versioneer] -VCS = git -style = pep440 -versionfile_source = ORBIT/_version.py -versionfile_build = ORBIT/_version.py -tag_prefix = -parentdir_prefix = ORBIT- diff --git a/setup.py b/setup.py deleted file mode 100644 index 2dc99f4b..00000000 --- a/setup.py +++ /dev/null @@ -1,58 +0,0 @@ -""""Distribution setup""" - -import os - -from setuptools import setup, find_packages - -import versioneer - -ROOT = os.path.abspath(os.path.dirname(__file__)) - -with open("README.rst", "r") as fh: - long_description = fh.read() - -setup( - name="orbit-nrel", - author="Jake Nunemaker", - version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), - description="Offshore Renewables Balance of system and Installation Tool", - long_description=long_description, - classifiers=[ - "Development Status :: 4 - Beta", - "Programming Language :: Python :: 3.9", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - ], - packages=find_packages( - exclude=["*.tests", "*.tests.*", "tests.*", "tests"] - ), - package_data={"": ["*.yaml"]}, - install_requires=[ - "numpy", - "matplotlib", - "simpy", - "marmot-agents>=0.2.5", - "scipy", - "pandas", - "pyyaml", - "openmdao>=3.2", - "python-benedict<0.33.2", - "statsmodels", - ], - extras_require={ - "dev": [ - "pre-commit", - "pylint", - "flake8", - "black", - "isort", - "pytest", - "pytest-cov", - "sphinx", - "sphinx-rtd-theme", - ] - }, - test_suite="pytest", - tests_require=["pytest", "pytest-cov"], -) diff --git a/versioneer.py b/versioneer.py deleted file mode 100644 index 64fea1c8..00000000 --- a/versioneer.py +++ /dev/null @@ -1,1822 +0,0 @@ - -# Version: 0.18 - -"""The Versioneer - like a rocketeer, but for versions. - -The Versioneer -============== - -* like a rocketeer, but for versions! -* https://github.com/warner/python-versioneer -* Brian Warner -* License: Public Domain -* Compatible With: python2.6, 2.7, 3.2, 3.3, 3.4, 3.5, 3.6, and pypy -* [![Latest Version] -(https://pypip.in/version/versioneer/badge.svg?style=flat) -](https://pypi.python.org/pypi/versioneer/) -* [![Build Status] -(https://travis-ci.org/warner/python-versioneer.png?branch=master) -](https://travis-ci.org/warner/python-versioneer) - -This is a tool for managing a recorded version number in distutils-based -python projects. The goal is to remove the tedious and error-prone "update -the embedded version string" step from your release process. Making a new -release should be as easy as recording a new tag in your version-control -system, and maybe making new tarballs. - - -## Quick Install - -* `pip install versioneer` to somewhere to your $PATH -* add a `[versioneer]` section to your setup.cfg (see below) -* run `versioneer install` in your source tree, commit the results - -## Version Identifiers - -Source trees come from a variety of places: - -* a version-control system checkout (mostly used by developers) -* a nightly tarball, produced by build automation -* a snapshot tarball, produced by a web-based VCS browser, like github's - "tarball from tag" feature -* a release tarball, produced by "setup.py sdist", distributed through PyPI - -Within each source tree, the version identifier (either a string or a number, -this tool is format-agnostic) can come from a variety of places: - -* ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows - about recent "tags" and an absolute revision-id -* the name of the directory into which the tarball was unpacked -* an expanded VCS keyword ($Id$, etc) -* a `_version.py` created by some earlier build step - -For released software, the version identifier is closely related to a VCS -tag. Some projects use tag names that include more than just the version -string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool -needs to strip the tag prefix to extract the version identifier. For -unreleased software (between tags), the version identifier should provide -enough information to help developers recreate the same tree, while also -giving them an idea of roughly how old the tree is (after version 1.2, before -version 1.3). Many VCS systems can report a description that captures this, -for example `git describe --tags --dirty --always` reports things like -"0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the -0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has -uncommitted changes. - -The version identifier is used for multiple purposes: - -* to allow the module to self-identify its version: `myproject.__version__` -* to choose a name and prefix for a 'setup.py sdist' tarball - -## Theory of Operation - -Versioneer works by adding a special `_version.py` file into your source -tree, where your `__init__.py` can import it. This `_version.py` knows how to -dynamically ask the VCS tool for version information at import time. - -`_version.py` also contains `$Revision$` markers, and the installation -process marks `_version.py` to have this marker rewritten with a tag name -during the `git archive` command. As a result, generated tarballs will -contain enough information to get the proper version. - -To allow `setup.py` to compute a version too, a `versioneer.py` is added to -the top level of your source tree, next to `setup.py` and the `setup.cfg` -that configures it. This overrides several distutils/setuptools commands to -compute the version when invoked, and changes `setup.py build` and `setup.py -sdist` to replace `_version.py` with a small static file that contains just -the generated version data. - -## Installation - -See [INSTALL.md](./INSTALL.md) for detailed installation instructions. - -## Version-String Flavors - -Code which uses Versioneer can learn about its version string at runtime by -importing `_version` from your main `__init__.py` file and running the -`get_versions()` function. From the "outside" (e.g. in `setup.py`), you can -import the top-level `versioneer.py` and run `get_versions()`. - -Both functions return a dictionary with different flavors of version -information: - -* `['version']`: A condensed version string, rendered using the selected - style. This is the most commonly used value for the project's version - string. The default "pep440" style yields strings like `0.11`, - `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section - below for alternative styles. - -* `['full-revisionid']`: detailed revision identifier. For Git, this is the - full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". - -* `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the - commit date in ISO 8601 format. This will be None if the date is not - available. - -* `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that - this is only accurate if run in a VCS checkout, otherwise it is likely to - be False or None - -* `['error']`: if the version string could not be computed, this will be set - to a string describing the problem, otherwise it will be None. It may be - useful to throw an exception in setup.py if this is set, to avoid e.g. - creating tarballs with a version string of "unknown". - -Some variants are more useful than others. Including `full-revisionid` in a -bug report should allow developers to reconstruct the exact code being tested -(or indicate the presence of local changes that should be shared with the -developers). `version` is suitable for display in an "about" box or a CLI -`--version` output: it can be easily compared against release notes and lists -of bugs fixed in various releases. - -The installer adds the following text to your `__init__.py` to place a basic -version in `YOURPROJECT.__version__`: - - from ._version import get_versions - __version__ = get_versions()['version'] - del get_versions - -## Styles - -The setup.cfg `style=` configuration controls how the VCS information is -rendered into a version string. - -The default style, "pep440", produces a PEP440-compliant string, equal to the -un-prefixed tag name for actual releases, and containing an additional "local -version" section with more detail for in-between builds. For Git, this is -TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags ---dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the -tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and -that this commit is two revisions ("+2") beyond the "0.11" tag. For released -software (exactly equal to a known tag), the identifier will only contain the -stripped tag, e.g. "0.11". - -Other styles are available. See [details.md](details.md) in the Versioneer -source tree for descriptions. - -## Debugging - -Versioneer tries to avoid fatal errors: if something goes wrong, it will tend -to return a version of "0+unknown". To investigate the problem, run `setup.py -version`, which will run the version-lookup code in a verbose mode, and will -display the full contents of `get_versions()` (including the `error` string, -which may help identify what went wrong). - -## Known Limitations - -Some situations are known to cause problems for Versioneer. This details the -most significant ones. More can be found on Github -[issues page](https://github.com/warner/python-versioneer/issues). - -### Subprojects - -Versioneer has limited support for source trees in which `setup.py` is not in -the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are -two common reasons why `setup.py` might not be in the root: - -* Source trees which contain multiple subprojects, such as - [Buildbot](https://github.com/buildbot/buildbot), which contains both - "master" and "slave" subprojects, each with their own `setup.py`, - `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI - distributions (and upload multiple independently-installable tarballs). -* Source trees whose main purpose is to contain a C library, but which also - provide bindings to Python (and perhaps other langauges) in subdirectories. - -Versioneer will look for `.git` in parent directories, and most operations -should get the right version string. However `pip` and `setuptools` have bugs -and implementation details which frequently cause `pip install .` from a -subproject directory to fail to find a correct version string (so it usually -defaults to `0+unknown`). - -`pip install --editable .` should work correctly. `setup.py install` might -work too. - -Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in -some later version. - -[Bug #38](https://github.com/warner/python-versioneer/issues/38) is tracking -this issue. The discussion in -[PR #61](https://github.com/warner/python-versioneer/pull/61) describes the -issue from the Versioneer side in more detail. -[pip PR#3176](https://github.com/pypa/pip/pull/3176) and -[pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve -pip to let Versioneer work correctly. - -Versioneer-0.16 and earlier only looked for a `.git` directory next to the -`setup.cfg`, so subprojects were completely unsupported with those releases. - -### Editable installs with setuptools <= 18.5 - -`setup.py develop` and `pip install --editable .` allow you to install a -project into a virtualenv once, then continue editing the source code (and -test) without re-installing after every change. - -"Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a -convenient way to specify executable scripts that should be installed along -with the python package. - -These both work as expected when using modern setuptools. When using -setuptools-18.5 or earlier, however, certain operations will cause -`pkg_resources.DistributionNotFound` errors when running the entrypoint -script, which must be resolved by re-installing the package. This happens -when the install happens with one version, then the egg_info data is -regenerated while a different version is checked out. Many setup.py commands -cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into -a different virtualenv), so this can be surprising. - -[Bug #83](https://github.com/warner/python-versioneer/issues/83) describes -this one, but upgrading to a newer version of setuptools should probably -resolve it. - -### Unicode version strings - -While Versioneer works (and is continually tested) with both Python 2 and -Python 3, it is not entirely consistent with bytes-vs-unicode distinctions. -Newer releases probably generate unicode version strings on py2. It's not -clear that this is wrong, but it may be surprising for applications when then -write these strings to a network connection or include them in bytes-oriented -APIs like cryptographic checksums. - -[Bug #71](https://github.com/warner/python-versioneer/issues/71) investigates -this question. - - -## Updating Versioneer - -To upgrade your project to a new release of Versioneer, do the following: - -* install the new Versioneer (`pip install -U versioneer` or equivalent) -* edit `setup.cfg`, if necessary, to include any new configuration settings - indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. -* re-run `versioneer install` in your source tree, to replace - `SRC/_version.py` -* commit any changed files - -## Future Directions - -This tool is designed to make it easily extended to other version-control -systems: all VCS-specific components are in separate directories like -src/git/ . The top-level `versioneer.py` script is assembled from these -components by running make-versioneer.py . In the future, make-versioneer.py -will take a VCS name as an argument, and will construct a version of -`versioneer.py` that is specific to the given VCS. It might also take the -configuration arguments that are currently provided manually during -installation by editing setup.py . Alternatively, it might go the other -direction and include code from all supported VCS systems, reducing the -number of intermediate scripts. - - -## License - -To make Versioneer easier to embed, all its code is dedicated to the public -domain. The `_version.py` that it creates is also in the public domain. -Specifically, both are released under the Creative Commons "Public Domain -Dedication" license (CC0-1.0), as described in -https://creativecommons.org/publicdomain/zero/1.0/ . - -""" - -from __future__ import print_function -try: - import configparser -except ImportError: - import ConfigParser as configparser -import errno -import json -import os -import re -import subprocess -import sys - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_root(): - """Get the project root directory. - - We require that all commands are run from the project root, i.e. the - directory that contains setup.py, setup.cfg, and versioneer.py . - """ - root = os.path.realpath(os.path.abspath(os.getcwd())) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - # allow 'python path/to/setup.py COMMAND' - root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) - setup_py = os.path.join(root, "setup.py") - versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): - err = ("Versioneer was unable to run the project root directory. " - "Versioneer requires setup.py to be executed from " - "its immediate directory (like 'python setup.py COMMAND'), " - "or in a way that lets it use sys.argv[0] to find the root " - "(like 'python path/to/setup.py COMMAND').") - raise VersioneerBadRootError(err) - try: - # Certain runtime workflows (setup.py install/develop in a setuptools - # tree) execute all dependencies in a single python process, so - # "versioneer" may be imported multiple times, and python's shared - # module-import table will cache the first one. So we can't use - # os.path.dirname(__file__), as that will find whichever - # versioneer.py was first imported, even in later projects. - me = os.path.realpath(os.path.abspath(__file__)) - me_dir = os.path.normcase(os.path.splitext(me)[0]) - vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) - if me_dir != vsr_dir: - print("Warning: build in %s is using versioneer.py from %s" - % (os.path.dirname(me), versioneer_py)) - except NameError: - pass - return root - - -def get_config_from_root(root): - """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise EnvironmentError (if setup.cfg is missing), or - # configparser.NoSectionError (if it lacks a [versioneer] section), or - # configparser.NoOptionError (if it lacks "VCS="). See the docstring at - # the top of versioneer.py for instructions on writing your setup.cfg . - setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.SafeConfigParser() - with open(setup_cfg, "r") as f: - parser.readfp(f) - VCS = parser.get("versioneer", "VCS") # mandatory - - def get(parser, name): - if parser.has_option("versioneer", name): - return parser.get("versioneer", name) - return None - cfg = VersioneerConfig() - cfg.VCS = VCS - cfg.style = get(parser, "style") or "" - cfg.versionfile_source = get(parser, "versionfile_source") - cfg.versionfile_build = get(parser, "versionfile_build") - cfg.tag_prefix = get(parser, "tag_prefix") - if cfg.tag_prefix in ("''", '""'): - cfg.tag_prefix = "" - cfg.parentdir_prefix = get(parser, "parentdir_prefix") - cfg.verbose = get(parser, "verbose") - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -# these dictionaries contain VCS-specific tools -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %s" % dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %s" % (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %s (error)" % dispcmd) - print("stdout was %s" % stdout) - return None, p.returncode - return stdout, p.returncode - - -LONG_VERSION_PY['git'] = ''' -# This file helps to compute a version number in source trees obtained from -# git-archive tarball (such as those provided by githubs download-from-tag -# feature). Distribution tarballs (built by setup.py sdist) and build -# directories (produced by setup.py build) will contain a much shorter file -# that just contains the computed version number. - -# This file is released into the public domain. Generated by -# versioneer-0.18 (https://github.com/warner/python-versioneer) - -"""Git implementation of _version.py.""" - -import errno -import os -import re -import subprocess -import sys - - -def get_keywords(): - """Get the keywords needed to look up the version information.""" - # these strings will be replaced by git during git-archive. - # setup.py/versioneer.py will grep for the variable names, so they must - # each be defined on a line of their own. _version.py will just call - # get_keywords(). - git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" - git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" - git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" - keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} - return keywords - - -class VersioneerConfig: - """Container for Versioneer configuration parameters.""" - - -def get_config(): - """Create, populate and return the VersioneerConfig() object.""" - # these strings are filled in when 'setup.py versioneer' creates - # _version.py - cfg = VersioneerConfig() - cfg.VCS = "git" - cfg.style = "%(STYLE)s" - cfg.tag_prefix = "%(TAG_PREFIX)s" - cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" - cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" - cfg.verbose = False - return cfg - - -class NotThisMethod(Exception): - """Exception raised if a method is not valid for the current scenario.""" - - -LONG_VERSION_PY = {} -HANDLERS = {} - - -def register_vcs_handler(vcs, method): # decorator - """Decorator to mark a method as the handler for a particular VCS.""" - def decorate(f): - """Store f in HANDLERS[vcs][method].""" - if vcs not in HANDLERS: - HANDLERS[vcs] = {} - HANDLERS[vcs][method] = f - return f - return decorate - - -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): - """Call the given command(s).""" - assert isinstance(commands, list) - p = None - for c in commands: - try: - dispcmd = str([c] + args) - # remember shell=False, so use git.cmd on windows, not just git - p = subprocess.Popen([c] + args, cwd=cwd, env=env, - stdout=subprocess.PIPE, - stderr=(subprocess.PIPE if hide_stderr - else None)) - break - except EnvironmentError: - e = sys.exc_info()[1] - if e.errno == errno.ENOENT: - continue - if verbose: - print("unable to run %%s" %% dispcmd) - print(e) - return None, None - else: - if verbose: - print("unable to find command, tried %%s" %% (commands,)) - return None, None - stdout = p.communicate()[0].strip() - if sys.version_info[0] >= 3: - stdout = stdout.decode() - if p.returncode != 0: - if verbose: - print("unable to run %%s (error)" %% dispcmd) - print("stdout was %%s" %% stdout) - return None, p.returncode - return stdout, p.returncode - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %%s but none started with prefix %%s" %% - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %%d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%%s', no digits" %% ",".join(refs - tags)) - if verbose: - print("likely tags: %%s" %% ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %%s" %% r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %%s not under git control" %% root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%%s*" %% tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%%s'" - %% describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%%s' doesn't start with prefix '%%s'" - print(fmt %% (full_tag, tag_prefix)) - pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" - %% (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%%d" %% pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%%d" %% pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%%s" %% pieces["short"] - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%%s" %% pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%%d" %% pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%%s'" %% style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -def get_versions(): - """Get version information or return default if unable to do so.""" - # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have - # __file__, we can work backwards from there to the root. Some - # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which - # case we can only use expanded keywords. - - cfg = get_config() - verbose = cfg.verbose - - try: - return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, - verbose) - except NotThisMethod: - pass - - try: - root = os.path.realpath(__file__) - # versionfile_source is the relative path from the top of the source - # tree (where the .git directory might live) to this file. Invert - # this to find the root from __file__. - for i in cfg.versionfile_source.split('/'): - root = os.path.dirname(root) - except NameError: - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to find root of source tree", - "date": None} - - try: - pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) - return render(pieces, cfg.style) - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - except NotThisMethod: - pass - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, - "error": "unable to compute version", "date": None} -''' - - -@register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): - """Extract version information from the given file.""" - # the code embedded in _version.py can just fetch the value of these - # keywords. When used from setup.py, we don't want to import _version.py, - # so we do it with a regexp instead. This function is not used from - # _version.py. - keywords = {} - try: - f = open(versionfile_abs, "r") - for line in f.readlines(): - if line.strip().startswith("git_refnames ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["refnames"] = mo.group(1) - if line.strip().startswith("git_full ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["full"] = mo.group(1) - if line.strip().startswith("git_date ="): - mo = re.search(r'=\s*"(.*)"', line) - if mo: - keywords["date"] = mo.group(1) - f.close() - except EnvironmentError: - pass - return keywords - - -@register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): - """Get version information from git keywords.""" - if not keywords: - raise NotThisMethod("no keywords at all, weird") - date = keywords.get("date") - if date is not None: - # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant - # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 - # -like" string, which we must then edit to make compliant), because - # it's been around since git-1.5.3, and it's too difficult to - # discover which version we're using, or to work around using an - # older one. - date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - refnames = keywords["refnames"].strip() - if refnames.startswith("$Format"): - if verbose: - print("keywords are unexpanded, not using") - raise NotThisMethod("unexpanded keywords, not a git-archive tarball") - refs = set([r.strip() for r in refnames.strip("()").split(",")]) - # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of - # just "foo-1.0". If we see a "tag: " prefix, prefer those. - TAG = "tag: " - tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)]) - if not tags: - # Either we're using git < 1.8.3, or there really are no tags. We use - # a heuristic: assume all version tags have a digit. The old git %d - # expansion behaves like git log --decorate=short and strips out the - # refs/heads/ and refs/tags/ prefixes that would let us distinguish - # between branches and tags. By ignoring refnames without digits, we - # filter out many common branch names like "release" and - # "stabilization", as well as "HEAD" and "master". - tags = set([r for r in refs if re.search(r'\d', r)]) - if verbose: - print("discarding '%s', no digits" % ",".join(refs - tags)) - if verbose: - print("likely tags: %s" % ",".join(sorted(tags))) - for ref in sorted(tags): - # sorting will prefer e.g. "2.0" over "2.0rc1" - if ref.startswith(tag_prefix): - r = ref[len(tag_prefix):] - if verbose: - print("picking %s" % r) - return {"version": r, - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": None, - "date": date} - # no suitable tags, so version is "0+unknown", but full hex is still there - if verbose: - print("no suitable tags, using unknown + full revision id") - return {"version": "0+unknown", - "full-revisionid": keywords["full"].strip(), - "dirty": False, "error": "no suitable tags", "date": None} - - -@register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command): - """Get version from 'git describe' in the root of the source tree. - - This only gets called if the git-archive 'subst' keywords were *not* - expanded, and _version.py hasn't already been rewritten with a short - version string, meaning we're inside a checked out source tree. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - - out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) - if rc != 0: - if verbose: - print("Directory %s not under git control" % root) - raise NotThisMethod("'git rev-parse --git-dir' returned error") - - # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] - # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) - # --long was added in git-1.5.5 - if describe_out is None: - raise NotThisMethod("'git describe' failed") - describe_out = describe_out.strip() - full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root) - if full_out is None: - raise NotThisMethod("'git rev-parse' failed") - full_out = full_out.strip() - - pieces = {} - pieces["long"] = full_out - pieces["short"] = full_out[:7] # maybe improved later - pieces["error"] = None - - # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] - # TAG might have hyphens. - git_describe = describe_out - - # look for -dirty suffix - dirty = git_describe.endswith("-dirty") - pieces["dirty"] = dirty - if dirty: - git_describe = git_describe[:git_describe.rindex("-dirty")] - - # now we have TAG-NUM-gHEX or HEX - - if "-" in git_describe: - # TAG-NUM-gHEX - mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) - if not mo: - # unparseable. Maybe git-describe is misbehaving? - pieces["error"] = ("unable to parse git-describe output: '%s'" - % describe_out) - return pieces - - # tag - full_tag = mo.group(1) - if not full_tag.startswith(tag_prefix): - if verbose: - fmt = "tag '%s' doesn't start with prefix '%s'" - print(fmt % (full_tag, tag_prefix)) - pieces["error"] = ("tag '%s' doesn't start with prefix '%s'" - % (full_tag, tag_prefix)) - return pieces - pieces["closest-tag"] = full_tag[len(tag_prefix):] - - # distance: number of commits since tag - pieces["distance"] = int(mo.group(2)) - - # commit: short hex revision ID - pieces["short"] = mo.group(3) - - else: - # HEX: no tags - pieces["closest-tag"] = None - count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"], - cwd=root) - pieces["distance"] = int(count_out) # total number of commits - - # commit date: see ISO-8601 comment in git_versions_from_keywords() - date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"], - cwd=root)[0].strip() - pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) - - return pieces - - -def do_vcs_install(manifest_in, versionfile_source, ipy): - """Git-specific installation logic for Versioneer. - - For Git, this means creating/changing .gitattributes to mark _version.py - for export-subst keyword substitution. - """ - GITS = ["git"] - if sys.platform == "win32": - GITS = ["git.cmd", "git.exe"] - files = [manifest_in, versionfile_source] - if ipy: - files.append(ipy) - try: - me = __file__ - if me.endswith(".pyc") or me.endswith(".pyo"): - me = os.path.splitext(me)[0] + ".py" - versioneer_file = os.path.relpath(me) - except NameError: - versioneer_file = "versioneer.py" - files.append(versioneer_file) - present = False - try: - f = open(".gitattributes", "r") - for line in f.readlines(): - if line.strip().startswith(versionfile_source): - if "export-subst" in line.strip().split()[1:]: - present = True - f.close() - except EnvironmentError: - pass - if not present: - f = open(".gitattributes", "a+") - f.write("%s export-subst\n" % versionfile_source) - f.close() - files.append(".gitattributes") - run_command(GITS, ["add", "--"] + files) - - -def versions_from_parentdir(parentdir_prefix, root, verbose): - """Try to determine the version from the parent directory name. - - Source tarballs conventionally unpack into a directory that includes both - the project name and a version string. We will also support searching up - two directory levels for an appropriately named parent directory - """ - rootdirs = [] - - for i in range(3): - dirname = os.path.basename(root) - if dirname.startswith(parentdir_prefix): - return {"version": dirname[len(parentdir_prefix):], - "full-revisionid": None, - "dirty": False, "error": None, "date": None} - else: - rootdirs.append(root) - root = os.path.dirname(root) # up a level - - if verbose: - print("Tried directories %s but none started with prefix %s" % - (str(rootdirs), parentdir_prefix)) - raise NotThisMethod("rootdir doesn't start with parentdir_prefix") - - -SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.18) from -# revision-control system data, or from the parent directory name of an -# unpacked source archive. Distribution tarballs contain a pre-generated copy -# of this file. - -import json - -version_json = ''' -%s -''' # END VERSION_JSON - - -def get_versions(): - return json.loads(version_json) -""" - - -def versions_from_file(filename): - """Try to determine the version from _version.py if present.""" - try: - with open(filename) as f: - contents = f.read() - except EnvironmentError: - raise NotThisMethod("unable to read _version.py") - mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", - contents, re.M | re.S) - if not mo: - raise NotThisMethod("no version_json in _version.py") - return json.loads(mo.group(1)) - - -def write_to_version_file(filename, versions): - """Write the given version number to the given _version.py file.""" - os.unlink(filename) - contents = json.dumps(versions, sort_keys=True, - indent=1, separators=(",", ": ")) - with open(filename, "w") as f: - f.write(SHORT_VERSION_PY % contents) - - print("set %s to '%s'" % (filename, versions["version"])) - - -def plus_or_dot(pieces): - """Return a + if we don't already have one, else return a .""" - if "+" in pieces.get("closest-tag", ""): - return "." - return "+" - - -def render_pep440(pieces): - """Build up version string, with post-release "local version identifier". - - Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you - get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty - - Exceptions: - 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += plus_or_dot(pieces) - rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - else: - # exception #1 - rendered = "0+untagged.%d.g%s" % (pieces["distance"], - pieces["short"]) - if pieces["dirty"]: - rendered += ".dirty" - return rendered - - -def render_pep440_pre(pieces): - """TAG[.post.devDISTANCE] -- No -dirty. - - Exceptions: - 1: no tags. 0.post.devDISTANCE - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += ".post.dev%d" % pieces["distance"] - else: - # exception #1 - rendered = "0.post.dev%d" % pieces["distance"] - return rendered - - -def render_pep440_post(pieces): - """TAG[.postDISTANCE[.dev0]+gHEX] . - - The ".dev0" means dirty. Note that .dev0 sorts backwards - (a dirty tree will appear "older" than the corresponding clean one), - but you shouldn't be releasing software with -dirty anyways. - - Exceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += plus_or_dot(pieces) - rendered += "g%s" % pieces["short"] - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - rendered += "+g%s" % pieces["short"] - return rendered - - -def render_pep440_old(pieces): - """TAG[.postDISTANCE[.dev0]] . - - The ".dev0" means dirty. - - Eexceptions: - 1: no tags. 0.postDISTANCE[.dev0] - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"] or pieces["dirty"]: - rendered += ".post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - else: - # exception #1 - rendered = "0.post%d" % pieces["distance"] - if pieces["dirty"]: - rendered += ".dev0" - return rendered - - -def render_git_describe(pieces): - """TAG[-DISTANCE-gHEX][-dirty]. - - Like 'git describe --tags --dirty --always'. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - if pieces["distance"]: - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render_git_describe_long(pieces): - """TAG-DISTANCE-gHEX[-dirty]. - - Like 'git describe --tags --dirty --always -long'. - The distance/hash is unconditional. - - Exceptions: - 1: no tags. HEX[-dirty] (note: no 'g' prefix) - """ - if pieces["closest-tag"]: - rendered = pieces["closest-tag"] - rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) - else: - # exception #1 - rendered = pieces["short"] - if pieces["dirty"]: - rendered += "-dirty" - return rendered - - -def render(pieces, style): - """Render the given version pieces into the requested style.""" - if pieces["error"]: - return {"version": "unknown", - "full-revisionid": pieces.get("long"), - "dirty": None, - "error": pieces["error"], - "date": None} - - if not style or style == "default": - style = "pep440" # the default - - if style == "pep440": - rendered = render_pep440(pieces) - elif style == "pep440-pre": - rendered = render_pep440_pre(pieces) - elif style == "pep440-post": - rendered = render_pep440_post(pieces) - elif style == "pep440-old": - rendered = render_pep440_old(pieces) - elif style == "git-describe": - rendered = render_git_describe(pieces) - elif style == "git-describe-long": - rendered = render_git_describe_long(pieces) - else: - raise ValueError("unknown style '%s'" % style) - - return {"version": rendered, "full-revisionid": pieces["long"], - "dirty": pieces["dirty"], "error": None, - "date": pieces.get("date")} - - -class VersioneerBadRootError(Exception): - """The project root directory is unknown or missing key files.""" - - -def get_versions(verbose=False): - """Get the project version from whatever source is available. - - Returns dict with two keys: 'version' and 'full'. - """ - if "versioneer" in sys.modules: - # see the discussion in cmdclass.py:get_cmdclass() - del sys.modules["versioneer"] - - root = get_root() - cfg = get_config_from_root(root) - - assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" - handlers = HANDLERS.get(cfg.VCS) - assert handlers, "unrecognized VCS '%s'" % cfg.VCS - verbose = verbose or cfg.verbose - assert cfg.versionfile_source is not None, \ - "please set versioneer.versionfile_source" - assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" - - versionfile_abs = os.path.join(root, cfg.versionfile_source) - - # extract version from first of: _version.py, VCS command (e.g. 'git - # describe'), parentdir. This is meant to work for developers using a - # source checkout, for users of a tarball created by 'setup.py sdist', - # and for users of a tarball/zipball created by 'git archive' or github's - # download-from-tag feature or the equivalent in other VCSes. - - get_keywords_f = handlers.get("get_keywords") - from_keywords_f = handlers.get("keywords") - if get_keywords_f and from_keywords_f: - try: - keywords = get_keywords_f(versionfile_abs) - ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) - if verbose: - print("got version from expanded keyword %s" % ver) - return ver - except NotThisMethod: - pass - - try: - ver = versions_from_file(versionfile_abs) - if verbose: - print("got version from file %s %s" % (versionfile_abs, ver)) - return ver - except NotThisMethod: - pass - - from_vcs_f = handlers.get("pieces_from_vcs") - if from_vcs_f: - try: - pieces = from_vcs_f(cfg.tag_prefix, root, verbose) - ver = render(pieces, cfg.style) - if verbose: - print("got version from VCS %s" % ver) - return ver - except NotThisMethod: - pass - - try: - if cfg.parentdir_prefix: - ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) - if verbose: - print("got version from parentdir %s" % ver) - return ver - except NotThisMethod: - pass - - if verbose: - print("unable to compute version") - - return {"version": "0+unknown", "full-revisionid": None, - "dirty": None, "error": "unable to compute version", - "date": None} - - -def get_version(): - """Get the short version string for this project.""" - return get_versions()["version"] - - -def get_cmdclass(): - """Get the custom setuptools/distutils subclasses used by Versioneer.""" - if "versioneer" in sys.modules: - del sys.modules["versioneer"] - # this fixes the "python setup.py develop" case (also 'install' and - # 'easy_install .'), in which subdependencies of the main project are - # built (using setup.py bdist_egg) in the same python process. Assume - # a main project A and a dependency B, which use different versions - # of Versioneer. A's setup.py imports A's Versioneer, leaving it in - # sys.modules by the time B's setup.py is executed, causing B to run - # with the wrong versioneer. Setuptools wraps the sub-dep builds in a - # sandbox that restores sys.modules to it's pre-build state, so the - # parent is protected against the child's "import versioneer". By - # removing ourselves from sys.modules here, before the child build - # happens, we protect the child from the parent's versioneer too. - # Also see https://github.com/warner/python-versioneer/issues/52 - - cmds = {} - - # we add "version" to both distutils and setuptools - from distutils.core import Command - - class cmd_version(Command): - description = "report generated version string" - user_options = [] - boolean_options = [] - - def initialize_options(self): - pass - - def finalize_options(self): - pass - - def run(self): - vers = get_versions(verbose=True) - print("Version: %s" % vers["version"]) - print(" full-revisionid: %s" % vers.get("full-revisionid")) - print(" dirty: %s" % vers.get("dirty")) - print(" date: %s" % vers.get("date")) - if vers["error"]: - print(" error: %s" % vers["error"]) - cmds["version"] = cmd_version - - # we override "build_py" in both distutils and setuptools - # - # most invocation pathways end up running build_py: - # distutils/build -> build_py - # distutils/install -> distutils/build ->.. - # setuptools/bdist_wheel -> distutils/install ->.. - # setuptools/bdist_egg -> distutils/install_lib -> build_py - # setuptools/install -> bdist_egg ->.. - # setuptools/develop -> ? - # pip install: - # copies source tree to a tempdir before running egg_info/etc - # if .git isn't copied too, 'git describe' will fail - # then does setup.py bdist_wheel, or sometimes setup.py install - # setup.py egg_info -> ? - - # we override different "build_py" commands for both environments - if "setuptools" in sys.modules: - from setuptools.command.build_py import build_py as _build_py - else: - from distutils.command.build_py import build_py as _build_py - - class cmd_build_py(_build_py): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - _build_py.run(self) - # now locate _version.py in the new build/ directory and replace - # it with an updated value - if cfg.versionfile_build: - target_versionfile = os.path.join(self.build_lib, - cfg.versionfile_build) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - cmds["build_py"] = cmd_build_py - - if "cx_Freeze" in sys.modules: # cx_freeze enabled? - from cx_Freeze.dist import build_exe as _build_exe - # nczeczulin reports that py2exe won't like the pep440-style string - # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. - # setup(console=[{ - # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION - # "product_version": versioneer.get_version(), - # ... - - class cmd_build_exe(_build_exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _build_exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["build_exe"] = cmd_build_exe - del cmds["build_py"] - - if 'py2exe' in sys.modules: # py2exe enabled? - try: - from py2exe.distutils_buildexe import py2exe as _py2exe # py3 - except ImportError: - from py2exe.build_exe import py2exe as _py2exe # py2 - - class cmd_py2exe(_py2exe): - def run(self): - root = get_root() - cfg = get_config_from_root(root) - versions = get_versions() - target_versionfile = cfg.versionfile_source - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, versions) - - _py2exe.run(self) - os.unlink(target_versionfile) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % - {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - cmds["py2exe"] = cmd_py2exe - - # we override different "sdist" commands for both environments - if "setuptools" in sys.modules: - from setuptools.command.sdist import sdist as _sdist - else: - from distutils.command.sdist import sdist as _sdist - - class cmd_sdist(_sdist): - def run(self): - versions = get_versions() - self._versioneer_generated_versions = versions - # unless we update this, the command will keep using the old - # version - self.distribution.metadata.version = versions["version"] - return _sdist.run(self) - - def make_release_tree(self, base_dir, files): - root = get_root() - cfg = get_config_from_root(root) - _sdist.make_release_tree(self, base_dir, files) - # now locate _version.py in the new base_dir directory - # (remembering that it may be a hardlink) and replace it with an - # updated value - target_versionfile = os.path.join(base_dir, cfg.versionfile_source) - print("UPDATING %s" % target_versionfile) - write_to_version_file(target_versionfile, - self._versioneer_generated_versions) - cmds["sdist"] = cmd_sdist - - return cmds - - -CONFIG_ERROR = """ -setup.cfg is missing the necessary Versioneer configuration. You need -a section like: - - [versioneer] - VCS = git - style = pep440 - versionfile_source = src/myproject/_version.py - versionfile_build = myproject/_version.py - tag_prefix = - parentdir_prefix = myproject- - -You will also need to edit your setup.py to use the results: - - import versioneer - setup(version=versioneer.get_version(), - cmdclass=versioneer.get_cmdclass(), ...) - -Please read the docstring in ./versioneer.py for configuration instructions, -edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. -""" - -SAMPLE_CONFIG = """ -# See the docstring in versioneer.py for instructions. Note that you must -# re-run 'versioneer.py setup' after changing this section, and commit the -# resulting files. - -[versioneer] -#VCS = git -#style = pep440 -#versionfile_source = -#versionfile_build = -#tag_prefix = -#parentdir_prefix = - -""" - -INIT_PY_SNIPPET = """ -from ._version import get_versions -__version__ = get_versions()['version'] -del get_versions -""" - - -def do_setup(): - """Main VCS-independent setup function for installing Versioneer.""" - root = get_root() - try: - cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, - configparser.NoOptionError) as e: - if isinstance(e, (EnvironmentError, configparser.NoSectionError)): - print("Adding sample versioneer config to setup.cfg", - file=sys.stderr) - with open(os.path.join(root, "setup.cfg"), "a") as f: - f.write(SAMPLE_CONFIG) - print(CONFIG_ERROR, file=sys.stderr) - return 1 - - print(" creating %s" % cfg.versionfile_source) - with open(cfg.versionfile_source, "w") as f: - LONG = LONG_VERSION_PY[cfg.VCS] - f.write(LONG % {"DOLLAR": "$", - "STYLE": cfg.style, - "TAG_PREFIX": cfg.tag_prefix, - "PARENTDIR_PREFIX": cfg.parentdir_prefix, - "VERSIONFILE_SOURCE": cfg.versionfile_source, - }) - - ipy = os.path.join(os.path.dirname(cfg.versionfile_source), - "__init__.py") - if os.path.exists(ipy): - try: - with open(ipy, "r") as f: - old = f.read() - except EnvironmentError: - old = "" - if INIT_PY_SNIPPET not in old: - print(" appending to %s" % ipy) - with open(ipy, "a") as f: - f.write(INIT_PY_SNIPPET) - else: - print(" %s unmodified" % ipy) - else: - print(" %s doesn't exist, ok" % ipy) - ipy = None - - # Make sure both the top-level "versioneer.py" and versionfile_source - # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so - # they'll be copied into source distributions. Pip won't be able to - # install the package without this. - manifest_in = os.path.join(root, "MANIFEST.in") - simple_includes = set() - try: - with open(manifest_in, "r") as f: - for line in f: - if line.startswith("include "): - for include in line.split()[1:]: - simple_includes.add(include) - except EnvironmentError: - pass - # That doesn't cover everything MANIFEST.in can do - # (http://docs.python.org/2/distutils/sourcedist.html#commands), so - # it might give some false negatives. Appending redundant 'include' - # lines is safe, though. - if "versioneer.py" not in simple_includes: - print(" appending 'versioneer.py' to MANIFEST.in") - with open(manifest_in, "a") as f: - f.write("include versioneer.py\n") - else: - print(" 'versioneer.py' already in MANIFEST.in") - if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) - with open(manifest_in, "a") as f: - f.write("include %s\n" % cfg.versionfile_source) - else: - print(" versionfile_source already in MANIFEST.in") - - # Make VCS-specific changes. For git, this means creating/changing - # .gitattributes to mark _version.py for export-subst keyword - # substitution. - do_vcs_install(manifest_in, cfg.versionfile_source, ipy) - return 0 - - -def scan_setup_py(): - """Validate the contents of setup.py against Versioneer's expectations.""" - found = set() - setters = False - errors = 0 - with open("setup.py", "r") as f: - for line in f.readlines(): - if "import versioneer" in line: - found.add("import") - if "versioneer.get_cmdclass()" in line: - found.add("cmdclass") - if "versioneer.get_version()" in line: - found.add("get_version") - if "versioneer.VCS" in line: - setters = True - if "versioneer.versionfile_source" in line: - setters = True - if len(found) != 3: - print("") - print("Your setup.py appears to be missing some important items") - print("(but I might be wrong). Please make sure it has something") - print("roughly like the following:") - print("") - print(" import versioneer") - print(" setup( version=versioneer.get_version(),") - print(" cmdclass=versioneer.get_cmdclass(), ...)") - print("") - errors += 1 - if setters: - print("You should remove lines like 'versioneer.VCS = ' and") - print("'versioneer.versionfile_source = ' . This configuration") - print("now lives in setup.cfg, and should be removed from setup.py") - print("") - errors += 1 - return errors - - -if __name__ == "__main__": - cmd = sys.argv[1] - if cmd == "setup": - errors = do_setup() - errors += scan_setup_py() - if errors: - sys.exit(1) From 39cd770230c8157fdec838e8a5f5fde4636436f5 Mon Sep 17 00:00:00 2001 From: Rob Hammond <13874373+RHammond2@users.noreply.github.com> Date: Wed, 26 Jun 2024 13:54:15 -0700 Subject: [PATCH 192/240] Ruff Adoption & Linting Reset (#166) * adopt modified ruff in place of flake8 & pylint * add blame ignore file for massive commit * cleanup codebase from ruff adoption and old skips * add massive commit to the ignore file * adopt pathlib.Path in place of os.xx to modernize ORBIT internals * update the changelog and remove dated library dependencies * update README * update readme and changelog, fix last path confusion * remove flake8-commas and undo (hopefully) all of its changes * add commas commit to git blame ignore --- .git-blame-ignore-revs | 3 + .pre-commit-config.yaml | 14 +- ORBIT/__init__.py | 2 +- ORBIT/api/__init__.py | 2 +- ORBIT/api/wisdem.py | 515 +- ORBIT/config.py | 17 +- ORBIT/core/cargo.py | 6 +- ORBIT/core/components.py | 31 +- ORBIT/core/defaults/__init__.py | 8 +- ORBIT/core/environment.py | 4 +- ORBIT/core/exceptions.py | 58 +- ORBIT/core/library.py | 76 +- ORBIT/core/logic/__init__.py | 2 +- ORBIT/core/logic/vessel_logic.py | 72 +- ORBIT/core/port.py | 2 +- ORBIT/core/supply_chain.py | 11 +- ORBIT/core/vessel.py | 103 +- ORBIT/manager.py | 223 +- ORBIT/parametric.py | 27 +- ORBIT/phases/__init__.py | 3 +- ORBIT/phases/base.py | 4 +- .../design/SemiTaut_mooring_system_design.py | 82 +- ORBIT/phases/design/_cables.py | 48 +- ORBIT/phases/design/array_system_design.py | 138 +- ORBIT/phases/design/electrical_export.py | 34 +- ORBIT/phases/design/export_system_design.py | 22 +- ORBIT/phases/design/monopile_design.py | 41 +- ORBIT/phases/design/mooring_system_design.py | 9 +- ORBIT/phases/design/oss_design.py | 8 +- ORBIT/phases/design/oss_design_floating.py | 19 +- .../phases/design/scour_protection_design.py | 23 +- .../phases/design/semi_submersible_design.py | 18 +- ORBIT/phases/design/spar_design.py | 32 +- .../phases/install/cable_install/__init__.py | 2 +- ORBIT/phases/install/cable_install/array.py | 44 +- ORBIT/phases/install/cable_install/common.py | 31 +- ORBIT/phases/install/cable_install/export.py | 28 +- ORBIT/phases/install/install_phase.py | 47 +- ORBIT/phases/install/jacket_install/common.py | 12 +- .../phases/install/jacket_install/standard.py | 78 +- .../phases/install/monopile_install/common.py | 44 +- .../install/monopile_install/standard.py | 56 +- .../phases/install/mooring_install/mooring.py | 30 +- ORBIT/phases/install/oss_install/common.py | 19 +- ORBIT/phases/install/oss_install/floating.py | 32 +- ORBIT/phases/install/oss_install/standard.py | 30 +- .../install/quayside_assembly_tow/common.py | 34 +- .../quayside_assembly_tow/gravity_base.py | 64 +- .../install/quayside_assembly_tow/moored.py | 42 +- .../scour_protection_install/standard.py | 26 +- .../phases/install/turbine_install/common.py | 18 +- .../install/turbine_install/standard.py | 99 +- ORBIT/supply_chain.py | 269 +- README.rst | 39 +- docs/conf.py | 12 +- docs/source/changelog.rst | 25 +- examples/1. Introduction.ipynb | 538 +-- examples/2. Installation Modules.ipynb | 3442 +++++++------- examples/4. Example Fixed Project.ipynb | 1806 +++---- ...ample - Cable Install Configurations.ipynb | 1748 +++---- examples/Example - Cash Flow.ipynb | 1050 ++--- examples/Example - Custom Array Layout.ipynb | 4170 ++++++++--------- examples/Example - Dependent Phases.ipynb | 1796 +++---- .../Example - Modifying Library Assets.ipynb | 422 +- examples/supply_chain_dev.ipynb | 828 ++-- library/turbines/22MW_generic.yaml | 3 +- misc/supply_chain.ipynb | 1208 ++--- misc/supply_chain_plots.py | 221 +- pyproject.toml | 816 +--- templates/design_module.py | 124 +- tests/api/test_wisdem_api.py | 3 +- tests/conftest.py | 15 +- tests/core/test_environment.py | 6 +- tests/core/test_library.py | 2 +- tests/data/__init__.py | 6 +- .../phases/design/test_array_system_design.py | 2 +- tests/phases/design/test_cable.py | 1 + tests/phases/design/test_electrical_design.py | 15 +- .../design/test_export_system_design.py | 3 +- .../design/test_mooring_system_design.py | 2 +- .../design/test_scour_protection_design.py | 3 - .../design/test_semisubmersible_design.py | 3 +- tests/phases/design/test_spar_design.py | 3 +- .../cable_install/test_array_install.py | 23 +- .../install/cable_install/test_cable_tasks.py | 5 +- .../cable_install/test_export_install.py | 24 +- .../jacket_install/test_jacket_install.py | 7 +- .../monopile_install/test_monopile_install.py | 12 +- .../monopile_install/test_monopile_tasks.py | 4 +- .../mooring_install/test_mooring_install.py | 10 +- .../install/oss_install/test_oss_install.py | 14 +- .../install/oss_install/test_oss_tasks.py | 4 +- .../quayside_assembly_tow/test_common.py | 14 +- .../test_gravity_based.py | 8 +- .../quayside_assembly_tow/test_moored.py | 13 +- .../test_scour_protection.py | 10 +- tests/phases/install/test_install_phase.py | 5 +- .../turbine_install/test_turbine_install.py | 34 +- .../turbine_install/test_turbine_tasks.py | 4 +- tests/test_config_management.py | 4 - tests/test_parametric.py | 27 +- tests/test_project_manager.py | 70 +- 102 files changed, 10674 insertions(+), 10592 deletions(-) create mode 100644 .git-blame-ignore-revs diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs new file mode 100644 index 00000000..dd6e4c3f --- /dev/null +++ b/.git-blame-ignore-revs @@ -0,0 +1,3 @@ +# Adopting ruff in place of flake8 & pylint, and cleaning up the previously ignored errors +faeab2d971c6de9d1afbb7f8b63c0c8dfc4c85ec +66a52fa234cb3296a28b06cb2f5ccf42637326bb diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 3458113f..f315b7db 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -24,18 +24,16 @@ repos: - id: check-executables-have-shebangs - id: check-json - id: check-yaml + args: [--unsafe] # allow Python constructors - id: check-merge-conflict - id: check-symlinks - - id: flake8 - name: flake8 - additional_dependencies: [Flake8-pyproject] - id: mixed-line-ending - id: pretty-format-json args: [--autofix] -- repo: https://github.com/pre-commit/mirrors-pylint - rev: v3.0.0a5 +- repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.4.10 hooks: - - id: pylint - name: pylint - exclude: ^tests/ + - id: ruff + args: [--fix] diff --git a/ORBIT/__init__.py b/ORBIT/__init__.py index b354d0a4..422ce24f 100644 --- a/ORBIT/__init__.py +++ b/ORBIT/__init__.py @@ -1,4 +1,4 @@ -""" Initializes ORBIT and provides the top-level import objects.""" +"""Initializes ORBIT and provides the top-level import objects.""" __author__ = ["Jake Nunemaker", "Matt Shields", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/ORBIT/api/__init__.py b/ORBIT/api/__init__.py index d60cf1f2..19a370c7 100644 --- a/ORBIT/api/__init__.py +++ b/ORBIT/api/__init__.py @@ -1,4 +1,4 @@ -"""ORBIT API's""" +"""ORBIT API's.""" __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/ORBIT/api/wisdem.py b/ORBIT/api/wisdem.py index 6147c937..a47877e3 100644 --- a/ORBIT/api/wisdem.py +++ b/ORBIT/api/wisdem.py @@ -1,4 +1,4 @@ -"""WISDEM Monopile API""" +"""WISDEM Monopile API.""" __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -14,23 +14,24 @@ class Orbit(om.Group): - """Orbit class for WISDEM API""" + """Orbit class for WISDEM API.""" def initialize(self): + """Initializes the API connections.""" self.options.declare("floating", default=False) self.options.declare("jacket", default=False) self.options.declare("jacket_legs", default=0) def setup(self): - - # Define all input variables from all models + """Define all input variables from all models.""" self.set_input_defaults("wtiv", "example_wtiv") self.set_input_defaults("feeder", "example_feeder") self.set_input_defaults("num_feeders", 1) self.set_input_defaults("num_towing", 1) self.set_input_defaults("num_station_keeping", 3) - self.set_input_defaults("oss_install_vessel", - "example_heavy_lift_vessel") + self.set_input_defaults( + "oss_install_vessel", "example_heavy_lift_vessel", + ) self.set_input_defaults("site_distance", 40.0, units="km") self.set_input_defaults("site_distance_to_landfall", 40.0, units="km") self.set_input_defaults("interconnection_distance", 40.0, units="km") @@ -46,8 +47,9 @@ def setup(self): self.set_input_defaults("site_auction_price", 100e6, units="USD") self.set_input_defaults("site_assessment_plan_cost", 1e6, units="USD") self.set_input_defaults("site_assessment_cost", 25e6, units="USD") - self.set_input_defaults("construction_operations_plan_cost", - 2.5e6, units="USD") + self.set_input_defaults( + "construction_operations_plan_cost", 2.5e6, units="USD", + ) self.set_input_defaults("design_install_plan_cost", 2.5e6, units="USD") self.set_input_defaults("boem_review_cost", 0.0, units="USD") @@ -63,187 +65,440 @@ def setup(self): class OrbitWisdem(om.ExplicitComponent): - """ORBIT-WISDEM Fixed Substructure API""" + """ORBIT-WISDEM Fixed Substructure API.""" def initialize(self): + """Initialize the API.""" self.options.declare("floating", default=False) self.options.declare("jacket", default=False) self.options.declare("jacket_legs", default=0) def setup(self): - """""" + """Define all the inputs.""" # Inputs - # self.add_discrete_input('weather_file', 'block_island', desc='Weather file to use for installation times.') + # self.add_discrete_input( + # 'weather_file', + # 'block_island', + # desc='Weather file to use for installation times.' + # ) # Vessels self.add_discrete_input( - "wtiv", "example_wtiv", desc="Vessel configuration to use for installation of foundations and turbines." + "wtiv", + "example_wtiv", + desc=( + "Vessel configuration to use for installation of foundations" + " and turbines." + ), ) self.add_discrete_input( - "feeder", "future_feeder", desc="Vessel configuration to use for (optional) feeder barges." + "feeder", + "future_feeder", + desc="Vessel configuration to use for (optional) feeder barges.", ) self.add_discrete_input( - "num_feeders", 1, desc="Number of feeder barges to use for installation of foundations and turbines." + "num_feeders", + 1, + desc=( + "Number of feeder barges to use for installation of" + " foundations and turbines." + ), ) self.add_discrete_input( "num_towing", 1, - desc="Number of towing vessels to use for floating platforms that are assembled at port (with or without the turbine).", + desc=( + "Number of towing vessels to use for floating platforms that" + " are assembled at port (with or without the turbine)." + ), ) self.add_discrete_input( "num_station_keeping", 3, - desc="Number of station keeping vessels that attach to floating platforms under tow-out.", + desc=( + "Number of station keeping vessels that attach to floating" + " platforms under tow-out." + ), ) self.add_discrete_input( "ahts_vessels", 1, - desc="Number of ahts vessels that attach to floating platforms under tow-out.", + desc="Number of ahts vessels that attach to floating platforms under tow-out.", # noqa: E501 ) self.add_discrete_input( "oss_install_vessel", "example_heavy_lift_vessel", - desc="Vessel configuration to use for installation of offshore substations.", + desc="Vessel configuration to use for installation of offshore substations.", # noqa: E501 ) # Site self.add_input("site_depth", 40.0, units="m", desc="Site depth.") - self.add_input("site_distance", 40.0, units="km", desc="Distance from site to installation port.") self.add_input( - "site_distance_to_landfall", 50.0, units="km", desc="Distance from site to landfall for export cable." + "site_distance", + 40.0, + units="km", + desc="Distance from site to installation port.", + ) + self.add_input( + "site_distance_to_landfall", + 50.0, + units="km", + desc="Distance from site to landfall for export cable.", + ) + self.add_input( + "interconnection_distance", + 3.0, + units="km", + desc="Distance from landfall to interconnection.", + ) + self.add_input( + "site_mean_windspeed", + 9.0, + units="m/s", + desc="Mean windspeed of the site.", ) - self.add_input("interconnection_distance", 3.0, units="km", desc="Distance from landfall to interconnection.") - self.add_input("site_mean_windspeed", 9.0, units="m/s", desc="Mean windspeed of the site.") # Plant - self.add_discrete_input("number_of_turbines", 60, desc="Number of turbines.") - self.add_input("plant_turbine_spacing", 7, desc="Turbine spacing in rotor diameters.") - self.add_input("plant_row_spacing", 7, desc="Row spacing in rotor diameters. Not used in ring layouts.") + self.add_discrete_input( + "number_of_turbines", 60, desc="Number of turbines.", + ) self.add_input( - "plant_substation_distance", 1, units="km", desc="Distance from first turbine in string to substation." + "plant_turbine_spacing", + 7, + desc="Turbine spacing in rotor diameters.", + ) + self.add_input( + "plant_row_spacing", + 7, + desc="Row spacing in rotor diameters. Not used in ring layouts.", + ) + self.add_input( + "plant_substation_distance", + 1, + units="km", + desc="Distance from first turbine in string to substation.", ) # Turbine - self.add_input("turbine_rating", 8.0, units="MW", desc="Rated capacity of a turbine.") - self.add_input("turbine_rated_windspeed", 11.0, units="m/s", desc="Rated windspeed of the turbine.") - self.add_input("turbine_capex", 1100, units="USD/kW", desc="Turbine CAPEX") - self.add_input("hub_height", 100.0, units="m", desc="Turbine hub height.") - self.add_input("turbine_rotor_diameter", 130, units="m", desc="Turbine rotor diameter.") - self.add_input("tower_mass", 400.0, units="t", desc="mass of the total tower.") - self.add_input("tower_length", 100.0, units="m", desc="Total length of the tower.") + self.add_input( + "turbine_rating", + 8.0, + units="MW", + desc="Rated capacity of a turbine.", + ) + self.add_input( + "turbine_rated_windspeed", + 11.0, + units="m/s", + desc="Rated windspeed of the turbine.", + ) + self.add_input( + "turbine_capex", 1100, units="USD/kW", desc="Turbine CAPEX", + ) + self.add_input( + "hub_height", 100.0, units="m", desc="Turbine hub height.", + ) + self.add_input( + "turbine_rotor_diameter", + 130, + units="m", + desc="Turbine rotor diameter.", + ) + self.add_input( + "tower_mass", 400.0, units="t", desc="mass of the total tower.", + ) + self.add_input( + "tower_length", + 100.0, + units="m", + desc="Total length of the tower.", + ) self.add_input( "tower_deck_space", 25.0, units="m**2", - desc="Deck space required to transport the tower. Defaults to 0 in order to not be a constraint on installation.", + desc=( + "Deck space required to transport the tower. Defaults to 0 in" + " order to not be a constraint on installation." + ), + ) + self.add_input( + "nacelle_mass", + 500.0, + units="t", + desc="mass of the rotor nacelle assembly (RNA).", ) - self.add_input("nacelle_mass", 500.0, units="t", desc="mass of the rotor nacelle assembly (RNA).") self.add_input( "nacelle_deck_space", 25.0, units="m**2", - desc="Deck space required to transport the rotor nacelle assembly (RNA). Defaults to 0 in order to not be a constraint on installation.", + desc=( + "Deck space required to transport the rotor nacelle assembly" + " (RNA). Defaults to 0 in order to not be a constraint on" + " installation." + ), + ) + self.add_discrete_input( + "number_of_blades", 3, desc="Number of blades per turbine.", + ) + self.add_input( + "blade_mass", 50.0, units="t", desc="mass of an individual blade.", ) - self.add_discrete_input("number_of_blades", 3, desc="Number of blades per turbine.") - self.add_input("blade_mass", 50.0, units="t", desc="mass of an individual blade.") self.add_input( "blade_deck_space", 100.0, units="m**2", - desc="Deck space required to transport a blade. Defaults to 0 in order to not be a constraint on installation.", + desc=( + "Deck space required to transport a blade. Defaults to 0 in" + " order to not be a constraint on installation." + ), ) # Mooring - self.add_discrete_input("num_mooring_lines", 3, desc="Number of mooring lines per platform.") - self.add_input("mooring_line_mass", 1e4, units="kg", desc="Total mass of a mooring line") - self.add_input("mooring_line_diameter", 0.1, units="m", desc="Cross-sectional diameter of a mooring line") - self.add_input("mooring_line_length", 1e3, units="m", desc="Unstretched mooring line length") - self.add_input("anchor_mass", 1e4, units="kg", desc="Total mass of an anchor") - self.add_input("mooring_line_cost", 0.5e6, units="USD", desc="Mooring line unit cost.") - self.add_input("mooring_anchor_cost", 0.1e6, units="USD", desc="Mooring line unit cost.") - self.add_discrete_input("anchor_type", "drag_embedment", desc="Number of mooring lines per platform.") + self.add_discrete_input( + "num_mooring_lines", + 3, + desc="Number of mooring lines per platform.", + ) + self.add_input( + "mooring_line_mass", + 1e4, + units="kg", + desc="Total mass of a mooring line", + ) + self.add_input( + "mooring_line_diameter", + 0.1, + units="m", + desc="Cross-sectional diameter of a mooring line", + ) + self.add_input( + "mooring_line_length", + 1e3, + units="m", + desc="Unstretched mooring line length", + ) + self.add_input( + "anchor_mass", 1e4, units="kg", desc="Total mass of an anchor", + ) + self.add_input( + "mooring_line_cost", + 0.5e6, + units="USD", + desc="Mooring line unit cost.", + ) + self.add_input( + "mooring_anchor_cost", + 0.1e6, + units="USD", + desc="Mooring line unit cost.", + ) + self.add_discrete_input( + "anchor_type", + "drag_embedment", + desc="Number of mooring lines per platform.", + ) # Port - self.add_input("port_cost_per_month", 2e6, units="USD/mo", desc="Monthly port costs.") self.add_input( - "takt_time", 170.0, units="h", desc="Substructure assembly cycle time when doing assembly at the port." + "port_cost_per_month", + 2e6, + units="USD/mo", + desc="Monthly port costs.", + ) + self.add_input( + "takt_time", + 170.0, + units="h", + desc="Substructure assembly cycle time when doing assembly at the port.", # noqa: E501 ) self.add_discrete_input( - "num_assembly_lines", 1, desc="Number of assembly lines used when assembly occurs at the port." + "num_assembly_lines", + 1, + desc="Number of assembly lines used when assembly occurs at the port.", # noqa: E501 ) self.add_discrete_input( "num_port_cranes", 1, - desc="Number of cranes used at the port to load feeders / WTIVS when assembly occurs on-site or assembly cranes when assembling at port.", + desc=( + "Number of cranes used at the port to load feeders / WTIVS" + " when assembly occurs on-site or assembly cranes when" + " assembling at port." + ), ) # Floating Substructures - self.add_input("floating_substructure_cost", 10e6, units="USD", desc="Floating substructure unit cost.") + self.add_input( + "floating_substructure_cost", + 10e6, + units="USD", + desc="Floating substructure unit cost.", + ) # Monopile - self.add_input("monopile_length", 100.0, units="m", desc="Length of monopile (including pile).") - self.add_input("monopile_diameter", 7.0, units="m", desc="Diameter of monopile.") - self.add_input("monopile_mass", 900.0, units="t", desc="mass of an individual monopile.") - self.add_input("monopile_cost", 4e6, units="USD", desc="Monopile unit cost.") + self.add_input( + "monopile_length", + 100.0, + units="m", + desc="Length of monopile (including pile).", + ) + self.add_input( + "monopile_diameter", 7.0, units="m", desc="Diameter of monopile.", + ) + self.add_input( + "monopile_mass", + 900.0, + units="t", + desc="mass of an individual monopile.", + ) + self.add_input( + "monopile_cost", 4e6, units="USD", desc="Monopile unit cost.", + ) # Jacket - self.add_input("jacket_length", 65.0, units="m", desc="Length/height of jacket (including pile/buckets).") - self.add_input("jacket_mass", 900.0, units="t", desc="mass of an individual jacket.") - self.add_input("jacket_cost", 4e6, units="USD", desc="Jacket unit cost.") - self.add_input("jacket_r_foot", 10.0, units="m", desc="Radius of jacket legs at base from centeroid.") + self.add_input( + "jacket_length", + 65.0, + units="m", + desc="Length/height of jacket (including pile/buckets).", + ) + self.add_input( + "jacket_mass", + 900.0, + units="t", + desc="mass of an individual jacket.", + ) + self.add_input( + "jacket_cost", 4e6, units="USD", desc="Jacket unit cost.", + ) + self.add_input( + "jacket_r_foot", + 10.0, + units="m", + desc="Radius of jacket legs at base from centeroid.", + ) # Generic fixed-bottom - self.add_input("transition_piece_mass", 250.0, units="t", desc="mass of an individual transition piece.") + self.add_input( + "transition_piece_mass", + 250.0, + units="t", + desc="mass of an individual transition piece.", + ) self.add_input( "transition_piece_deck_space", 25.0, units="m**2", - desc="Deck space required to transport a transition piece. Defaults to 0 in order to not be a constraint on installation.", + desc=( + "Deck space required to transport a transition piece." + " Defaults to 0 in order to not be a constraint on" + " installation." + ), + ) + self.add_input( + "transition_piece_cost", + 1.5e6, + units="USD", + desc="Transition piece unit cost.", ) - self.add_input("transition_piece_cost", 1.5e6, units="USD", desc="Transition piece unit cost.") # Project - self.add_input("site_auction_price", 100e6, units="USD", desc="Cost to secure site lease") self.add_input( - "site_assessment_plan_cost", 1e6, units="USD", desc="Cost to do engineering plan for site assessment" + "site_auction_price", + 100e6, + units="USD", + desc="Cost to secure site lease", + ) + self.add_input( + "site_assessment_plan_cost", + 1e6, + units="USD", + desc="Cost to do engineering plan for site assessment", + ) + self.add_input( + "site_assessment_cost", + 25e6, + units="USD", + desc="Cost to execute site assessment", + ) + self.add_input( + "construction_operations_plan_cost", + 2.5e6, + units="USD", + desc="Cost to do construction planning", ) - self.add_input("site_assessment_cost", 25e6, units="USD", desc="Cost to execute site assessment") - self.add_input("construction_operations_plan_cost", 2.5e6, units="USD", desc="Cost to do construction planning") self.add_input( "boem_review_cost", 0.0, units="USD", - desc="Cost for additional review by U.S. Dept of Interior Bureau of Ocean Energy Management (BOEM)", + desc=( + "Cost for additional review by U.S. Dept of Interior Bureau" + " of Ocean Energy Management (BOEM)" + ), + ) + self.add_input( + "design_install_plan_cost", + 2.5e6, + units="USD", + desc="Cost to do installation planning", ) - self.add_input("design_install_plan_cost", 2.5e6, units="USD", desc="Cost to do installation planning") # Other - self.add_input("commissioning_pct", 0.01, desc="Commissioning percent.") - self.add_input("decommissioning_pct", 0.15, desc="Decommissioning percent.") + self.add_input( + "commissioning_pct", 0.01, desc="Commissioning percent.", + ) + self.add_input( + "decommissioning_pct", 0.15, desc="Decommissioning percent.", + ) # Outputs # Totals self.add_output( - "bos_capex", 0.0, units="USD", desc="Total BOS CAPEX not including commissioning or decommissioning." + "bos_capex", + 0.0, + units="USD", + desc="Total BOS CAPEX not including commissioning or decommissioning.", # noqa: E501 + ) + self.add_output( + "total_capex", + 0.0, + units="USD", + desc="Total BOS CAPEX including commissioning and decommissioning.", # noqa: E501 + ) + self.add_output( + "total_capex_kW", + 0.0, + units="USD/kW", + desc="Total BOS CAPEX including commissioning and decommissioning.", # noqa: E501 ) self.add_output( - "total_capex", 0.0, units="USD", desc="Total BOS CAPEX including commissioning and decommissioning." + "installation_time", + 0.0, + units="h", + desc="Total balance of system installation time.", ) self.add_output( - "total_capex_kW", 0.0, units="USD/kW", desc="Total BOS CAPEX including commissioning and decommissioning." + "installation_capex", + 0.0, + units="USD", + desc="Total balance of system installation cost.", ) - self.add_output("installation_time", 0.0, units="h", desc="Total balance of system installation time.") - self.add_output("installation_capex", 0.0, units="USD", desc="Total balance of system installation cost.") - def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_outputs): - """""" + def compile_orbit_config_file( + self, inputs, outputs, discrete_inputs, discrete_outputs, + ): + """Compiles the ORBIT configuration dictionary.""" floating_flag = self.options["floating"] jacket_flag = self.options["jacket"] config = { # Vessels - "wtiv": "floating_heavy_lift_vessel" if floating_flag else discrete_inputs["wtiv"], + "wtiv": ( + "floating_heavy_lift_vessel" + if floating_flag + else discrete_inputs["wtiv"] + ), "array_cable_install_vessel": "example_cable_lay_vessel", "array_cable_bury_vessel": "example_cable_lay_vessel", "export_cable_install_vessel": "example_cable_lay_vessel", @@ -252,18 +507,24 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o "site": { "depth": float(inputs["site_depth"]), "distance": float(inputs["site_distance"]), - "distance_to_landfall": float(inputs["site_distance_to_landfall"]), + "distance_to_landfall": float( + inputs["site_distance_to_landfall"] + ), "mean_windspeed": float(inputs["site_mean_windspeed"]), }, "landfall": { - "interconnection_distance": float(inputs["interconnection_distance"]), + "interconnection_distance": float( + inputs["interconnection_distance"], + ), }, "plant": { "layout": "grid", "num_turbines": int(discrete_inputs["number_of_turbines"]), "row_spacing": float(inputs["plant_row_spacing"]), "turbine_spacing": float(inputs["plant_turbine_spacing"]), - "substation_distance": float(inputs["plant_substation_distance"]), + "substation_distance": float( + inputs["plant_substation_distance"] + ), }, # Turbine + components "turbine": { @@ -302,35 +563,54 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o }, "export_system_design": { "cables": "XLPE_1000mm_220kV", - "interconnection_distance": float(inputs["interconnection_distance"]), + "interconnection_distance": float( + inputs["interconnection_distance"] + ), "percent_added_length": 0.1, }, # Phase Specific "OffshoreSubstationInstallation": { - "oss_install_vessel": "floating_heavy_lift_vessel" if floating_flag else "example_heavy_lift_vessel", - "feeder": "floating_barge" if floating_flag else "future_feeder", + "oss_install_vessel": ( + "floating_heavy_lift_vessel" + if floating_flag + else "example_heavy_lift_vessel" + ), + "feeder": ( + "floating_barge" if floating_flag else "future_feeder" + ), "num_feeders": int(discrete_inputs["num_feeders"]), }, # Project development costs "project_development": { - "site_auction_price": float(inputs["site_auction_price"]), # 100e6, - "site_assessment_plan_cost": float(inputs["site_assessment_plan_cost"]), # 1e6, - "site_assessment_cost": float(inputs["site_assessment_cost"]), # 25e6, - "construction_operations_plan_cost": float(inputs["construction_operations_plan_cost"]), # 2.5e6, + "site_auction_price": float( + inputs["site_auction_price"] + ), # 100e6, + "site_assessment_plan_cost": float( + inputs["site_assessment_plan_cost"] + ), # 1e6, + "site_assessment_cost": float( + inputs["site_assessment_cost"] + ), # 25e6, + "construction_operations_plan_cost": float( + inputs["construction_operations_plan_cost"] + ), # 2.5e6, "boem_review_cost": float(inputs["boem_review_cost"]), # 0, - "design_install_plan_cost": float(inputs["design_install_plan_cost"]), # 2.5e6 + "design_install_plan_cost": float( + inputs["design_install_plan_cost"] + ), # 2.5e6 }, # Other "commissioning": float(inputs["commissioning_pct"]), "decomissioning": float(inputs["decommissioning_pct"]), "turbine_capex": float(inputs["turbine_capex"]), # Phases - # Putting monopile or semisub here would override the inputs we assume to get from WISDEM + # Putting monopile or semisub here would override the inputs + # we assume to get from WISDEM "design_phases": [ - #'MonopileDesign', - #'SemiSubmersibleDesign', - #'MooringSystemDesign', - #'ScourProtectionDesign', + # 'MonopileDesign', + # 'SemiSubmersibleDesign', + # 'MooringSystemDesign', + # 'ScourProtectionDesign', "ArraySystemDesign", "ExportSystemDesign", "OffshoreSubstationDesign", @@ -338,16 +618,18 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o } if config["landfall"]["interconnection_distance"]: - warn("landfall dictionary will be deprecated and moved" - " into [export_system_design][landfall].", - DeprecationWarning, - stacklevel=2 + warn( + "landfall dictionary will be deprecated and moved" + " into [export_system_design][landfall].", + DeprecationWarning, + stacklevel=2, ) if config["export_system_design"]["interconnection_distance"]: warn( - "[export_system][interconnection_distance] will be deprecated and" - " moved to [export_system_design][landfall][interconnection_distance].", + "[export_system][interconnection_distance] will be deprecated" + " and moved to" + " [export_system_design][landfall][interconnection_distance].", DeprecationWarning, stacklevel=2, ) @@ -362,7 +644,9 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o "ArrayCableInstallation": ("MooredSubInstallation", 0.25), } else: - fixedStr = "JacketInstallation" if jacket_flag else "MonopileInstallation" + fixedStr = ( + "JacketInstallation" if jacket_flag else "MonopileInstallation" + ) if jacket_flag: monopile = config.get("monopile", {}) @@ -383,13 +667,15 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o if floating_flag: vessels = { "support_vessel": "example_support_vessel", - "ahts_vessel" : "example_ahts_vessel", + "ahts_vessel": "example_ahts_vessel", "towing_vessel": "example_towing_vessel", "mooring_install_vessel": "example_support_vessel", "towing_vessel_groups": { "towing_vessels": int(discrete_inputs["num_towing"]), - "station_keeping_vessels": int(discrete_inputs["num_station_keeping"]), - "ahts_vessels" : int(discrete_inputs["ahts_vessels"]) + "station_keeping_vessels": int( + discrete_inputs["num_station_keeping"] + ), + "ahts_vessels": int(discrete_inputs["ahts_vessels"]), }, } else: @@ -403,8 +689,12 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o # Unique support structure design/assembly if floating_flag: config["port"] = { - "sub_assembly_lines": int(discrete_inputs["num_assembly_lines"]), - "turbine_assembly_cranes": int(discrete_inputs["num_port_cranes"]), + "sub_assembly_lines": int( + discrete_inputs["num_assembly_lines"] + ), + "turbine_assembly_cranes": int( + discrete_inputs["num_port_cranes"] + ), "monthly_rate": float(inputs["port_cost_per_month"]), } @@ -454,7 +744,11 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o "type": "Monopile", "length": float(inputs["monopile_length"]), "diameter": float(inputs["monopile_diameter"]), - "deck_space": 0.25*float(inputs["monopile_diameter"]*inputs["monopile_length"]), + "deck_space": 0.25 + * float( + inputs["monopile_diameter"] + * inputs["monopile_length"] + ), "mass": float(inputs["monopile_mass"]), "unit_cost": float(inputs["monopile_cost"]), } @@ -463,8 +757,11 @@ def compile_orbit_config_file(self, inputs, outputs, discrete_inputs, discrete_o return config def compute(self, inputs, outputs, discrete_inputs, discrete_outputs): + """Creates and runs the project, then gathers the results.""" - config = self.compile_orbit_config_file(inputs, outputs, discrete_inputs, discrete_outputs) + config = self.compile_orbit_config_file( + inputs, outputs, discrete_inputs, discrete_outputs, + ) project = ProjectManager(config) project.run() diff --git a/ORBIT/config.py b/ORBIT/config.py index 4a50732d..d97926d9 100644 --- a/ORBIT/config.py +++ b/ORBIT/config.py @@ -1,10 +1,12 @@ +"""Provides the configuration loading and saving methods.""" + __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -import os +from pathlib import Path import yaml from yaml import Dumper @@ -22,7 +24,7 @@ def load_config(filepath): Path to yaml config file. """ - with open(filepath, "r") as f: + with Path(filepath).open() as f: data = yaml.load(f, Loader=loader) return data @@ -42,13 +44,14 @@ def save_config(config, filepath, overwrite=False): Overwrite file if it already exists. Default: False. """ - dirs = os.path.split(filepath)[0] - if dirs and not os.path.isdir(dirs): - os.makedirs(dirs) + filepath = Path(filepath).resolve() + dirs = filepath.parent + if not dirs.exists(): + dirs.mkdir(parents=True) if overwrite is False: - if os.path.exists(filepath): + if filepath.exists(): raise FileExistsError(f"File already exists at '{filepath}'.") - with open(filepath, "w") as f: + with filepath.open("w") as f: yaml.dump(config, f, Dumper=Dumper, default_flow_style=False) diff --git a/ORBIT/core/cargo.py b/ORBIT/core/cargo.py index 843d655e..6d6bf3c7 100644 --- a/ORBIT/core/cargo.py +++ b/ORBIT/core/cargo.py @@ -1,13 +1,13 @@ -""" - -""" +"""Provides the ``Cargo`` base class.""" from marmot import Object class Cargo(Object): + """Base class for working with cargo.""" def __repr__(self): + """Overridden __repr__ method.""" return self.type @property diff --git a/ORBIT/core/components.py b/ORBIT/core/components.py index e4e3792c..15ba6392 100644 --- a/ORBIT/core/components.py +++ b/ORBIT/core/components.py @@ -14,7 +14,7 @@ class Crane: - """Base Crane Class""" + """Base Crane Class.""" def __init__(self, crane_specs): """ @@ -72,7 +72,7 @@ def reequip(**kwargs): class DynamicPositioning: - """Base Dynamic Positioning Class""" + """Base Dynamic Positioning Class.""" def __init__(self, dp_specs): """ @@ -100,7 +100,7 @@ def extract_dp_specs(self, dp_specs): class JackingSys: - """Base Jacking System Class""" + """Base Jacking System Class.""" def __init__(self, jacksys_specs): """ @@ -153,15 +153,15 @@ def jacking_time(self, extension, depth): """ if extension > self.max_extension: - raise Exception( - "{} extension is greater than {} maximum" - "".format(extension, self.max_extension) + msg = ( + f"{extension} extension is greater than {self.max_extension}" + " maximum" ) + raise Exception(msg) elif depth > self.max_depth: raise Exception( - "{} is beyond the operating depth {}" - "".format(depth, self.max_depth) + f"{depth} is beyond the operating depth {self.max_depth}" ) elif depth > extension: @@ -175,12 +175,17 @@ def jacking_time(self, extension, depth): class VesselStorage(simpy.FilterStore): - """Vessel Storage Class""" + """Vessel Storage Class.""" required_keys = ["type", "mass", "deck_space"] def __init__( - self, env, max_cargo, max_deck_space, max_deck_load, **kwargs + self, + env, + max_cargo, + max_deck_space, + max_deck_load, + **kwargs, ): """ Creates an instance of VesselStorage. @@ -291,7 +296,7 @@ def any_remaining(self, _type): class ScourProtectionStorage(simpy.Container): - """Scour Protection Storage Class""" + """Scour Protection Storage Class.""" def __init__(self, env, max_mass, **kwargs): """ @@ -316,7 +321,7 @@ def available_capacity(self): class CableCarousel(simpy.Container): - """Cable Storage Class""" + """Cable Storage Class.""" def __init__(self, env, max_mass, **kwargs): """ @@ -342,7 +347,7 @@ def available_mass(self): @property def current_mass(self): - """Returns current cargo mass""" + """Returns current cargo mass.""" try: mass = self.level * self.cable.linear_density diff --git a/ORBIT/core/defaults/__init__.py b/ORBIT/core/defaults/__init__.py index 7df591ec..bbc9ee9f 100644 --- a/ORBIT/core/defaults/__init__.py +++ b/ORBIT/core/defaults/__init__.py @@ -5,17 +5,17 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -import os +from pathlib import Path import yaml from ORBIT.core.library import loader -DIR = os.path.split(__file__)[0] +DIR = Path(__file__).parent -with open(os.path.join(DIR, "process_times.yaml"), "r") as f: +with (DIR / "process_times.yaml").open() as f: process_times = yaml.load(f, Loader=loader) -with open(os.path.join(DIR, "common_costs.yaml"), "r") as f: +with (DIR / "common_costs.yaml").open() as f: common_costs = yaml.load(f, Loader=loader) diff --git a/ORBIT/core/environment.py b/ORBIT/core/environment.py index 4654ec13..dee120e3 100644 --- a/ORBIT/core/environment.py +++ b/ORBIT/core/environment.py @@ -227,10 +227,10 @@ def extrapolate_ws(self, h1, h): self.state = np.array(append_fields(self.state, f"windspeed_{h}m", ts)) @staticmethod - def simplify_num(str): + def simplify_num(string): """Returns the simplest str representation of a number.""" - num = float(str) + num = float(string) if int(num) == num: return int(num) diff --git a/ORBIT/core/exceptions.py b/ORBIT/core/exceptions.py index 8d7d0ca4..b3219c38 100644 --- a/ORBIT/core/exceptions.py +++ b/ORBIT/core/exceptions.py @@ -7,6 +7,7 @@ import os +from pathlib import Path class MissingComponent(Exception): @@ -31,12 +32,12 @@ def __init__(self, vessel, component): ) def __str__(self): - + """Provides the string error message.""" return self.message class ItemNotFound(Exception): - """Error for when no items in list satisfy rule""" + """Error for when no items in list satisfy rule.""" def __init__(self, rule): """ @@ -51,19 +52,20 @@ def __init__(self, rule): self.message = f"No items found that satisfy: {rule}" def __str__(self): + """Provides the string error message.""" return self.message class CargoMassExceeded(Exception): - """Error for exceeding vessel maximum cargo mass""" + """Error for exceeding vessel maximum cargo mass.""" - def __init__(self, max, current, item): + def __init__(self, max_mass, current, item): """ Creates an instance of CargoMassExceeded. Parameters ---------- - max : int | float + max_mass : int | float Maximum vessel cargo mass (t). current : int | float Vessel cargo mass currently in use (t). @@ -72,12 +74,13 @@ def __init__(self, max, current, item): a dictionary with a 'type' or the name of an item. """ - self.max = max + self.max = max_mass self.current = current self.item = item self.message = f"'{self.item}' will exceed maximum cargo mass." def __str__(self): + """Provides the string error message.""" return self.message @@ -101,6 +104,7 @@ def __init__(self, item, required): self.message = f"{item} is missing {self.missing}" def __str__(self): + """Provides the string error message.""" return self.message @@ -132,13 +136,12 @@ def __init__(self, current_amount, item_type, amount_requested): ) def __str__(self): + """Provides the string error message.""" return self.message class InsufficientCable(Exception): - """ - Error raised when a Carousel doesn't have enough cable for next section. - """ + """Error for when a Carousel doesn't have enough cable for next section.""" def __init__(self, current_amount, amount_requested): """ @@ -154,14 +157,15 @@ def __init__(self, current_amount, amount_requested): self.current = current_amount self.requested = amount_requested - self.message = f"Not enough cable on carousel." + self.message = "Not enough cable on carousel." def __str__(self): + """Provides the string error message.""" return self.message class PhaseNotFound(Exception): - """Exception for missing Phase""" + """Exception for missing Phase.""" def __init__(self, p): """ @@ -177,6 +181,7 @@ def __init__(self, p): self.message = f"Unrecognized phase '{self.phase}'." def __str__(self): + """Provides a string of the error message.""" return self.message @@ -197,6 +202,7 @@ def __init__(self, k): self.message = f"Input(s) '{self.keys}' missing in config." def __str__(self): + """Provides a string of the error message.""" return self.message @@ -224,11 +230,12 @@ def __init__(self, start, weather): ) def __str__(self): + """Provides a string of the error message.""" return self.message class LibraryItemNotFoundError(Exception): - """Error for missing library data""" + """Error for missing library data.""" def __init__(self, sub_dir, name): """ @@ -242,11 +249,12 @@ def __init__(self, sub_dir, name): Filename of item to be extracted. """ - self.dir = os.path.join(os.environ["DATA_LIBRARY"], sub_dir) + self.dir = Path(os.environ["DATA_LIBRARY"]) / sub_dir self.name = name self.message = f"{self.name} not found in {self.dir}." def __str__(self): + """Provides a string of the error message.""" return self.message @@ -276,21 +284,19 @@ def __init__(self, agent, duration, max_windspeed, max_waveheight): self.max_waveheight = max_waveheight self.message = ( - "No weather window found for '{}' that satisfies:" - "\n\tMaximum Windspeed: {:.2f}" - "\n\tMaximum Waveheight: {:.2f}" - "\n\tDuration: {:.2f}" - "".format(agent, max_windspeed, max_waveheight, duration) + f"No weather window found for '{agent}' that satisfies:" + f"\n\tMaximum Windspeed: {max_windspeed:.2f}" + f"\n\tMaximum Waveheight: {max_waveheight:.2f}" + f"\n\tDuration: {duration:.2f}" ) def __str__(self): + """Provides a string of the error message.""" return self.message class WeatherProfileExhausted(Exception): - """ - Error to be raised at the end of the weather data. - """ + """Error to be raised at the end of the weather data.""" def __init__(self, length): """ @@ -304,11 +310,10 @@ def __init__(self, length): self.length = length - self.message = "Weather profile exhausted at element {:,.0f}".format( - length - ) + self.message = f"Weather profile exhausted at element {length:,.0f}" def __str__(self): + """Provides a string of the error message.""" return self.message @@ -337,6 +342,7 @@ def __init__(self, vessel, items): ) def __str__(self): + """Provides a string of the error message.""" return self.message @@ -345,7 +351,7 @@ class FastenTimeNotFound(Exception): def __init__(self, item): """ - Creates an instance of FastenTimeNotFound + Creates an instance of FastenTimeNotFound. Parameters ---------- @@ -358,6 +364,7 @@ def __init__(self, item): self.message = f"Unknown fasten time for item type '{item}'." def __str__(self): + """Provides a string of the error message.""" return self.message @@ -379,4 +386,5 @@ def __init__(self, phases): self.message = f"Phase dependencies {phases} are not resolvable." def __str__(self): + """Provides a string of the error message.""" return self.message diff --git a/ORBIT/core/library.py b/ORBIT/core/library.py index e33b4523..bf678dcf 100644 --- a/ORBIT/core/library.py +++ b/ORBIT/core/library.py @@ -34,24 +34,30 @@ import re import csv import warnings +from pathlib import Path import yaml import pandas as pd from yaml import Dumper + from ORBIT.core.exceptions import LibraryItemNotFoundError -ROOT = os.path.abspath(os.path.join(os.path.abspath(__file__), "../../..")) -default_library = os.path.join(ROOT, "library") +ROOT = Path(__file__).parents[2] +default_library = ROOT / "library" # Need a custom loader to read in scientific notation correctly class CustomSafeLoader(yaml.SafeLoader): + """Custom loader that enables tuple sequences in YAML files.""" + def construct_python_tuple(self, node): + """Constructs the tuple.""" return tuple(self.construct_sequence(node)) CustomSafeLoader.add_constructor( - "tag:yaml.org,2002:python/tuple", CustomSafeLoader.construct_python_tuple + "tag:yaml.org,2002:python/tuple", + CustomSafeLoader.construct_python_tuple, ) loader = CustomSafeLoader @@ -96,14 +102,15 @@ def initialize_library(library_path): if library_path is None: library_path = default_library - if not os.path.isdir(library_path): - raise ValueError(f"Invalid library path.") + library_path = Path(library_path).resolve() + if not library_path.is_dir(): + raise ValueError("Invalid library path.") - os.environ["DATA_LIBRARY"] = library_path + os.environ["DATA_LIBRARY"] = str(library_path) print(f"ORBIT library intialized at '{library_path}'") -def extract_library_data(config, additional_keys=[]): +def extract_library_data(config, additional_keys=None): """ Extracts the configuration data from the specified library. @@ -111,7 +118,7 @@ def extract_library_data(config, additional_keys=[]): ---------- config : dict Configuration dictionary. - additional_keys : list + additional_keys : list | None Additional keys that contain data that needs to be extracted from within `config`, by default []. @@ -121,6 +128,9 @@ def extract_library_data(config, additional_keys=[]): Configuration dictionary. """ + if additional_keys is None: + additional_keys = [] + if os.environ.get("DATA_LIBRARY", None) is None: return config @@ -167,14 +177,14 @@ def extract_library_specs(key, filename, file_type="yaml"): filename = f"{filename}.{file_type}" path = PATH_LIBRARY[key] - filepath = os.path.join(os.environ["DATA_LIBRARY"], path, filename) + filepath = Path(os.environ["DATA_LIBRARY"]) / path / filename - if os.path.isfile(filepath): + if filepath.is_file(): return _extract_file(filepath) - if os.environ["DATA_LIBRARY"] != default_library: - filepath = os.path.join(default_library, path, filename) - if os.path.isfile(filepath): + if Path(os.environ["DATA_LIBRARY"]) != default_library: + filepath = default_library / path / filename + if filepath.is_file(): return _extract_file(filepath) raise LibraryItemNotFoundError(path, filename) @@ -186,30 +196,27 @@ def _extract_file(filepath): Parameters ---------- - filepath : str + filepath : pathlib.Path Valid filepath of library item. """ - if filepath.endswith("yaml"): - f = open(filepath, "r") - fyaml = yaml.load(f, Loader=loader) - f.close() + ftype = filepath.suffix + if ftype in (".yaml", ".yml"): + with filepath.open() as f: + fyaml = yaml.load(f, Loader=loader) return fyaml - elif filepath.endswith("csv"): + elif ftype == ".csv": df = pd.read_csv(filepath, index_col=False) # Drop empty rows and columns - df.dropna(how="all", inplace=True) - df.dropna(how="all", inplace=True, axis=1) + df = df.dropna(how="all").dropna(how="all", axis=1) # Enforce strictly lowercase and "_" separated column names df.columns = [el.replace(" ", "_").lower() for el in df.columns] return df - else: - _type = filepath.split(".")[-1] - raise TypeError(f"File type {_type} not supported for extraction.") + raise TypeError(f"File type {ftype} not supported for extraction.") def _get_yes_no_response(filename): @@ -244,16 +251,15 @@ def export_library_specs(key, filename, data, file_ext="yaml"): filename = f"{filename}.{file_ext}" path = PATH_LIBRARY[key] - data_path = os.path.join(os.environ["DATA_LIBRARY"], path, filename) - if os.path.isfile(data_path) and not _get_yes_no_response(data_path): + data_path = Path(os.environ["DATA_LIBRARY"]) / path / filename + if data_path.is_file() and not _get_yes_no_response(data_path): print("Cancelling save!") return if file_ext == "yaml": - f = open(data_path, "w") - yaml.dump(data, f, Dumper=Dumper, default_flow_style=False) - f.close() + with data_path.open("w") as f: + yaml.dump(data, f, Dumper=Dumper, default_flow_style=False) elif file_ext == "csv": - with open(data_path, "w") as f: + with data_path.open("w") as f: writer = csv.writer(f) writer.writerows(data) print("Save complete!") @@ -285,11 +291,11 @@ def export_library_specs(key, filename, data, file_ext="yaml"): "export_system": "cables", "export_system_design": "cables", # project details - "config": os.path.join("project", "config"), - "plant": os.path.join("project", "plant"), - "port": os.path.join("project", "ports"), - "project_development": os.path.join("project", "development"), - "site": os.path.join("project", "site"), + "config": str(Path("project") / "config"), + "plant": str(Path("project") / "plant"), + "port": str(Path("project") / "ports"), + "project_development": str(Path("project") / "development"), + "site": str(Path("project") / "site"), # substructures "monopile": "substructures", "monopile_design": "substructures", diff --git a/ORBIT/core/logic/__init__.py b/ORBIT/core/logic/__init__.py index 7c928e57..24b00f63 100644 --- a/ORBIT/core/logic/__init__.py +++ b/ORBIT/core/logic/__init__.py @@ -1,4 +1,4 @@ -"""This package contains simulation logic shared across several modules.""" +"""Provides the simulation logic shared across several modules.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/ORBIT/core/logic/vessel_logic.py b/ORBIT/core/logic/vessel_logic.py index b27a3e78..a906a89a 100644 --- a/ORBIT/core/logic/vessel_logic.py +++ b/ORBIT/core/logic/vessel_logic.py @@ -1,4 +1,4 @@ -"""This module contains common simulation logic related to vessels.""" +"""Provides common simulation logic related to vessels.""" __author__ = ["Jake Nunemaker", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -71,13 +71,17 @@ def stabilize(vessel, **kwargs): extension = kwargs.get("extension", site_depth + 10) jackup_time = jacksys.jacking_time(extension, site_depth) yield vessel.task_wrapper( - "Jackup", jackup_time, constraints=vessel.transit_limits, **kwargs + "Jackup", + jackup_time, + constraints=vessel.transit_limits, + **kwargs, ) - except MissingComponent: + except MissingComponent as exc: raise MissingComponent( - vessel, ["Dynamic Positioning", "Jacking System"] - ) + vessel, + ["Dynamic Positioning", "Jacking System"], + ) from exc @process @@ -123,7 +127,9 @@ def position_onsite(vessel, **kwargs): position_time = kwargs.get("site_position_time", pt["site_position_time"]) yield vessel.task_wrapper( - "Position Onsite", position_time, constraints=vessel.transit_limits + "Position Onsite", + position_time, + constraints=vessel.transit_limits, ) @@ -162,7 +168,10 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): # Get list of items try: yield get_list_of_items_from_port( - vessel, port, items, **kwargs + vessel, + port, + items, + **kwargs, ) except ItemNotFound: @@ -178,7 +187,9 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): vessel.update_trip_data() vessel.at_port = False yield vessel.task_wrapper( - "Transit", transit_time, constraints=vessel.transit_limits + "Transit", + transit_time, + constraints=vessel.transit_limits, ) yield stabilize(vessel, **kwargs) vessel.at_site = True @@ -194,7 +205,9 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): queue_time = vessel.env.now - queue_start if queue_time > 0: vessel.submit_action_log( - "Queue", queue_time, location="Site" + "Queue", + queue_time, + location="Site", ) queue.vessel = vessel @@ -207,7 +220,9 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): active_time = vessel.env.now - active_start vessel.submit_action_log( - "ActiveFeeder", active_time, location="Site" + "ActiveFeeder", + active_time, + location="Site", ) queue.vessel = None @@ -217,7 +232,9 @@ def shuttle_items_to_queue(vessel, port, queue, distance, items, **kwargs): vessel.at_site = False yield jackdown_if_required(vessel, **kwargs) yield vessel.task_wrapper( - "Transit", transit_time, constraints=vessel.transit_limits + "Transit", + transit_time, + constraints=vessel.transit_limits, ) vessel.at_port = True @@ -307,7 +324,14 @@ def get_list_of_items_from_port(vessel, port, items, **kwargs): @process def shuttle_items_to_queue_wait( - vessel, port, queue, distance, items, per_trip, assigned, **kwargs + vessel, + port, + queue, + distance, + items, + per_trip, + assigned, + **kwargs, ): """ Shuttles a list of items from port to queue. @@ -338,13 +362,18 @@ def shuttle_items_to_queue_wait( # Get list of items per_trip = max([per_trip, 1]) yield get_list_of_items_from_port_wait( - vessel, port, items * per_trip, **kwargs + vessel, + port, + items * per_trip, + **kwargs, ) # Transit to site vessel.update_trip_data() yield vessel.task( - "Transit", transit_time, constraints=vessel.transit_limits + "Transit", + transit_time, + constraints=vessel.transit_limits, ) yield stabilize(vessel, **kwargs) @@ -369,7 +398,9 @@ def shuttle_items_to_queue_wait( active_time = vessel.env.now - active_start vessel.submit_action_log( - "ActiveFeeder", active_time, location="Site" + "ActiveFeeder", + active_time, + location="Site", ) queue.vessel = None @@ -379,7 +410,9 @@ def shuttle_items_to_queue_wait( vessel.at_site = False yield jackdown_if_required(vessel, **kwargs) yield vessel.task( - "Transit", transit_time, constraints=vessel.transit_limits + "Transit", + transit_time, + constraints=vessel.transit_limits, ) n += per_trip @@ -411,7 +444,7 @@ def get_list_of_items_from_port_wait(vessel, port, items, **kwargs): for i in items: wait_start = vessel.env.now - item = yield port.get(lambda x: x.type == i) + item = yield port.get(lambda x: x.type == i) # noqa: B023 wait_time = vessel.env.now - wait_start if wait_time > 0: @@ -422,5 +455,8 @@ def get_list_of_items_from_port_wait(vessel, port, items, **kwargs): if time > 0: yield vessel.task( - action, time, constraints=vessel.transit_limits, **kwargs + action, + time, + constraints=vessel.transit_limits, + **kwargs, ) diff --git a/ORBIT/core/port.py b/ORBIT/core/port.py index dbfc152a..9078768a 100644 --- a/ORBIT/core/port.py +++ b/ORBIT/core/port.py @@ -12,7 +12,7 @@ class Port(simpy.FilterStore): - """Port Class""" + """Port Class.""" def __init__(self, env, **kwargs): """ diff --git a/ORBIT/core/supply_chain.py b/ORBIT/core/supply_chain.py index 0f2f3e1a..6314bbdb 100644 --- a/ORBIT/core/supply_chain.py +++ b/ORBIT/core/supply_chain.py @@ -9,10 +9,16 @@ class SubstructureDelivery(Agent): - """""" + """Simulates the substrucutre delivery process.""" def __init__( - self, component, num, deilvery_time, port, items, num_parallel=1 + self, + component, + num, + deilvery_time, + port, + items, + num_parallel=1, ): """ Creates an instance of `SupplyChain`. @@ -41,6 +47,7 @@ def __init__( @process def start(self): + """Starts the delivery processes.""" n = 0 while n < self.num: diff --git a/ORBIT/core/vessel.py b/ORBIT/core/vessel.py index 88c823a4..430ea2bc 100644 --- a/ORBIT/core/vessel.py +++ b/ORBIT/core/vessel.py @@ -5,16 +5,11 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -from math import ceil from collections import Counter, namedtuple import numpy as np from marmot import Agent, le, process -from marmot._exceptions import ( - StateExhausted, - WindowNotFound, - AgentNotRegistered, -) +from marmot._exceptions import AgentNotRegistered from ORBIT.core.components import ( Crane, @@ -30,7 +25,7 @@ class Vessel(Agent): - """Base Vessel Class""" + """Base Vessel Class.""" def __init__(self, name, config, avail=1): """ @@ -84,9 +79,16 @@ def submit_action_log(self, action, duration, **kwargs): @process def task_wrapper( - self, name, duration, constraints={}, suspendable=False, **kwargs + self, + name, + duration, + constraints=None, + suspendable=False, + **kwargs, ): - + """Wraps the ``task`` method and provides two checks.""" + if constraints is None: + constraints = {} duration /= self.avail yield self.task(name, duration, constraints, suspendable, **kwargs) @@ -100,7 +102,7 @@ def extract_vessel_dayrate(self): self.day_rate = self.config["vessel_specs"]["day_rate"] except KeyError: - self.day_rate = np.NaN + self.day_rate = np.nan def mobilize(self): """ @@ -135,8 +137,8 @@ def crane(self): try: return self._crane - except AttributeError: - raise MissingComponent(self, "Crane") + except AttributeError as exc: + raise MissingComponent(self, "Crane") from exc @property def jacksys(self): @@ -144,17 +146,17 @@ def jacksys(self): try: return self._jacksys - except AttributeError: - raise MissingComponent(self, "Jacking System") + except AttributeError as exc: + raise MissingComponent(self, "Jacking System") from exc @property def dynamic_positioning(self): - """Returns configured `DynamicPositioning` or raises `MissingComponent`.""" + """Returns `DynamicPositioning` or raises `MissingComponent`.""" try: return self._dp_system - except AttributeError: - raise MissingComponent(self, "Dynamic Positioning") + except AttributeError as exc: + raise MissingComponent(self, "Dynamic Positioning") from exc @property def storage(self): @@ -162,17 +164,20 @@ def storage(self): try: return self._storage - except AttributeError: - return MissingComponent(self, "Vessel Storage") + except AttributeError as exc: + raise MissingComponent(self, "Vessel Storage") from exc @property def rock_storage(self): - """Returns configured `ScourProtectionStorage` or raises `MissingComponent`.""" + """ + Returns configured `ScourProtectionStorage` or raises + `MissingComponent`. + """ try: return self._rock_storage - except AttributeError: - raise MissingComponent(self, "Scour Protection Storage") + except AttributeError as exc: + raise MissingComponent(self, "Scour Protection Storage") from exc @property def cable_storage(self): @@ -180,8 +185,8 @@ def cable_storage(self): try: return self._cable_storage - except AttributeError: - raise MissingComponent(self, "Cable Storage") + except AttributeError as exc: + raise MissingComponent(self, "Cable Storage") from exc def initialize(self, mobilize=True): """ @@ -237,13 +242,14 @@ def extract_storage_specs(self): self._storage = VesselStorage(self.env, **self._storage_specs) def extract_cable_storage_specs(self): - """Extracts and defines cable storage system specifications if found.""" + """Extracts and defines cable storage system specifications.""" self._cable_storage_specs = self.config.get("cable_storage", {}) if self._cable_storage_specs: self.trip_data = [] self._cable_storage = CableCarousel( - self.env, **self._cable_storage_specs + self.env, + **self._cable_storage_specs, ) def extract_scour_protection_specs(self): @@ -269,12 +275,17 @@ def extract_scour_protection_specs(self): self._rock_storage = ScourProtectionStorage(self.env, capacity) self.scour_protection_install_speed = self._sp_specs.get( - "scour_protection_install_speed", 10 + "scour_protection_install_speed", + 10, ) @process def get_item_from_storage( - self, _type, vessel=None, release=False, **kwargs + self, + _type, + vessel=None, + release=False, + **kwargs, ): """ Retrieves an item which matches `item.type = _type` from `self.storage` @@ -375,7 +386,7 @@ def operational_limits(self): """ try: - _ = getattr(self, "crane") + _ = self.crane max_windspeed = self._crane_specs["max_windspeed"] except MissingComponent: @@ -403,9 +414,9 @@ def update_trip_data(self, cargo=True, deck=True, items=True): if storage is None: raise Exception("Vessel does not have storage capacity.") - _cargo = storage.current_cargo_mass if cargo else np.NaN - _deck = storage.current_deck_space if deck else np.NaN - _items = dict(Counter(i for i in storage.items)) if items else np.NaN + _cargo = storage.current_cargo_mass if cargo else np.nan + _deck = storage.current_deck_space if deck else np.nan + _items = dict(Counter(i for i in storage.items)) if items else np.nan trip = Trip(cargo_mass=_cargo, deck_space=_deck, items=_items) @@ -426,7 +437,7 @@ def cargo_mass_utilizations(self): return np.array(self.cargo_mass_list) / max_cargo_mass except MissingComponent: - return np.array(np.NaN) + return np.array(np.nan) @property def deck_space_list(self): @@ -443,14 +454,14 @@ def deck_space_utilizations(self): return np.array(self.deck_space_list) / max_deck_space except MissingComponent: - return np.array(np.NaN) + return np.array(np.nan) @property def max_cargo_mass_utilization(self): """Returns maximum cargo mass utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.max(self.cargo_mass_utilizations) @@ -459,7 +470,7 @@ def min_cargo_mass_utilization(self): """Returns minimum cargo mass utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.min(self.cargo_mass_utilizations) @@ -468,7 +479,7 @@ def mean_cargo_mass_utilization(self): """Returns mean cargo mass utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.mean(self.cargo_mass_utilizations) @@ -477,7 +488,7 @@ def median_cargo_mass_utilization(self): """Returns median cargo mass utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.median(self.cargo_mass_utilizations) @@ -486,7 +497,7 @@ def max_deck_space_utilization(self): """Returns maximum deck_space utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.max(self.deck_space_utilizations) @@ -495,7 +506,7 @@ def min_deck_space_utilization(self): """Returns minimum deck_space utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.min(self.deck_space_utilizations) @@ -504,7 +515,7 @@ def mean_deck_space_utilization(self): """Returns mean deck space utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.mean(self.deck_space_utilizations) @@ -513,7 +524,7 @@ def median_deck_space_utilization(self): """Returns median deck space utilization.""" if not self.trip_data: - return np.NaN + return np.nan return np.median(self.deck_space_utilizations) @@ -522,7 +533,7 @@ def max_items_by_mass(self): """Returns items corresponding to `self.max_cargo_mass`.""" if not self.trip_data: - return np.NaN + return np.nan i = np.argmax(self.cargo_mass_list) return self.trip_data[i].items @@ -532,7 +543,7 @@ def min_items_by_mass(self): """Returns items corresponding to `self.min_cargo_mass`.""" if not self.trip_data: - return np.NaN + return np.nan i = np.argmin(self.cargo_mass_list) return self.trip_data[i].items @@ -542,7 +553,7 @@ def max_items_by_space(self): """Returns items corresponding to `self.max_deck_space`.""" if not self.trip_data: - return np.NaN + return np.nan i = np.argmax(self.deck_space_list) return self.trip_data[i].items @@ -552,7 +563,7 @@ def min_items_by_space(self): """Returns items corresponding to `self.min_deck_space`.""" if not self.trip_data: - return np.NaN + return np.nan i = np.argmin(self.deck_space_list) return self.trip_data[i].items diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 303ecbaf..84232f63 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -1,16 +1,21 @@ +""" +Provides the ``ProjectManager`` API for running ORBIT simulations and +calculating results. +""" + __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" __email__ = ["jake.nunemaker@nrel.gov"] -import os import re import datetime as dt import collections.abc as collections from copy import deepcopy from math import ceil from numbers import Number +from pathlib import Path from itertools import product import numpy as np @@ -31,11 +36,11 @@ ArraySystemDesign, ExportSystemDesign, MooringSystemDesign, - SemiTautMooringSystemDesign, ScourProtectionDesign, SemiSubmersibleDesign, CustomArraySystemDesign, OffshoreSubstationDesign, + SemiTautMooringSystemDesign, OffshoreFloatingSubstationDesign, ) from ORBIT.phases.install import ( @@ -71,9 +76,9 @@ class ProjectManager: ExportSystemDesign, ScourProtectionDesign, OffshoreSubstationDesign, - OffshoreFloatingSubstationDesign, + OffshoreFloatingSubstationDesign, MooringSystemDesign, - SemiTautMooringSystemDesign, + SemiTautMooringSystemDesign, SemiSubmersibleDesign, SparDesign, ElectricalDesign, @@ -134,9 +139,12 @@ def __init__(self, config, library_path=None, weather=None): @property def start_date(self): - """Return start date for the analysis. If weather is configured, the - first date in the weather profile is used. If weather is not configured, - an arbitary start date is assumed and used to index phase times.""" + """ + Return start date for the analysis. If weather is configured, the + first date in the weather profile is used. If weather is not + configured, an arbitary start date is assumed and used to index phase + times. + """ if self.weather is not None: return self.weather.index[0].to_pydatetime() @@ -187,7 +195,7 @@ def _print_warnings(self): try: df = pd.DataFrame(self.logs) - df = df.loc[~df["message"].isnull()] + df = df.loc[~df["message"].isna()] df = df.loc[df["message"].str.contains("Exceeded")] for msg in df["message"].unique(): @@ -222,10 +230,12 @@ def register_design_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._design_phases]: - raise ValueError(f"A phase with name '{phase.__name__}' already exists.") + raise ValueError( + f"A phase with name '{phase.__name__}' already exists." + ) if len(re.split("[_ ]", phase.__name__)) > 1: - raise ValueError(f"Registered phase name must not include a '_'.") + raise ValueError("Registered phase name must not include a '_'.") cls._design_phases = (*cls._design_phases, phase) @@ -246,10 +256,12 @@ def register_install_phase(cls, phase): ) if phase.__name__ in [c.__name__ for c in cls._install_phases]: - raise ValueError(f"A phase with name '{phase.__name__}' already exists.") + raise ValueError( + f"A phase with name '{phase.__name__}' already exists." + ) if len(re.split("[_ ]", phase.__name__)) > 1: - raise ValueError(f"Registered phase name must not include a '_'.") + raise ValueError("Registered phase name must not include a '_'.") cls._install_phases = (*cls._install_phases, phase) @@ -353,7 +365,7 @@ def resolve_project_capacity(self): if all((project_capacity, turbine_rating, num_turbines)): if project_capacity != (turbine_rating * num_turbines): raise AttributeError( - f"Input and calculated project capacity don't match." + "Input and calculated project capacity don't match." ) else: @@ -397,9 +409,7 @@ def find_key_match(cls, target): @classmethod def phase_dict(cls): - """ - Returns dictionary of all possible phases with format 'name': 'class'. - """ + """Returns dictionary of all phases with format {'name': 'class'}.""" install = {p.__name__: p for p in cls._install_phases} design = {p.__name__: p for p in cls._design_phases} @@ -426,14 +436,17 @@ def merge_dicts(cls, left, right, overwrite=True, add_keys=True): if not add_keys: right = {k: right[k] for k in set(new).intersection(set(right))} - for k, _ in right.items(): + for k in right.keys(): if ( k in new and isinstance(new[k], dict) and isinstance(right[k], collections.Mapping) ): new[k] = cls.merge_dicts( - new[k], right[k], overwrite=overwrite, add_keys=add_keys + new[k], + right[k], + overwrite=overwrite, + add_keys=add_keys, ) elif ( k in new @@ -517,6 +530,7 @@ def create_config_for_phase(self, phase): @property def phase_ends(self): + """Calculates hte end date for all phases.""" ret = {} for k, t in self.phase_times.items(): @@ -563,11 +577,14 @@ def run_install_phase(self, name, start, **kwargs): if _catch: try: phase = _class( - _config, weather=weather, phase_name=name, **kwargs + _config, + weather=weather, + phase_name=name, + **kwargs, ) phase.run() - except Exception as e: + except Exception as e: # noqa: BLE001 print(f"\n\t - {name}: {e}") return None, None @@ -583,7 +600,8 @@ def run_install_phase(self, name, start, **kwargs): self.phase_starts[name] = start self.phase_times[name] = time self.detailed_outputs = self.merge_dicts( - self.detailed_outputs, phase.detailed_output + self.detailed_outputs, + phase.detailed_output, ) if phase.system_capex: @@ -618,9 +636,7 @@ def get_phase_class(self, phase): return phase_class def run_all_design_phases(self, phase_list, **kwargs): - """ - Runs multiple design phases and adds '.design_result' to self.config. - """ + """Runs the design phases and adds '.design_result' to self.config.""" for name in phase_list: self.run_design_phase(name, **kwargs) @@ -645,7 +661,7 @@ def run_design_phase(self, name, **kwargs): phase = _class(_config) phase.run() - except Exception as e: + except Exception as e: # noqa: BLE001 print(f"\n\t - {name}: {e}") return @@ -656,11 +672,15 @@ def run_design_phase(self, name, **kwargs): self._phases[name] = phase self.design_results = self.merge_dicts( - self.design_results, phase.design_result, overwrite=False + self.design_results, + phase.design_result, + overwrite=False, ) self.config = self.merge_dicts( - self.config, phase.design_result, overwrite=False + self.config, + phase.design_result, + overwrite=False, ) self.detailed_outputs = self.merge_dicts( self.detailed_outputs, phase.detailed_output @@ -685,9 +705,9 @@ def run_multiple_phases_in_serial(self, phase_list, **kwargs): continue else: - for l in logs: + for log in logs: try: - l["time"] += start + log["time"] += start except KeyError: pass @@ -717,9 +737,9 @@ def run_multiple_phases_overlapping(self, phases, **kwargs): continue else: - for l in logs: + for log in logs: try: - l["time"] += start - zero + log["time"] += start - zero except KeyError: pass @@ -765,9 +785,9 @@ def run_dependent_phases(self, _phases, zero, **kwargs): continue else: - for l in logs: + for log in logs: try: - l["time"] += start - zero + log["time"] += start - zero except KeyError: pass @@ -797,11 +817,13 @@ def get_dependency_start_time(self, target, perc): if isinstance(perc, (int, float)): - if (perc < 0.) or (perc > 1.): - raise ValueError(f"Dependent phase perc must be between 0. and 1.") - + if (perc < 0.0) or (perc > 1.0): + raise ValueError( + "Dependent phase perc must be between 0. and 1." + ) + return start + elapsed * perc - + if isinstance(perc, str): try: @@ -814,11 +836,12 @@ def get_dependency_start_time(self, target, perc): return start + delta.days * 24 + delta.seconds / 3600 - except (TypeError, IndexError): + except (TypeError, IndexError) as exc: raise ValueError( - f"Dependent phase amount must be defined with this format: " - "'weeks=1;hours=12'. Accepted entries: 'weeks', 'days', 'hours'." - ) + "Dependent phase amount must be defined with this" + " format: 'weeks=1;hours=12'. Accepted entries: 'weeks'," + " 'days', 'hours'." + ) from exc else: raise ValueError( @@ -855,7 +878,8 @@ def transform_weather_input(weather): def _parse_install_phase_values(self, phases): """ Parses the input dictionary `install_phases`, splitting them into - phases that have defined start times and ones that rely on other phases. + phases that have defined start times and ones that rely on other + phases. Parameters ---------- @@ -885,14 +909,15 @@ def _parse_install_phase_values(self, phases): if not defined: raise ValueError("No phases have a defined start index/date.") - - if len(set(type(i) for i in defined.values())) > 1: + + if len({type(i) for i in defined.values()}) > 1: raise ValueError( - "Defined start date types can't be mixed. " - "All must be an int (index location) or str (format: '%m/%d/%Y'). " - "This does not apply to the dependent phases defined as tuples." + "Defined start date types can't be mixed." + " All must be an int (index location) or str (format:" + " '%m/%d/%Y'). This does not apply to the dependent phases" + " defined as tuples." ) - + for k, v in defined.items(): if isinstance(v, int): @@ -904,13 +929,13 @@ def _parse_install_phase_values(self, phases): try: defined[k] = self.weather.index.get_loc(_dt) - except KeyError: - raise WeatherProfileError(_dt, self.weather) - + except KeyError as exc: + raise WeatherProfileError(_dt, self.weather) from exc + else: - delta = (_dt - self.start_date) + delta = _dt - self.start_date defined[k] = delta.days * 24 + delta.seconds / 3600 - + return defined, depends def get_weather_profile(self, start): @@ -1001,7 +1026,7 @@ def num_turbines(self): @property def turbine_rating(self): - """Returns turbine rating in MW""" + """Returns turbine rating in MW.""" try: rating = self.config["turbine"]["turbine_rating"] @@ -1015,7 +1040,7 @@ def turbine_rating(self): def logs(self): """Returns list of all logs in the project.""" - return sorted(self._output_logs, key=lambda l: l["time"]) + return sorted(self._output_logs, key=lambda x: x["time"]) @property def project_time(self): @@ -1032,14 +1057,16 @@ def month_bins(self): @property def monthly_expenses(self): """Returns the monthly expenses of the project from development through - construction.""" + construction. + """ opex = self.monthly_opex lifetime = self.project_params.get("project_lifetime", 25) _expense_logs = self._filter_logs(keys=["cost", "time"]) expenses = np.array( - _expense_logs, dtype=[("cost", "f8"), ("time", "i4")] + _expense_logs, + dtype=[("cost", "f8"), ("time", "i4")], ) dig = np.digitize(expenses["time"], self.month_bins) @@ -1077,7 +1104,8 @@ def monthly_opex(self): @property def monthly_revenue(self): """Returns the monthly revenue based on when array system strings can - be energized, eg. 'self.progress.energize_points'.""" + be energized, eg. 'self.progress.energize_points'. + """ ncf = self.project_params.get("ncf", 0.4) price = self.project_params.get("offtake_price", 80) @@ -1100,7 +1128,8 @@ def monthly_revenue(self): @property def cash_flow(self): """Returns the net cash flow based on `self.monthly_expenses` and - `self.monthly_revenue`.""" + `self.monthly_revenue`. + """ try: revenue = self.monthly_revenue @@ -1117,7 +1146,8 @@ def cash_flow(self): @property def npv(self): """Returns the net present value of the project based on - `self.cash_flow`.""" + `self.cash_flow`. + """ dr = self.project_params.get("discount_rate", 0.025) pr = (1 + dr) ** (1 / 12) - 1 @@ -1140,9 +1170,9 @@ def _filter_logs(self, keys): """Returns filtered list of logs.""" filtered = [] - for l in self.logs: + for log in self.logs: try: - filtered.append(tuple(l[k] for k in keys)) + filtered.append(tuple(log[k] for k in keys)) except KeyError: pass @@ -1172,8 +1202,8 @@ def progress_summary(self): def actions(self): """Returns list of all actions in the project.""" - actions = [l for l in self.logs if l["level"] == "ACTION"] - return sorted(actions, key=lambda l: l["time"]) + actions = [log for log in self.logs if log["level"] == "ACTION"] + return sorted(actions, key=lambda x: x["time"]) @staticmethod def create_input_xlsx(): @@ -1185,9 +1215,7 @@ def create_input_xlsx(): @property def phase_dates(self): - """ - Returns a combination of input start dates and `self.phase_times`. - """ + """Returns a combination of phase start dates and timing.""" if not isinstance(self.config["install_phases"], dict): print("Project was not configured with start dates.") @@ -1201,7 +1229,9 @@ def phase_dates(self): start = dt.datetime.strptime(_start, self.date_format_short) except TypeError: - start = self.start_date + dt.timedelta(hours=self.phase_starts[phase]) + start = self.start_date + dt.timedelta( + hours=self.phase_starts[phase] + ) end = start + dt.timedelta(hours=self.phase_times[phase]) @@ -1253,9 +1283,7 @@ def _diff_dates_long(self, a, b): @property def overnight_capex_per_kw(self): - """ - Returns overnight CAPEX/kW. - """ + """Returns overnight CAPEX/kW.""" try: capex = self.overnight_capex / (self.capacity * 1000) @@ -1316,7 +1344,7 @@ def capex_breakdown(self): categories[phase] = cat break - missing = [p for p in unique if p not in categories.keys()] + missing = list(set(unique).difference([*categories])) if missing: print( f"Warning: CapEx category not found for {missing}. " @@ -1329,7 +1357,7 @@ def capex_breakdown(self): outputs = {} for phase, cost in self.system_costs.items(): name = categories[phase] - if name in outputs.keys(): + if name in outputs: outputs[name] += cost else: @@ -1337,7 +1365,7 @@ def capex_breakdown(self): for phase, cost in self.installation_costs.items(): name = categories[phase] + " Installation" - if name in outputs.keys(): + if name in outputs: outputs[name] += cost else: @@ -1385,12 +1413,12 @@ def turbine_capex(self): num_turbines = self.config["plant"]["num_turbines"] rating = self.config["turbine"]["turbine_rating"] - except KeyError: + except KeyError as exc: raise KeyError( - f"Total turbine CAPEX can't be calculated. Required " - f"parameters 'plant.num_turbines' or 'turbine.turbine_rating' " - f"not found." - ) + "Total turbine CAPEX can't be calculated. Required " + "parameters 'plant.num_turbines' or 'turbine.turbine_rating' " + "not found." + ) from exc capex = _capex * num_turbines * rating * 1000 return capex @@ -1434,7 +1462,13 @@ def soft_capex_per_kw(self): decommissioning = self.project_params.get("decommissioning", 58) return sum( - [insurance, financing, contingency, commissioning, decommissioning] + [ + insurance, + financing, + contingency, + commissioning, + decommissioning, + ], ) @property @@ -1524,9 +1558,9 @@ def export_project_logs(self, filepath, level="ACTION"): Default: 'ACTION' """ - dirs = os.path.split(filepath)[0] - if dirs and not os.path.isdir(dirs): - os.makedirs(dirs) + dirs = Path(filepath).parent + if dirs and not dirs.is_dir(): + dirs.mkdir(parents=True) if level == "ACTION": out = pd.DataFrame(self.actions) @@ -1591,7 +1625,7 @@ def complete_array_strings(self): data = list(zip(strings, subs, turbines)) - return [max(l) for l in data], num_turbines + return [max(el) for el in data], num_turbines @property def energize_points(self): @@ -1605,13 +1639,12 @@ def energize_points(self): points = [] times, turbines = self.complete_array_strings - for t in times: - points.append(max([t, export])) + points = [max(t, export) for t in times] return points, turbines def parse_logs(self, k): - """Parse `self.data` for specific progress points associated key `k`""" + """Parse `self.data` for specific progress points for key ``k``.""" pts = [p[1] for p in self.data if p[0] == k] if not pts: @@ -1620,15 +1653,15 @@ def parse_logs(self, k): return pts @staticmethod - def chunk_max(l, n): - """Yield max value of successive n-sized chunks from l.""" + def chunk_max(x, n): + """Yield max value of successive n-sized chunks from x.""" - for i in range(0, len(l), n): - yield max(l[i : i + n]) + for i in range(0, len(x), n): + yield max(x[i : i + n]) @staticmethod - def chunk_len(l, n): - """Yield successive n-sized chunks from l.""" + def chunk_len(x, n): + """Yield successive n-sized chunks from x.""" - for i in range(0, len(l), n): - yield len(l[i : i + n]) + for i in range(0, len(x), n): + yield len(x[i : i + n]) diff --git a/ORBIT/parametric.py b/ORBIT/parametric.py index 6895400c..052c8eeb 100644 --- a/ORBIT/parametric.py +++ b/ORBIT/parametric.py @@ -1,3 +1,5 @@ +"""Provides the ParametricManager class for a parameter sweeps.""" + __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" @@ -10,11 +12,9 @@ from random import sample from itertools import product -import yaml import numpy as np import pandas as pd import statsmodels.api as sm -from yaml import Loader from benedict import benedict from ORBIT import ProjectManager @@ -31,7 +31,7 @@ def __init__( weather=None, module=None, product=False, - keep_inputs=[], + keep_inputs=None, ): """ Creates an instance of `ParametricRun`. @@ -57,11 +57,12 @@ def __init__( self.results = None self.module = module self.product = product - self.keep = keep_inputs + self.keep = keep_inputs if keep_inputs is not None else [] def run(self, **kwargs): """Run the configured parametric runs and save any requested results to - `self.results`.""" + `self.results`. + """ outputs = [] for run in self.run_list: @@ -123,6 +124,7 @@ def run_list(self): @property def num_runs(self): + """Calculates the number of runs completed.""" return len(self.run_list) @staticmethod @@ -143,14 +145,14 @@ def map_funcs(obj, funcs): try: res = f(obj) - except TypeError: + except TypeError as exc: raise TypeError( f"Result function '{f}' not structured properly. " f"Correct format: 'lambda project: project.{f}'" - ) + ) from exc except AttributeError: - res = np.NaN + res = np.nan results[k] = res @@ -187,7 +189,7 @@ def preview(self, num=10, **kwargs): return pd.DataFrame(outputs) def create_model(self, x, y): - """""" + """Creates a ``LinearModel`` for the inputs and results.""" if self.results is None: print("`ParametricManager hasn't been ran yet.") @@ -196,7 +198,10 @@ def create_model(self, x, y): @classmethod def from_config(cls, data): - """""" + """ + Creates a ``ParametricManager`` isntance from a configuration + dictionary, ``data``. + """ outputs = data.pop("outputs", {}) @@ -350,7 +355,7 @@ def perc_diff(self): pd.Series """ - inputs = dict(zip(self.X.T.index, self.X.T.values)) + inputs = dict(zip(self.X.T.index, self.X.T.to_numpy())) predicted = self.predict(inputs) return (self.Y - predicted) / self.Y diff --git a/ORBIT/phases/__init__.py b/ORBIT/phases/__init__.py index 5047a09d..e03cbe6b 100644 --- a/ORBIT/phases/__init__.py +++ b/ORBIT/phases/__init__.py @@ -1,5 +1,6 @@ """ -The phases package contains `DesignPhase`, `InstallPhase` and any subclasses. +Provides `DesignPhase`, `InstallPhase` and their component-specific +implementations. """ __author__ = ["Jake Nunemaker", "Rob Hammond"] diff --git a/ORBIT/phases/base.py b/ORBIT/phases/base.py index 2e9b539d..3e73b951 100644 --- a/ORBIT/phases/base.py +++ b/ORBIT/phases/base.py @@ -46,9 +46,7 @@ def initialize_library(self, config, **kwargs): return extract_library_data(config) def extract_phase_kwargs(self, **kwargs): - """ - Consistent handling of kwargs for Phase and subclasses. - """ + """Consistent handling of kwargs for Phase and subclasses.""" phase_name = kwargs.get("phase_name", None) if phase_name is not None: diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py index e6db2abd..11c0edcc 100644 --- a/ORBIT/phases/design/SemiTaut_mooring_system_design.py +++ b/ORBIT/phases/design/SemiTaut_mooring_system_design.py @@ -5,8 +5,8 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov & rebecca.fuchs@nrel.gov" -from scipy.interpolate import interp1d import numpy as np +from scipy.interpolate import interp1d from ORBIT.phases.design import DesignPhase @@ -29,14 +29,14 @@ class SemiTautMooringSystemDesign(DesignPhase): output_config = { "mooring_system": { "num_lines": "int", - #"line_diam": "m, float", # this is not needed for mooring.py - "line_mass": "t", # you need this for mooring.py (mooring installation module) - "line_cost": "USD", # you can calculate this based on each rope&chain length & diameter. - "line_length": "m", # this can be calculated from rope length and chain length (which you get from an empirical eqn as function of depth) - "anchor_mass": "t", # you need this for mooring.py (mooring installation module) - "anchor_type": "str", # keep, changed default to drag embedment. - "anchor_cost": "USD", # this can be calculated also as a function of (depth?) from the empirical data you have. - } + # "line_diam": "m, float", # this is not needed for mooring.py + "line_mass": "t", # you need this for mooring.py (mooring installation module) + "line_cost": "USD", # you can calculate this based on each rope&chain length & diameter. + "line_length": "m", # this can be calculated from rope length and chain length (which you get from an empirical eqn as function of depth) + "anchor_mass": "t", # you need this for mooring.py (mooring installation module) + "anchor_type": "str", # keep, changed default to drag embedment. + "anchor_cost": "USD", # this can be calculated also as a function of (depth?) from the empirical data you have. + }, } def __init__(self, config, **kwargs): @@ -59,9 +59,7 @@ def __init__(self, config, **kwargs): self._outputs = {} def run(self): - """ - Main run function. - """ + """Main run function.""" self.calculate_line_length_mass() self.determine_mooring_line_cost() @@ -70,16 +68,19 @@ def run(self): self._outputs["mooring_system"] = {**self.design_result} def calculate_line_length_mass(self): - """ - Returns the mooring line length and mass. - """ + """Returns the mooring line length and mass.""" depth = self.config["site"]["depth"] - # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California + # Input hybrid mooring system design from Cooperman et al. (2022), + # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore + # Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy + # Areas, California depths = np.array([500, 750, 1000, 1250, 1500]) rope_lengths = np.array([478.41, 830.34, 1229.98, 1183.93, 1079.62]) - rope_diameters = np.array([0.2, 0.2, 0.2, 0.2, 0.2]) # you need the diameter for the cost data + rope_diameters = np.array( + [0.2, 0.2, 0.2, 0.2, 0.2] + ) # you need the diameter for the cost data chain_lengths = np.array([917.11, 800.36, 609.07, 896.42, 1280.57]) chain_diameters = np.array([0.13, 0.17, 0.22, 0.22, 0.22]) @@ -98,12 +99,18 @@ def calculate_line_length_mass(self): self.line_length = self.rope_length + self.chain_length - chain_kg_per_m = 19900 * (self.chain_diameter**2) # 19,900 kg/m^2 (diameter)/m (length) - rope_kg_per_m = 797.8 * (self.rope_diameter**2) # 797.8 kg/ m^2 (diameter) / m (length) - self.line_mass = (self.chain_length * chain_kg_per_m) + (self.rope_length * rope_kg_per_m) # kg - #print('total hybrid line mass is ' + str(self.line_mass) + 'kg') + chain_kg_per_m = 19900 * ( + self.chain_diameter**2 + ) # 19,900 kg/m^2 (diameter)/m (length) + rope_kg_per_m = 797.8 * ( + self.rope_diameter**2 + ) # 797.8 kg/ m^2 (diameter) / m (length) + self.line_mass = (self.chain_length * chain_kg_per_m) + ( + self.rope_length * rope_kg_per_m + ) # kg + # print('total hybrid line mass is ' + str(self.line_mass) + 'kg') # convert kg to metric tonnes - self.line_mass = self.line_mass/1e3 + self.line_mass = self.line_mass / 1e3 def calculate_anchor_mass_cost(self): """ @@ -114,21 +121,36 @@ def calculate_anchor_mass_cost(self): """ if self.anchor_type == "Drag Embedment": - self.anchor_mass = 20 # t. This should be updated, but I don't have updated data right now for this. - # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California + + # TODO: Update this when data is available + self.anchor_mass = 20 # t + + # Input hybrid mooring system design from Cooperman et al. (2022), + # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of + # Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay + # Wind Energy Areas, California depths = np.array([500, 750, 1000, 1250, 1500]) - anchor_costs = np.array([112766, 125511, 148703, 204988, 246655]) # [USD] + anchor_costs = np.array( + [112766, 125511, 148703, 204988, 246655] + ) # [USD] # interpolate anchor cost to project depth depth = self.config["site"]["depth"] finterp_anchor_cost = interp1d(depths, anchor_costs) - self.anchor_cost = finterp_anchor_cost(depth) # replace this with interp. function based on depth of hybrid mooring line + self.anchor_cost = finterp_anchor_cost( + depth + ) # TODO: replace with interp. function based on depth of hybrid mooring line # noqa: E501 def determine_mooring_line_cost(self): """Returns cost of one line mooring line.""" - # Input hybrid mooring system design from Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy Areas, California - depths = np.array([500, 750, 1000, 1250, 1500]) # [m] - total_line_costs = np.array([826598, 1221471, 1682208, 2380035, 3229700]) # [USD] + # Input hybrid mooring system design from Cooperman et al. (2022), + # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore + # Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy + # Areas, California + depths = np.array([500, 750, 1000, 1250, 1500]) # [m] + total_line_costs = np.array( + [826598, 1221471, 1682208, 2380035, 3229700] + ) # [USD] finterp_total_line_cost = interp1d(depths, total_line_costs) depth = self.config["site"]["depth"] self.line_cost = finterp_total_line_cost(depth) @@ -150,7 +172,7 @@ def detailed_output(self): return { "num_lines": self.num_lines, - #"line_diam": self.line_diam, + # "line_diam": self.line_diam, "line_mass": self.line_mass, "line_length": self.line_length, "line_cost": self.line_cost, diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index d767c745..3b5be8ed 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -11,15 +11,16 @@ import numpy as np from scipy.optimize import fsolve + from ORBIT.core.library import extract_library_specs from ORBIT.phases.design import DesignPhase class Cable: - """ - Base cable class + r""" + Base cable class. - Attributes + Parameters ---------- conductor_size : float Cable cross section in :math:`mm^2`. @@ -61,10 +62,10 @@ class Cable: def __init__(self, cable_specs, **kwargs): """ - Create an instance of Cable (either array or export) + Create an instance of Cable (either array or export). Parameters - --------- + ---------- cable_specs : dict Dictionary containing cable specifications. kwargs : dict @@ -94,9 +95,7 @@ def __init__(self, cable_specs, **kwargs): self.calc_cable_power() def calc_char_impedance(self): - """ - Calculate characteristic impedance of cable. - """ + """Calculate characteristic impedance of cable.""" if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: self.char_impedance = 0 else: @@ -113,9 +112,7 @@ def calc_char_impedance(self): self.char_impedance = np.sqrt(num / den) def calc_power_factor(self): - """ - Calculate power factor. - """ + """Calculate power factor.""" if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: self.power_factor = 0 @@ -127,7 +124,8 @@ def calc_power_factor(self): def calc_cable_power(self): """ - Calculate maximum power transfer through 3-phase cable in :math:`MW`. + Calculates the maximum power transfer through a 3-phase cable, + in :math:`MW`. """ if self.cable_type in ["HVDC-monopole", "HVDC-bipole"]: @@ -144,9 +142,7 @@ def calc_cable_power(self): ) def calc_compensation_factor(self): - """ - Calculate compensation factor for shunt reactor cost - """ + """Calculates the compensation factor for the shunt reactor cost.""" capacitive_reactance = 1 / ( 2 * np.pi * self.line_frequency * (self.capacitance / 10e8) ) @@ -247,7 +243,8 @@ def _initialize_distances(self, config): ) self.substation_distance = config["plant"].get( - "substation_distance", None + "substation_distance", + None, ) if self.substation_distance is None: self.substation_distance = self.turbine_distance @@ -309,7 +306,8 @@ def __init__(self, config, cable_type, **kwargs): def _initialize_cables(self): """ - Creates the base cable objects for each type of array cable being used. + Creates the base cable objects for each type of array cable being + modeled. """ if isinstance(self._design["cables"], str): @@ -346,8 +344,8 @@ def _get_touchdown_distance(self): Returns the cable touchdown distance measured from the centerpoint of the substructure. - If depth <= 60, default is 0km (straight down assumed for fixed bottom). - If depth > 60, default is 0.3 * depth. + If depth <= 60, default is 0km (straight down assumed for fixed + bottom). If depth > 60, default is 0.3 * depth. """ _design = f"{self.cable_type}_system_design" @@ -363,7 +361,8 @@ def _get_touchdown_distance(self): else: self.touchdown = depth * 0.3 - # TODO: Update this scaling function - should be closer to cable bend radius. Unrealistic for deep water + # TODO: Update this scaling function - should be closer to + # cable bend radius. Unrealistic for deep water @staticmethod def _catenary(a, *data): @@ -391,7 +390,8 @@ def _get_catenary_length(self, d, h): if not np.isclose(y[-1], d): print( - "Warning: Catenary calculation failed. Reverting to simple vertical profile." + "Warning: Catenary calculation failed. Reverting to simple" + " vertical profile." ) return d @@ -399,13 +399,13 @@ def _get_catenary_length(self, d, h): @property def free_cable_length(self): - """Returns the length of the vertical portion of a cable section in km.""" + """Returns the vertical length of a cable section, in :mat:`km`.""" _design = f"{self.cable_type}_system_design" depth = self.config["site"]["depth"] _cable_depth = self.config[_design].get("floating_cable_depth", depth) - # Select prescribed cable depth if it is less than or equal to overall water dpeth + # Select prescribed cable depth if it is <= overall water dpeth if _cable_depth > depth: cable_depth = depth else: @@ -419,7 +419,7 @@ def free_cable_length(self): @property def cable_lengths_by_type(self): """ - Creates dictionary of lists of cable sections for each type of cable + Creates dictionary of lists of cable sections for each type of cable. Returns ------- diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 0e3f0571..43210d59 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -64,7 +64,7 @@ class ArraySystemDesign(CableSystem): sections_cables : np.ndarray, [`num_strings`, `num_turbines_full_string`] The type of cable being used to connect turbines in a string. All values are either ``None`` or `Cable.name`. - """ + """ # noqa: E501 expected_config = { "site": {"depth": "m"}, @@ -131,7 +131,7 @@ def detailed_output(self): "array_system_length_by_type": self.total_cable_length_by_type, "array_system_total_cost": self.total_cable_cost, "array_system_cost_by_type": self.cost_by_type, - "array_system_num_turbines_full_string": self.num_turbines_full_string, + "array_system_num_turbines_full_string": self.num_turbines_full_string, # noqa: E501 "array_system_num_full_strings": self.num_full_strings, } @@ -147,7 +147,7 @@ def _compute_euclidean_distance(self): string for all strings in the windfarm. """ differnce = np.abs(np.diff(self.coordinates, n=1, axis=1)) - distance = np.round_(np.linalg.norm(differnce, axis=2), 10) + distance = np.round(np.linalg.norm(differnce, axis=2), 10) return distance def _compute_maximum_turbines_per_cable(self): @@ -220,7 +220,8 @@ def create_strings(self): ) self.num_turbines_full_string = len(self.full_string) self.num_full_strings, self.num_turbines_partial_string = np.divmod( - self.system.num_turbines, self.num_turbines_full_string + self.system.num_turbines, + self.num_turbines_full_string, ) # Create a partial string constrained by the remainder @@ -234,9 +235,7 @@ def create_strings(self): self.num_strings = self.num_full_strings + self.num_partial_strings def _design_grid_layout(self): - """ - Makes the coordinates of a default grid layout. - """ + """Makes the coordinates of a default grid layout.""" # Create the relative (x, y) coordinate matrices for the turbines # using vector math @@ -244,9 +243,11 @@ def _design_grid_layout(self): # X = column vector of turbine distance # * row vector of range(1, num_turbines_full_string + 1) self.turbines_x = np.full( - self.num_strings, self.system.turbine_distance + self.num_strings, + self.system.turbine_distance, ).reshape(-1, 1) * np.add( - np.arange(self.num_turbines_full_string, dtype=float), 1 + np.arange(self.num_turbines_full_string, dtype=float), + 1, ) # Y = column vector of reverse range(1, num_strings) @@ -254,7 +255,8 @@ def _design_grid_layout(self): self.turbines_y = np.arange(self.num_strings, dtype=float)[ ::-1 ].reshape(-1, 1) * np.full( - (1, self.num_turbines_full_string), self.system.row_distance + (1, self.num_turbines_full_string), + self.system.row_distance, ) # If there are partial strings the default layout then null out @@ -268,9 +270,7 @@ def _design_grid_layout(self): self.oss_y = self.turbines_y[:, 0].mean() def _design_ring_layout(self): - """ - Creates the coordinates of a default ring layout. - """ + """Creates the coordinates of a default ring layout.""" # Calculate the radius of each turbine from the OSS radius = ( @@ -352,12 +352,10 @@ def _create_cable_section_lengths(self): i, 0 : self.num_turbines_full_string - ix ] = self.full_string[::-1][: self.num_turbines_full_string - ix][ ::-1 - ] + ] # noqa: E501 def run(self): - """ - Runs all the functions to create an array sytem. - """ + """Runs all the functions to create an array sytem.""" self._initialize_cables() self.create_strings() @@ -378,7 +376,8 @@ def save_layout(self, save_name, return_df=False, folder="cables"): 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. + if "plant", then the layout will be saved to the "project/plant" + folder. Returns ------- @@ -456,9 +455,9 @@ 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.values.tolist() + data = [columns] + layout_df.to_numpy().tolist() print( - f"Saving custom array CSV to: /cables/{save_name}.csv" + f"Saving custom array CSV to: /cables/{save_name}.csv" # noqa: E501 ) export_library_specs(folder, save_name, data, file_ext="csv") if return_df: @@ -511,7 +510,10 @@ def _plot_oss(self, ax): return labels_set + ["Turbine"], ax def plot_array_system( - self, show=True, save_path_name=None, return_fig=False + self, + show=True, + save_path_name=None, + return_fig=False, ): """ Plot the array cabling system. @@ -559,7 +561,11 @@ def plot_array_system( # 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"].values[0] + # 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 @@ -738,7 +744,7 @@ def __init__(self, config, distance=False, **kwargs): self.distance = config["array_system_design"].get("distance", distance) def create_project_csv(self, save_name, folder="cables"): - """Creates a base CSV in <`library_path`>/cables/ + """Creates a base CSV in <`library_path`>/cables/. Parameters ---------- @@ -808,9 +814,7 @@ def create_project_csv(self, save_name, folder="cables"): ] rows.insert(0, first) rows.insert(0, self.COLUMNS) - print( - f"Saving custom array CSV to: /cables/{save_name}.csv" - ) + print(f"Saving custom array to: /cables/{save_name}.csv") export_library_specs(folder, save_name, rows, file_ext="csv") def _format_windfarm_data(self): @@ -820,43 +824,42 @@ def _format_windfarm_data(self): self.location_data.substation_id == self.location_data.id ) oss = self.location_data[substation_filter].copy() - oss.rename( + oss = oss.rename( columns={ "latitude": "substation_latitude", "longitude": "substation_longitude", "name": "substation_name", }, - inplace=True, ) oss.substation_id = oss["id"] - oss.drop( + oss = oss.drop( ["id", "string", "order", "cable_length", "bury_speed"], - inplace=True, axis=1, ) # Separate the turbine data turbines = self.location_data[~substation_filter].copy() - turbines.rename( + turbines = turbines.rename( columns={ "latitude": "turbine_latitude", "longitude": "turbine_longitude", "name": "turbine_name", }, - inplace=True, ) # Merge them back together self.location_data = turbines.merge( - oss, on="substation_id", how="left" + oss, + on="substation_id", + how="left", ) self.location_data = self.location_data[self.REQUIRED + self.OPTIONAL] self.location_data.string = self.location_data.string.astype(int) self.location_data.order = self.location_data.order.astype(int) - self.location_data.sort_values( - by=["substation_id", "string", "order"], inplace=True + self.location_data = self.location_data.sort_values( + by=["substation_id", "string", "order"], ) def _initialize_custom_data(self): @@ -864,18 +867,22 @@ def _initialize_custom_data(self): try: self.location_data = extract_library_specs( - "cables", windfarm, file_type="csv" + "cables", + windfarm, + file_type="csv", ) except LibraryItemNotFoundError: self.location_data = extract_library_specs( - "plant", windfarm, file_type="csv" + "plant", + windfarm, + file_type="csv", ) # Make sure no data is missing missing = set(self.COLUMNS).difference(self.location_data.columns) if missing: raise ValueError( "The following columns must be included in the location " - f"data: {missing}" + f"data: {missing}", ) self._format_windfarm_data() @@ -884,7 +891,7 @@ def _initialize_custom_data(self): missing_data_cols = [ c for c in self.REQUIRED - if pd.isnull(self.location_data[c]).sum() > 0 + if pd.isna(self.location_data[c]).sum() > 0 ] if missing_data_cols: raise ValueError(f"Missing data in columns: {missing_data_cols}!") @@ -894,7 +901,7 @@ def _initialize_custom_data(self): c for c in self.OPTIONAL if ( - pd.isnull(self.location_data[c]) | self.location_data[c] == 0 + pd.isna(self.location_data[c]) | self.location_data[c] == 0 ).sum() > 0 ] @@ -903,7 +910,7 @@ def _initialize_custom_data(self): f"Missing data in columns {missing_data_cols}; " "all values will be calculated." ) - warnings.warn(message) + warnings.warn(message, stacklevel=2) # Ensure the number of turbines matches what's expected if self.location_data.shape[0] != self.system.num_turbines: @@ -944,12 +951,14 @@ def _check_optional_input(self): """ if np.any(self.sections_cable_lengths == 0): self.sections_cable_lengths = np.zeros( - (self.num_strings, self.num_turbines_full_string), dtype=float + (self.num_strings, self.num_turbines_full_string), + dtype=float, ) if np.any(self.sections_bury_speeds == 0): self.sections_bury_speeds = np.zeros( - (self.num_strings, self.num_turbines_full_string), dtype=float + (self.num_strings, self.num_turbines_full_string), + dtype=float, ) def _compute_haversine_distance(self): @@ -995,16 +1004,20 @@ def _create_windfarm_layout(self): """ self.location_data_x = np.zeros( - (self.num_strings, self.num_turbines_full_string + 1), dtype=float + (self.num_strings, self.num_turbines_full_string + 1), + dtype=float, ) self.location_data_y = np.zeros( - (self.num_strings, self.num_turbines_full_string + 1), dtype=float + (self.num_strings, self.num_turbines_full_string + 1), + dtype=float, ) self.sections_cable_lengths = np.zeros( - (self.num_strings, self.num_turbines_full_string), dtype=float + (self.num_strings, self.num_turbines_full_string), + dtype=float, ) self.sections_bury_speeds = np.zeros( - (self.num_strings, self.num_turbines_full_string), dtype=float + (self.num_strings, self.num_turbines_full_string), + dtype=float, ) self.oss_x = [] @@ -1018,8 +1031,8 @@ def _create_windfarm_layout(self): string_id = np.sort(layout.string.unique()) string_id += 0 if i == 0 else i - x = layout.substation_longitude.values[0] - y = layout.substation_latitude.values[0] + x = layout.substation_longitude.to_numpy()[0] + y = layout.substation_latitude.to_numpy()[0] self.oss_x.append(x) self.oss_y.append(y) self.location_data_x[string_id, 0] = x @@ -1027,19 +1040,19 @@ def _create_windfarm_layout(self): for string in string_id: data = layout[layout.string == string - i] - order = data["order"].values - self.location_data_x[ - string, order + 1 - ] = data.turbine_longitude.values[order] - self.location_data_y[ - string, order + 1 - ] = data.turbine_latitude.values[order] - self.sections_cable_lengths[ - string, order - ] = data.cable_length.values[order] - self.sections_bury_speeds[ - string, order - ] = data.bury_speed.values[order] + order = data["order"].to_numpy() + self.location_data_x[string, order + 1] = ( + data.turbine_longitude.to_numpy()[order] + ) + self.location_data_y[string, order + 1] = ( + data.turbine_latitude.to_numpy()[order] + ) + self.sections_cable_lengths[string, order] = ( + data.cable_length.to_numpy()[order] + ) + self.sections_bury_speeds[string, order] = ( + data.bury_speed.to_numpy()[order] + ) i = string + 1 # Ensure any point in array without a turbine is set to None @@ -1062,6 +1075,7 @@ def _create_windfarm_layout(self): self.sections_distance = self._compute_haversine_distance() def run(self): + """Runs the design model.""" self._initialize_cables() self.create_strings() diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 0e44f83c..df0f7dcc 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -161,7 +161,7 @@ def run(self): "system_cost": self.total_cable_cost, } - for _, cable in self.cables.items(): + for cable in self.cables.values(): self._outputs["export_system"]["cable"] = { "linear_density": cable.linear_density, "sections": [self.length], @@ -233,9 +233,7 @@ def detailed_output(self): @property def design_result(self): - """ - Returns the results of self.run(). - """ + """Returns the results of self.run().""" return self._outputs # CABLES @@ -268,9 +266,7 @@ def compute_number_cables(self): self.num_cables = int(num_required + num_redundant) def compute_cable_length(self): - """ - Calculates the total distance an export cable must travel. - """ + """Calculates the total distance an export cable must travel.""" added_length = 1.0 + self._design.get("percent_added_length", 0.0) self.length = round( @@ -284,9 +280,7 @@ def compute_cable_length(self): ) def compute_cable_mass(self): - """ - Calculates the total mass of a single length of export cable. - """ + """Calculates the total mass of a single length of export cable.""" self.mass = round(self.length * self.cable.linear_density, 10) @@ -302,30 +296,30 @@ def compute_total_cable(self): @property def sections_cable_lengths(self): """ - Creates an array of section lengths to work with `CableSystem` + Creates an array of section lengths to work with ``CableSystem``. Returns ------- np.ndarray - Array of `length` with shape (`num_cables`, ). + Array of `length` with shape (``num_cables``, ). """ return np.full(self.num_cables, self.length) @property def sections_cables(self): """ - Creates an array of cable names to work with `CableSystem`. + Creates an array of cable names to work with ``CableSystem``. Returns ------- np.ndarray - Array of `cable.name` with shape (`num_cables`, ). + Array of ``cable.name`` with shape (``num_cables``, ). """ return np.full(self.num_cables, self.cable.name) def calc_crossing_cost(self): - """Compute cable crossing costs""" + """Compute cable crossing costs.""" self._crossing_design = self.config["export_system_design"].get( "cable_crossings", {} ) @@ -417,7 +411,7 @@ def calc_shunt_reactor_cost(self): if "HVDC" in self.cable.cable_type: self.compensation = 0 else: - for _, cable in self.cables.items(): + for cable in self.cables.values(): self.compensation = touchdown * cable.compensation_factor # MW self.shunt_reactor_cost = ( self.compensation * shunt_unit_cost * self.num_cables @@ -475,7 +469,7 @@ def calc_ancillary_system_cost(self): ) * self.num_substations def calc_converter_cost(self): - """Computes converter cost""" + """Computes converter cost.""" if self.cable.cable_type == "HVDC-monopole": self.converter_cost = self.num_substations * self._design.get( @@ -547,9 +541,7 @@ def calc_substructure_mass_and_cost(self): self.substructure_mass = substructure_mass + substructure_pile_mass def calc_substructure_length(self): - """ - Calculates substructure length as the site depth + 10m - """ + """Calculates substructure length as the site depth + 10m.""" if self.substructure_type == "Floating": self.substructure_length = 0 @@ -598,7 +590,7 @@ def calc_topside_mass_and_cost(self): self.topside_cost = _design.get("topside_design_cost", 107.3e6) def calc_onshore_cost(self): - """Minimum Cost of Onshore Substation Connection + """Minimum Cost of Onshore Substation Connection. Parameters ---------- diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index a5ba8180..4ad674b1 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -103,9 +103,7 @@ def __init__(self, config, **kwargs): ) def run(self): - """ - Instantiates the export cable system and runs all the required methods. - """ + """Runs the design model.""" self._initialize_cables() self.cable = self.cables[[*self.cables][0]] @@ -146,9 +144,7 @@ def compute_number_cables(self): self.num_cables = int(num_required + num_redundant) def compute_cable_length(self): - """ - Calculates the total distance an export cable must travel. - """ + """Calculates the total distance an export cable must travel.""" added_length = 1.0 + self._design.get("percent_added_length", 0.0) self.length = round( @@ -162,9 +158,7 @@ def compute_cable_length(self): ) def compute_cable_mass(self): - """ - Calculates the total mass of a single length of export cable. - """ + """Calculates the total mass of a single length of export cable.""" self.mass = round(self.length * self.cable.linear_density, 10) @@ -180,24 +174,24 @@ def compute_total_cable(self): @property def sections_cable_lengths(self): """ - Creates an array of section lengths to work with `CableSystem` + Creates an array of section lengths to work with ``CableSystem``. Returns ------- np.ndarray - Array of `length` with shape (`num_cables`, ). + Array of ``length`` with shape (``num_cables``, ). """ return np.full(self.num_cables, self.length) @property def sections_cables(self): """ - Creates an array of cable names to work with `CableSystem`. + Creates an array of cable names to work with ``CableSystem``. Returns ------- np.ndarray - Array of `cable.name` with shape (`num_cables`, ). + Array of `cable.name` with shape (``num_cables``, ). """ return np.full(self.num_cables, self.cable.name) @@ -231,7 +225,7 @@ def design_result(self): } } - for _, cable in self.cables.items(): + for cable in self.cables.values(): output["export_system"]["cable"] = { "linear_density": cable.linear_density, diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index 25473fff..8fb33d62 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -312,16 +312,14 @@ def monopile_steel_cost(self): try: cost = _design.get(_key, common_costs[_key]) - except KeyError: - raise Exception("Cost of monopile steel not found.") + except KeyError as exc: + raise Exception("Cost of monopile steel not found.") from exc return cost @property def tp_steel_cost(self): - """ - Returns the cost of transition piece steel (USD/t) fully fabricated. - """ + """Returns the cost of fabricated transition piece steel (USD/t).""" _design = self.config.get("monopile_design", {}) _key = "tp_steel_cost" @@ -329,8 +327,10 @@ def tp_steel_cost(self): try: cost = _design.get(_key, common_costs[_key]) - except KeyError: - raise Exception("Cost of transition piece steel not found.") + except KeyError as exc: + raise Exception( + "Cost of transition piece steel not found." + ) from exc # noqa: E501 return cost @@ -364,6 +364,7 @@ def pile_mass(Dp, tp, Lt, **kwargs): def pile_embedment_length(Ip, **kwargs): """ Calculates required pile embedment length. + Source: Arany & Bhattacharya (2016) - Equation 7 (Enforces a rigid/lower aspect ratio monopile) @@ -389,6 +390,7 @@ def pile_embedment_length(Ip, **kwargs): def pile_thickness(Dp): """ Calculates pile wall thickness. + Source: Arany & Bhattacharya (2016) - Equation 1 @@ -432,8 +434,9 @@ def pile_moment(Dp, tp): @staticmethod def pile_diam_equation(Dp, *data): """ - Equation to be solved for Pile Diameter. Combination of equations 99 & - 101 in this paper: + Equation to be solved for Pile Diameter. + + Combination of equations 99 & 101 in this paper: Source: Arany & Bhattacharya (2016) - Equations 99 & 101 @@ -465,7 +468,9 @@ def calculate_50year_wind_moment( ): """ Calculates the 50 year extreme wind moment using methodology from - DNV-GL. Source: Arany & Bhattacharya (2016) + DNV-GL. + + Source: Arany & Bhattacharya (2016) - Equation 30 Parameters @@ -505,10 +510,15 @@ def calculate_50year_wind_moment( return M_50y * load_factor def calculate_50year_wind_load( - self, mean_windspeed, rotor_diameter, rated_windspeed, **kwargs + self, + mean_windspeed, + rotor_diameter, + rated_windspeed, + **kwargs, ): """ Calculates the 50 year extreme wind load using methodology from DNV-GL. + Source: Arany & Bhattacharya (2016) - Equation 29 @@ -547,6 +557,7 @@ def calculate_50year_wind_load( def calculate_thrust_coefficient(rated_windspeed): """ Calculates the thrust coefficient using rated windspeed. + Source: Frohboese & Schmuck (2010) Parameters @@ -569,6 +580,7 @@ def calculate_50year_extreme_ws(mean_windspeed, **kwargs): """ Calculates the 50 year extreme wind speed using methodology from DNV-GL. + Source: Arany & Bhattacharya (2016) - Equation 27 @@ -594,10 +606,15 @@ def calculate_50year_extreme_ws(mean_windspeed, **kwargs): return U_50y def calculate_50year_extreme_gust( - self, mean_windspeed, rotor_diameter, rated_windspeed, **kwargs + self, + mean_windspeed, + rotor_diameter, + rated_windspeed, + **kwargs, ): """ Calculates the 50 year extreme wind gust using methodology from DNV-GL. + Source: Arany & Bhattacharya (2016) - Equation 28 diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index e14bb09c..7e703c99 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -89,9 +89,7 @@ def __init__(self, config, **kwargs): self._outputs = {} def run(self): - """ - Main run function. - """ + """Runs the design model.""" self.determine_mooring_line() self.calculate_breaking_load() @@ -132,9 +130,7 @@ def determine_mooring_line(self): ) def calculate_breaking_load(self): - """ - Returns the mooring line breaking load. - """ + """Returns the mooring line breaking load.""" self.breaking_load = ( 419449 * (self.line_diam**2) + 93415 * self.line_diam - 3577.9 @@ -146,6 +142,7 @@ def calculate_line_length_mass(self): SemiTaut model based on: https://github.com/NREL/MoorPy/blob/dev/moorpy/MoorProps_default.yaml + TODO: Improve TLP line length and mass """ diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index 37f55ee4..1c276550 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -110,9 +110,7 @@ def total_cost(self): ) * self.num_substations def calc_substructure_length(self): - """ - Calculates substructure length as the site depth + 10m - """ + """Calculates substructure length as the site depth + 10m.""" self.substructure_length = self.config["site"]["depth"] + 10 @@ -295,9 +293,7 @@ def calc_substructure_mass_and_cost(self): @property def design_result(self): - """ - Returns the results of self.run(). - """ + """Returns the results of self.run().""" if not self._outputs: raise Exception("Has OffshoreSubstationDesign been ran yet?") diff --git a/ORBIT/phases/design/oss_design_floating.py b/ORBIT/phases/design/oss_design_floating.py index a1f384d3..77d984b3 100644 --- a/ORBIT/phases/design/oss_design_floating.py +++ b/ORBIT/phases/design/oss_design_floating.py @@ -37,7 +37,7 @@ class OffshoreFloatingSubstationDesign(DesignPhase): output_config = { "num_substations": "int", "offshore_substation_topside": "dict", - #"offshore_substation_substructure", "dict", + # "offshore_substation_substructure", "dict", } def __init__(self, config, **kwargs): @@ -110,9 +110,7 @@ def total_cost(self): ) * self.num_substations def calc_substructure_length(self): - """ - Calculates substructure length as the site depth + 10m - """ + """Calculates substructure length as the site depth + 10m.""" self.substructure_length = self.config["site"]["depth"] + 10 @@ -136,7 +134,8 @@ def calc_topside_deck_space(self): def calc_num_mpt_and_rating(self): """ - Calculates the number of main power transformers (MPTs) and their rating. + Calculates the number of main power transformers (MPTs) and their + rating. Parameters ---------- @@ -284,20 +283,18 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) substructure_mass = 0.4 * self.topside_mass - #substructure_pile_mass = 8 * substructure_mass ** 0.5574 - substructure_pile_mass = 0 # the monopiles are no longer needed because there is s mooring system + # substructure_pile_mass = 8 * substructure_mass ** 0.5574 + substructure_pile_mass = 0 # moorings don't use piles self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate ) - #print('substructure cost:' + str(self.substructure_cost)) + # print('substructure cost:' + str(self.substructure_cost)) self.substructure_mass = substructure_mass + substructure_pile_mass @property def design_result(self): - """ - Returns the results of self.run(). - """ + """Returns the results of self.run().""" if not self._outputs: raise Exception("Has OffshoreSubstationDesign been ran yet?") diff --git a/ORBIT/phases/design/scour_protection_design.py b/ORBIT/phases/design/scour_protection_design.py index efa66b4f..cb07fa45 100644 --- a/ORBIT/phases/design/scour_protection_design.py +++ b/ORBIT/phases/design/scour_protection_design.py @@ -1,4 +1,4 @@ -"""Provides the `ScourProtectionDesign` class""" +"""Provides the `ScourProtectionDesign` class.""" __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -14,7 +14,8 @@ class ScourProtectionDesign(DesignPhase): """ - Calculates the necessary scour protection material for a fixed substructure. + Calculates the necessary scour protection material for a fixed + substructure. Parameters ---------- @@ -65,7 +66,7 @@ class ScourProtectionDesign(DesignPhase): "scour_protection": { "tonnes_per_substructure": "t", "cost_per_tonne": "USD/t", - } + }, } def __init__(self, config, **kwargs): @@ -90,7 +91,7 @@ def __init__(self, config, **kwargs): self.protection_depth = self._design.get("scour_protection_depth", 1) def compute_scour_protection_tonnes_to_install(self): - """ + r""" Computes the amount of scour protection material that needs to be installed around a fixed substructure. @@ -105,17 +106,17 @@ def compute_scour_protection_tonnes_to_install(self): References ---------- - .. [1] Det Norske Veritas AS. (2014, May). Design of Offshore Wind Turbine - Structures. Retrieved from + .. [1] Det Norske Veritas AS. (2014, May). Design of Offshore Wind + Turbine Structures. Retrieved from https://rules.dnvgl.com/docs/pdf/DNV/codes/docs/2014-05/Os-J101.pdf - """ + """ # noqa: E501 self.scour_depth = self.equilibrium * self.diameter r = self.diameter / 2 + self.scour_depth / np.tan(np.radians(self.phi)) volume = ( - np.pi * self.protection_depth * (r ** 2 - (self.diameter / 2) ** 2) + np.pi * self.protection_depth * (r**2 - (self.diameter / 2) ** 2) ) self.scour_protection_tonnes = ceil( @@ -123,15 +124,13 @@ def compute_scour_protection_tonnes_to_install(self): ) def run(self): - """ - Runs the required methods to be able to produce a `design_result`. - """ + """Runs the design model.""" self.compute_scour_protection_tonnes_to_install() @property def total_cost(self): - """Returns the total cost of the phase in $USD""" + """Returns the total cost of the phase in $USD.""" cost = ( self._design["cost_per_tonne"] diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index 58404a29..23f0fd0c 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -10,7 +10,7 @@ class SemiSubmersibleDesign(DesignPhase): - """Semi-Submersible Substructure Design""" + """Semi-Submersible Substructure Design.""" expected_config = { "site": {"depth": "m"}, @@ -30,7 +30,7 @@ class SemiSubmersibleDesign(DesignPhase): "mass": "t", "unit_cost": "USD", "towing_speed": "km/h", - } + }, } def __init__(self, config, **kwargs): @@ -67,7 +67,7 @@ def stiffened_column_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.9581 * rating ** 2 + 40.89 * rating + 802.09 + mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 return mass @@ -89,7 +89,7 @@ def truss_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = 2.7894 * rating ** 2 + 15.591 * rating + 266.03 + mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 return mass @@ -106,12 +106,12 @@ def truss_cost(self): @property def heave_plate_mass(self): """ - Calculates the heave plate mass for a single semi-submersible in tonnes. - From original OffshoreBOS model. + Calculates the heave plate mass for a single semi-submersible in + tonnes. Source: original OffshoreBOS model. """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.4397 * rating ** 2 + 21.545 * rating + 177.42 + mass = -0.4397 * rating**2 + 21.545 * rating + 177.42 return mass @@ -133,7 +133,7 @@ def secondary_steel_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.153 * rating ** 2 + 6.54 * rating + 128.34 + mass = -0.153 * rating**2 + 6.54 * rating + 128.34 return mass @@ -178,7 +178,7 @@ def total_substructure_mass(self): @property def design_result(self): - """Returns the result of `self.run()`""" + """Returns the result of `self.run()`.""" if not self._outputs: raise Exception("Has `SemiSubmersibleDesign` been ran yet?") diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index 224c4a5e..151e12b3 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -12,7 +12,7 @@ class SparDesign(DesignPhase): - """Spar Substructure Design""" + """Spar Substructure Design.""" expected_config = { "site": {"depth": "m"}, @@ -33,7 +33,7 @@ class SparDesign(DesignPhase): "ballasted_mass": "t", "unit_cost": "USD", "towing_speed": "km/h", - } + }, } def __init__(self, config, **kwargs): @@ -66,20 +66,22 @@ def run(self): @property def stiffened_column_mass(self): """ - Calculates the mass of the stiffened column for a single spar in tonnes. From original OffshoreBOS model. + Calculates the mass of the stiffened column for a single spar in + tonnes. Source: original OffshoreBOS model. """ rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) return mass @property def tapered_column_mass(self): """ - Calculates the mass of the atpered column for a single spar in tonnes. From original OffshoreBOS model. + Calculates the mass of the atpered column for a single spar in tonnes. + Source: original OffshoreBOS model. """ rating = self.config["turbine"]["turbine_rating"] @@ -91,7 +93,8 @@ def tapered_column_mass(self): @property def stiffened_column_cost(self): """ - Calculates the cost of the stiffened column for a single spar. From original OffshoreBOS model. + Calculates the cost of the stiffened column for a single spar. + Source: original OffshoreBOS model. """ cr = self._design.get("stiffened_column_CR", 3120) @@ -100,7 +103,8 @@ def stiffened_column_cost(self): @property def tapered_column_cost(self): """ - Calculates the cost of the tapered column for a single spar. From original OffshoreBOS model. + Calculates the cost of the tapered column for a single spar. + Source: original OffshoreBOS model. """ cr = self._design.get("tapered_column_CR", 4220) @@ -109,18 +113,20 @@ def tapered_column_cost(self): @property def ballast_mass(self): """ - Calculates the ballast mass of a single spar. From original OffshoreBOS model. + Calculates the ballast mass of a single spar. + Source: original OffshoreBOS model. """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @property def ballast_cost(self): """ - Calculates the cost of ballast material for a single spar. From original OffshoreBOS model. + Calculates the cost of ballast material for a single spar. + Source: original OffshoreBOS model. """ cr = self._design.get("ballast_material_CR", 100) @@ -138,7 +144,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 - + 0.196 * (rating ** 0.5) * log(rating) + + 0.196 * (rating**0.5) * log(rating) + 0.00001 * depth * log(depth) ) @@ -172,7 +178,7 @@ def ballasted_mass(self): @property def substructure_cost(self): - """Returns the total cost (including ballast) of the spar substructure.""" + """Returns the cost (including ballast) of the spar substructure.""" return ( self.stiffened_column_cost @@ -207,7 +213,7 @@ def total_cost(self): @property def design_result(self): - """Returns the result of `self.run()`""" + """Returns the result of `self.run()`.""" if not self._outputs: raise Exception("Has `SparDesign` been ran yet?") diff --git a/ORBIT/phases/install/cable_install/__init__.py b/ORBIT/phases/install/cable_install/__init__.py index abbb38eb..dc52a6a0 100644 --- a/ORBIT/phases/install/cable_install/__init__.py +++ b/ORBIT/phases/install/cable_install/__init__.py @@ -1,4 +1,4 @@ -"""Initialize cable installation functionality""" +"""Initialize cable installation functionality.""" __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/ORBIT/phases/install/cable_install/array.py b/ORBIT/phases/install/cable_install/array.py index 5fbb5923..d24f5144 100644 --- a/ORBIT/phases/install/cable_install/array.py +++ b/ORBIT/phases/install/cable_install/array.py @@ -10,7 +10,7 @@ import numpy as np from marmot import process -from ORBIT.core import Vessel + from ORBIT.core.logic import position_onsite from ORBIT.phases.install import InstallPhase from ORBIT.core.exceptions import InsufficientCable @@ -30,7 +30,7 @@ class ArrayCableInstallation(InstallPhase): - """Array Cable Installation Phase""" + """Array Cable Installation Phase.""" phase = "Array Cable Installation" capex_category = "Array System" @@ -51,7 +51,7 @@ class ArrayCableInstallation(InstallPhase): "cable_sections": [ ("length, km", "int", "speed, km/h (optional)") ], - } + }, }, }, } @@ -77,11 +77,7 @@ def __init__(self, config, weather=None, **kwargs): self.setup_simulation(**kwargs) def setup_simulation(self, **kwargs): - """ - Setup method for ArrayCableInstallation phase. - - Extracts key inputs - - - """ + """Setup method for ArrayCableInstallation phase.""" depth = self.config["site"]["depth"] system = self.config["array_system"] @@ -213,16 +209,16 @@ def install_array_cables( total_cable_length = 0 installed = 0 - for cable, sections in cable_data: + for _, sections in cable_data: for s in sections: - l, num_i, *_ = s - total_cable_length += l * num_i + length, num_i, *_ = s + total_cable_length += length * num_i - _trench_length = max(0, l - 2 * free_cable_length) + _trench_length = max(0, length - 2 * free_cable_length) if _trench_length: trench_sections.extend([_trench_length] * num_i) - ## Trenching Process + # Trenching Process # Conduct trenching along cable routes before laying cable if trench_vessel is None: pass @@ -240,7 +236,9 @@ def install_array_cables( # Dig trench along each cable section distance trench_distance = trench_sections.pop(0) yield dig_array_cables_trench( - trench_vessel, trench_distance, **kwargs + trench_vessel, + trench_distance, + **kwargs, ) except IndexError: @@ -253,7 +251,7 @@ def install_array_cables( message="Array cable trench digging process completed!" ) - ## Cable Lay Process + # Cable Lay Process to_bury = [] for cable, sections in cable_data: vessel.cable_storage.reset() @@ -322,10 +320,13 @@ def install_array_cables( if burial_vessel is None: breakpoints = check_for_completed_string( - vessel, installed, total_cable_length, breakpoints + vessel, + installed, + total_cable_length, + breakpoints, ) - ## Burial Process + # Burial Process if burial_vessel is None: vessel.submit_debug_log( message="Array cable lay/burial process completed!" @@ -361,7 +362,10 @@ def bury_array_cables(vessel, sections, breakpoints, **kwargs): installed += length breakpoints = check_for_completed_string( - vessel, installed, total_length, breakpoints + vessel, + installed, + total_length, + breakpoints, ) vessel.submit_debug_log(message="Array cable burial process completed!") @@ -385,9 +389,7 @@ def dig_array_cables_trench(vessel, distance, **kwargs): def check_for_completed_string(vessel, installed, total, breakpoints): - """ - TODO: - """ + """Checks that a string has been logged as completed.""" if (installed / total) >= breakpoints[0]: vessel.submit_debug_log(progress="Array String") diff --git a/ORBIT/phases/install/cable_install/common.py b/ORBIT/phases/install/cable_install/common.py index 483e9718..6a60d41d 100644 --- a/ORBIT/phases/install/cable_install/common.py +++ b/ORBIT/phases/install/cable_install/common.py @@ -7,12 +7,13 @@ from marmot import process + from ORBIT.core.logic import position_onsite from ORBIT.core.defaults import process_times as pt class SimpleCable: - """Simple Cable Class""" + """Simple Cable Class.""" def __init__(self, linear_density): """ @@ -27,7 +28,7 @@ def __init__(self, linear_density): @process -def load_cable_on_vessel(vessel, cable, constraints={}, **kwargs): +def load_cable_on_vessel(vessel, cable, constraints=None, **kwargs): """ Subprocess for loading `cable` onto the configured `vessel`. @@ -37,16 +38,23 @@ def load_cable_on_vessel(vessel, cable, constraints={}, **kwargs): Performing vessel. Required to have configured `cable_storage`. cable : SimpleCable | Cable Cable type. - constraints : dict - Constraints to be applied to cable loading subprocess. + constraints : dict | None + Constraints to be applied to cable loading subprocess, defaults to + None. """ + if constraints is None: + constraints = {} + key = "cable_load_time" load_time = kwargs.get(key, pt[key]) vessel.cable_storage.load_cable(cable) yield vessel.task_wrapper( - "Load Cable", load_time, constraints=constraints, **kwargs + "Load Cable", + load_time, + constraints=constraints, + **kwargs, ) @@ -87,7 +95,10 @@ def prep_cable(vessel, **kwargs): prep_time = kwargs.get(key, pt[key]) yield vessel.task_wrapper( - "Prepare Cable", prep_time, constraints=vessel.transit_limits, **kwargs + "Prepare Cable", + prep_time, + constraints=vessel.transit_limits, + **kwargs, ) @@ -333,7 +344,10 @@ def tow_plow(vessel, distance, **kwargs): plow_time = distance / plow_speed yield vessel.task_wrapper( - "Tow Plow", plow_time, constraints=vessel.operational_limits, **kwargs + "Tow Plow", + plow_time, + constraints=vessel.operational_limits, + **kwargs, ) @@ -368,7 +382,8 @@ def pull_winch(vessel, distance, **kwargs): @process def dig_trench(vessel, distance, **kwargs): """ - Task representing time required to dig a trench prior to cable lay and burial + Task representing time required to dig a trench prior to cable lay and + burial. Parameters ---------- diff --git a/ORBIT/phases/install/cable_install/export.py b/ORBIT/phases/install/cable_install/export.py index b214af4f..642681ec 100644 --- a/ORBIT/phases/install/cable_install/export.py +++ b/ORBIT/phases/install/cable_install/export.py @@ -31,7 +31,7 @@ class ExportCableInstallation(InstallPhase): - """Export Cable Installation Phase""" + """Export Cable Installation Phase.""" phase = "Export Cable Installation" capex_category = "Export System" @@ -200,12 +200,9 @@ def calculate_onshore_transmission_cost(self, **kwargs): OffshoreBOS model. """ - capacity = self.config["plant"]["capacity"] - + # capacity = self.config["plant"]["capacity"] system = self.config["export_system"] - voltage = system.get("interconnection_voltage", 345) - distance = system.get("interconnection_distance", None) if distance: @@ -218,14 +215,13 @@ def calculate_onshore_transmission_cost(self, **kwargs): ) landfall = system.get("landfall", {}) - distance = landfall.get("interconnection_distance", 3) - switchyard_cost = 18115 * voltage + 165944 - onshore_substation_cost = ( - 0.165 * 1e6 - ) * capacity # From BNEF Tomorrow's Cost of Offshore Wind - onshore_misc_cost = 11795 * capacity**0.3549 + 350000 + # switchyard_cost = 18115 * voltage + 165944 + # onshore_substation_cost = ( + # 0.165 * 1e6 + # ) * capacity # From BNEF Tomorrow's Cost of Offshore Wind + # onshore_misc_cost = 11795 * capacity**0.3549 + 350000 transmission_line_cost = (1176 * voltage + 218257) * ( distance ** (1 - 0.1063) ) @@ -355,17 +351,21 @@ def install_export_cables( else: for _ in range(number): - # Trenching vessel can dig a trench during inbound or outbound journey + # Trench vessel can dig a trench during inbound or outbound journey if trench_vessel.at_port: trench_vessel.at_port = False yield dig_export_cables_trench( - trench_vessel, ground_distance, **kwargs + trench_vessel, + ground_distance, + **kwargs, ) trench_vessel.at_site = True elif trench_vessel.at_site: trench_vessel.at_site = False yield dig_export_cables_trench( - trench_vessel, ground_distance, **kwargs + trench_vessel, + ground_distance, + **kwargs, ) trench_vessel.at_port = True diff --git a/ORBIT/phases/install/install_phase.py b/ORBIT/phases/install/install_phase.py index 0fbad57a..0689a2d9 100644 --- a/ORBIT/phases/install/install_phase.py +++ b/ORBIT/phases/install/install_phase.py @@ -12,6 +12,7 @@ import numpy as np import simpy import pandas as pd + from ORBIT.core import Port, Vessel, Environment from ORBIT.phases import BasePhase from ORBIT.core.defaults import common_costs @@ -51,9 +52,9 @@ def initialize_environment(self, weather, **kwargs): self.env = Environment(name=env_name, state=weather, **kwargs) def initialize_vessel(self, name, specs): - """""" + """Initializes a vessel.""" - avail = getattr(self, "availability") + avail = self.availability if avail is None: return Vessel(name, specs) @@ -67,7 +68,7 @@ def initialize_vessel(self, name, specs): @abstractmethod def setup_simulation(self): """ - Sets up the required simulation infrastructure + Sets up the required simulation infrastructure. Generally, this creates the port, initializes the items to be installed, and initializes the vessel(s) used for the installation. @@ -76,9 +77,7 @@ def setup_simulation(self): pass def initialize_port(self): - """ - Initializes a Port object with N number of cranes. - """ + """Initializes a Port object with N number of cranes.""" self.port = Port(self.env) @@ -107,8 +106,8 @@ def run(self, until=None): def append_phase_info(self): """Appends phase information to all logs in `self.env.logs`.""" - for l in self.env.logs: - l["phase"] = self.phase + for log in self.env.logs: + log["phase"] = self.phase @property def port_costs(self): @@ -122,8 +121,12 @@ def port_costs(self): else: port_config = self.config.get("port", {}) assert port_config.get("sub_assembly_lines", 1) == port_config.get( - "turbine_assembly_cranes", 1 - ), "Number of substructure assembly lines is not equal to number of turbine assembly cranes" + "turbine_assembly_cranes", + 1, + ), ( + "Number of substructure assembly lines is not equal to number" + " of turbine assembly cranes" + ) key = "port_cost_per_month" rate = port_config.get("monthly_rate", common_costs[key]) @@ -155,9 +158,7 @@ def detailed_output(self): @property def agent_efficiencies(self): - """ - Returns a summary of agent operational efficiencies. - """ + """Returns a summary of agent operational efficiencies.""" efficiencies = {} @@ -166,7 +167,7 @@ def agent_efficiencies(self): k: sum([i["duration"] for i in list(v)]) for k, v in groupby(s, key=lambda x: (x["agent"], x["action"])) } - agents = list(set([k[0] for k in grouped.keys()])) + agents = list({k[0] for k in grouped.keys()}) for agent in agents: total = sum([v for k, v in grouped.items() if k[0] == agent]) @@ -192,7 +193,8 @@ def agent_efficiencies(self): @staticmethod def get_max_cargo_mass_utilzations(vessels): """ - Returns a summary of cargo mass efficiencies for list of input `vessels`. + Returns a summary of cargo mass efficiencies for list of input + `vessels`. Parameters ---------- @@ -209,16 +211,17 @@ def get_max_cargo_mass_utilzations(vessels): print("Vessel does not have storage capacity.") continue - outputs[ - f"{name}_cargo_mass_utilization" - ] = vessel.max_cargo_mass_utilization + outputs[f"{name}_cargo_mass_utilization"] = ( + vessel.max_cargo_mass_utilization + ) return outputs @staticmethod def get_max_deck_space_utilzations(vessels): """ - Returns a summary of deck space efficiencies for list of input `vessels`. + Returns a summary of deck space efficiencies for list of input + `vessels`. Parameters ---------- @@ -235,8 +238,8 @@ def get_max_deck_space_utilzations(vessels): print("Vessel does not have storage capacity.") continue - outputs[ - f"{name}_deck_space_utilization" - ] = vessel.max_deck_space_utilization + outputs[f"{name}_deck_space_utilization"] = ( + vessel.max_deck_space_utilization + ) return outputs diff --git a/ORBIT/phases/install/jacket_install/common.py b/ORBIT/phases/install/jacket_install/common.py index 4312bfcf..3ffaa436 100644 --- a/ORBIT/phases/install/jacket_install/common.py +++ b/ORBIT/phases/install/jacket_install/common.py @@ -1,3 +1,8 @@ +""" +Provides the jacket-specific cargo implementation and jacket installation +methods. +""" + __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2021, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" @@ -11,7 +16,7 @@ class Jacket(Cargo): - """Jacket Cargo""" + """Creates the jacket-specific cargo model.""" def __init__( self, @@ -185,5 +190,8 @@ def install_jacket(vessel, jacket, **kwargs): grout_time = kwargs.get("jacket_grout_time", pt["jacket_grout_time"]) yield vessel.task_wrapper( - "Grout Jacket", grout_time, constraints=vessel.transit_limits, **kwargs + "Grout Jacket", + grout_time, + constraints=vessel.transit_limits, + **kwargs, ) diff --git a/ORBIT/phases/install/jacket_install/standard.py b/ORBIT/phases/install/jacket_install/standard.py index 95fb7402..efaef805 100644 --- a/ORBIT/phases/install/jacket_install/standard.py +++ b/ORBIT/phases/install/jacket_install/standard.py @@ -1,3 +1,5 @@ +"""Provides the jacket installation class and model.""" + __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2021, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" @@ -55,7 +57,7 @@ class JacketInstallation(InstallPhase): "mass": "t", "unit_cost": "USD", "num_legs": "N (optional, default: 4)", - "foundation_type": "str (optional, 'piles' | 'suction', default: 'piles')", + "foundation_type": "str (optional, 'piles' | 'suction', default: 'piles')", # noqa: E501 }, "transition_piece": { "deck_space": "m2 (optional)", @@ -111,9 +113,7 @@ def system_capex(self): ] def initialize_substructure_delivery(self): - """ - - """ + """Creates the simulated jacket delivery process.""" jacket = Jacket(**self.config["jacket"]) @@ -161,8 +161,8 @@ def initialize_substructure_delivery(self): def setup_simulation(self, **kwargs): """ - Sets up simulation infrastructure, routing to specific methods dependent - on number of feeders. + Sets up simulation infrastructure, routing to specific methods + dependent on number of feeders. """ if self.config.get("num_feeders", None): @@ -176,7 +176,8 @@ def setup_simulation(self, **kwargs): def setup_simulation_without_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation without feeder barges. + Creates the infrastructure for turbine installation without feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -210,7 +211,8 @@ def setup_simulation_without_feeders(self, **kwargs): def setup_simulation_with_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation using feeder barges. + Creates the infrastructure for turbine installation using feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -261,9 +263,7 @@ def setup_simulation_with_feeders(self, **kwargs): ) def initialize_wtiv(self): - """ - Initializes the WTIV simulation object and the onboard vessel storage. - """ + """Creates the WTIV simulation object and onboard vessel storage.""" wtiv_specs = self.config.get("wtiv", None) name = wtiv_specs.get("name", "WTIV") @@ -277,16 +277,14 @@ def initialize_wtiv(self): self.wtiv = wtiv def initialize_feeders(self): - """ - Initializes feeder barge objects. - """ + """Initializes feeder barge objects.""" number = self.config.get("num_feeders", None) feeder_specs = self.config.get("feeder", None) self.feeders = [] for n in range(number): - name = "Feeder {}".format(n) + name = f"Feeder {n}" feeder = self.initialize_vessel(name, feeder_specs) self.env.register(feeder) @@ -299,7 +297,8 @@ def initialize_feeders(self): def initialize_queue(self): """ Initializes the queue, modeled as a ``SimPy.Resource`` that feeders - join at site. This limits the simulation to one active feeder at a time. + join at site. This limits the simulation to one active feeder at a + time. """ self.active_feeder = simpy.Resource(self.env, capacity=1) @@ -321,7 +320,7 @@ def detailed_output(self): **self.agent_efficiencies, **self.get_max_cargo_mass_utilzations(transport_vessels), **self.get_max_deck_space_utilzations(transport_vessels), - } + }, } return outputs @@ -329,7 +328,12 @@ def detailed_output(self): @process def solo_install_jackets( - vessel, port, distance, jackets, component_list, **kwargs + vessel, + port, + distance, + jackets, + component_list, + **kwargs, ): """ Logic that a Wind Turbine Installation Vessel (WTIV) uses during a single @@ -354,7 +358,10 @@ def solo_install_jackets( try: # Get substructure + transition piece from port yield get_list_of_items_from_port_wait( - vessel, port, component_list, **kwargs + vessel, + port, + component_list, + **kwargs, ) except ItemNotFound: @@ -377,7 +384,9 @@ def solo_install_jackets( if vessel.storage.items: # Prep for jacket install yield prep_for_site_operations( - vessel, survey_required=True, **kwargs + vessel, + survey_required=True, + **kwargs, ) # Get jacket from internal storage @@ -387,7 +396,8 @@ def solo_install_jackets( # Get transition piece from internal storage if needed if "TransitionPiece" in component_list: tp = yield vessel.get_item_from_storage( - "TransitionPiece", **kwargs + "TransitionPiece", + **kwargs, ) yield install_transition_piece(vessel, tp, **kwargs) @@ -407,7 +417,12 @@ def solo_install_jackets( @process def install_jackets_from_queue( - wtiv, queue, jackets, distance, component_list, **kwargs + wtiv, + queue, + jackets, + distance, + component_list, + **kwargs, ): """ Logic that a Wind Turbine Installation Vessel (WTIV) uses to install @@ -443,13 +458,17 @@ def install_jackets_from_queue( # Prep for jacket install yield prep_for_site_operations( - wtiv, survey_required=True, **kwargs + wtiv, + survey_required=True, + **kwargs, ) # Get jacket and tp if "TransitionPiece" in component_list: jacket = yield wtiv.get_item_from_storage( - "Jacket", vessel=queue.vessel, **kwargs + "Jacket", + vessel=queue.vessel, + **kwargs, ) yield install_jacket(wtiv, jacket, **kwargs) @@ -467,7 +486,10 @@ def install_jackets_from_queue( else: jacket = yield wtiv.get_item_from_storage( - "Jacket", vessel=queue.vessel, release=True, **kwargs + "Jacket", + vessel=queue.vessel, + release=True, + **kwargs, ) yield install_jacket(wtiv, jacket, **kwargs) @@ -480,7 +502,11 @@ def install_jackets_from_queue( start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay: Not enough vessels for jackets", delay_time, location="Site") + wtiv.submit_action_log( + "Delay: Not enough vessels for jackets", + delay_time, + location="Site", + ) # Transit to port wtiv.at_site = False diff --git a/ORBIT/phases/install/monopile_install/common.py b/ORBIT/phases/install/monopile_install/common.py index 04af017a..cdfa70b8 100644 --- a/ORBIT/phases/install/monopile_install/common.py +++ b/ORBIT/phases/install/monopile_install/common.py @@ -14,14 +14,17 @@ class Monopile(Cargo): - """Monopile Cargo""" + """Monopile Cargo.""" def __init__( - self, length=None, diameter=None, mass=None, deck_space=None, **kwargs + self, + length=None, + diameter=None, + mass=None, + deck_space=None, + **kwargs, ): - """ - Creates an instance of `Monopile`. - """ + """Creates an instance of `Monopile`.""" self.length = length self.diameter = diameter @@ -48,12 +51,10 @@ def release(**kwargs): class TransitionPiece(Cargo): - """Transition Piece Cargo""" + """Transition Piece Cargo.""" def __init__(self, mass=None, deck_space=None, **kwargs): - """ - Creates an instance of `TransitionPiece`. - """ + """Creates an instance of `TransitionPiece`.""" self.mass = mass self.deck_space = deck_space @@ -69,7 +70,10 @@ def fasten(**kwargs): @staticmethod def release(**kwargs): - """Returns time required to release transition piece from fastenings.""" + """ + Returns the time required to release the transition piece from its + fastenings. + """ key = "tp_release_time" time = kwargs.get(key, pt[key]) @@ -165,7 +169,10 @@ def drive_monopile(vessel, **kwargs): constraints = {**vessel.operational_limits, "whales": false()} yield vessel.task_wrapper( - "Drive Monopile", drive_time, constraints=constraints, **kwargs + "Drive Monopile", + drive_time, + constraints=constraints, + **kwargs, ) @@ -185,7 +192,10 @@ def lower_transition_piece(vessel, **kwargs): """ yield vessel.task_wrapper( - "Lower TP", 1, constraints=vessel.operational_limits, **kwargs + "Lower TP", + 1, + constraints=vessel.operational_limits, + **kwargs, ) @@ -210,7 +220,10 @@ def bolt_transition_piece(vessel, **kwargs): bolt_time = kwargs.get(key, pt[key]) yield vessel.task_wrapper( - "Bolt TP", bolt_time, constraints=vessel.operational_limits, **kwargs + "Bolt TP", + bolt_time, + constraints=vessel.operational_limits, + **kwargs, ) @@ -259,7 +272,10 @@ def cure_transition_piece_grout(vessel, **kwargs): cure_time = kwargs.get(key, pt[key]) yield vessel.task_wrapper( - "Cure TP Grout", cure_time, constraints=vessel.transit_limits, **kwargs + "Cure TP Grout", + cure_time, + constraints=vessel.transit_limits, + **kwargs, ) diff --git a/ORBIT/phases/install/monopile_install/standard.py b/ORBIT/phases/install/monopile_install/standard.py index 47ae2923..6e47b685 100644 --- a/ORBIT/phases/install/monopile_install/standard.py +++ b/ORBIT/phases/install/monopile_install/standard.py @@ -13,8 +13,8 @@ from ORBIT.core import SubstructureDelivery from ORBIT.core.logic import ( prep_for_site_operations, - shuttle_items_to_queue_wait, get_list_of_items_from_port, + shuttle_items_to_queue_wait, ) from ORBIT.phases.install import InstallPhase from ORBIT.core.exceptions import ItemNotFound @@ -106,9 +106,7 @@ def system_capex(self): ) * self.config["plant"]["num_turbines"] def initialize_substructure_delivery(self): - """ - - """ + """Creates the simulated monopile delivery model.""" monopile = Monopile(**self.config["monopile"]) tp = TransitionPiece(**self.config["transition_piece"]) @@ -145,8 +143,8 @@ def initialize_substructure_delivery(self): def setup_simulation(self, **kwargs): """ - Sets up simulation infrastructure, routing to specific methods dependent - on number of feeders. + Sets up simulation infrastructure, routing to specific methods + dependent on number of feeders. """ if self.config.get("num_feeders", None): @@ -160,7 +158,8 @@ def setup_simulation(self, **kwargs): def setup_simulation_without_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation without feeder barges. + Creates the infrastructure for turbine installations without feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -189,7 +188,8 @@ def setup_simulation_without_feeders(self, **kwargs): def setup_simulation_with_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation using feeder barges. + Creates the infrastructure for turbine installation using feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -236,9 +236,7 @@ def setup_simulation_with_feeders(self, **kwargs): ) def initialize_wtiv(self): - """ - Initializes the WTIV simulation object and the onboard vessel storage. - """ + """Creates the WTIV simulation object and its onboard storage.""" wtiv_specs = self.config.get("wtiv", None) name = wtiv_specs.get("name", "WTIV") @@ -252,16 +250,14 @@ def initialize_wtiv(self): self.wtiv = wtiv def initialize_feeders(self): - """ - Initializes feeder barge objects. - """ + """Initializes feeder barge objects.""" number = self.config.get("num_feeders", None) feeder_specs = self.config.get("feeder", None) self.feeders = [] for n in range(number): - name = "Feeder {}".format(n) + name = f"Feeder {n}" feeder = self.initialize_vessel(name, feeder_specs) self.env.register(feeder) @@ -274,7 +270,8 @@ def initialize_feeders(self): def initialize_queue(self): """ Initializes the queue, modeled as a ``SimPy.Resource`` that feeders - join at site. This limits the simulation to one active feeder at a time. + join at site. This limits the simulation to one active feeder at a + time. """ self.active_feeder = simpy.Resource(self.env, capacity=1) @@ -296,7 +293,7 @@ def detailed_output(self): **self.agent_efficiencies, **self.get_max_cargo_mass_utilzations(transport_vessels), **self.get_max_deck_space_utilzations(transport_vessels), - } + }, } return outputs @@ -327,7 +324,10 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): try: # Get substructure + transition piece from port yield get_list_of_items_from_port( - vessel, port, component_list, **kwargs + vessel, + port, + component_list, + **kwargs, ) except ItemNotFound: @@ -335,7 +335,7 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): # the job is done if not vessel.storage.items: vessel.submit_debug_log( - message="Item not found. Shutting down." + message="Item not found. Shutting down.", ) break @@ -350,7 +350,9 @@ def solo_install_monopiles(vessel, port, distance, monopiles, **kwargs): if vessel.storage.items: # Prep for monopile install yield prep_for_site_operations( - vessel, survey_required=True, **kwargs + vessel, + survey_required=True, + **kwargs, ) # Get monopile from internal storage @@ -413,12 +415,16 @@ def install_monopiles_from_queue(wtiv, queue, monopiles, distance, **kwargs): # Prep for monopile install yield prep_for_site_operations( - wtiv, survey_required=True, **kwargs + wtiv, + survey_required=True, + **kwargs, ) # Get monopile monopile = yield wtiv.get_item_from_storage( - "Monopile", vessel=queue.vessel, **kwargs + "Monopile", + vessel=queue.vessel, + **kwargs, ) yield upend_monopile(wtiv, monopile.length, **kwargs) @@ -441,7 +447,11 @@ def install_monopiles_from_queue(wtiv, queue, monopiles, distance, **kwargs): start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay: Not enough vessels for monopiles", delay_time, location="Site") + wtiv.submit_action_log( + "Delay: Not enough vessels for monopiles", + delay_time, + location="Site", + ) # Transit to port wtiv.at_site = False diff --git a/ORBIT/phases/install/mooring_install/mooring.py b/ORBIT/phases/install/mooring_install/mooring.py index a8997f39..d9a86d7d 100644 --- a/ORBIT/phases/install/mooring_install/mooring.py +++ b/ORBIT/phases/install/mooring_install/mooring.py @@ -8,7 +8,7 @@ from marmot import process -from ORBIT.core import Cargo, Vessel +from ORBIT.core import Cargo from ORBIT.core.logic import position_onsite, get_list_of_items_from_port from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install import InstallPhase @@ -75,7 +75,12 @@ def setup_simulation(self, **kwargs): self.anchor_cost = self.config["mooring_system"]["anchor_cost"] install_mooring_systems( - self.vessel, self.port, distance, depth, self.num_systems, **kwargs + self.vessel, + self.port, + distance, + depth, + self.num_systems, + **kwargs, ) @property @@ -142,7 +147,10 @@ def install_mooring_systems(vessel, port, distance, depth, systems, **kwargs): try: # Get mooring systems from port. yield get_list_of_items_from_port( - vessel, port, ["MooringSystem"], **kwargs + vessel, + port, + ["MooringSystem"], + **kwargs, ) except ItemNotFound: @@ -171,7 +179,10 @@ def install_mooring_systems(vessel, port, distance, depth, systems, **kwargs): yield position_onsite(vessel, **kwargs) yield perform_mooring_site_survey(vessel, **kwargs) yield install_mooring_anchor( - vessel, depth, system.anchor_type, **kwargs + vessel, + depth, + system.anchor_type, + **kwargs, ) yield install_mooring_line(vessel, depth, **kwargs) @@ -243,12 +254,15 @@ def install_mooring_anchor(vessel, depth, _type, **kwargs): else: raise ValueError( - f"Mooring System Anchor Type: {_type} not recognized." + f"Mooring System Anchor Type: {_type} not recognized.", ) install_time = fixed + 0.005 * depth yield vessel.task_wrapper( - task, install_time, constraints=vessel.transit_limits, **kwargs + task, + install_time, + constraints=vessel.transit_limits, + **kwargs, ) @@ -280,7 +294,7 @@ def install_mooring_line(vessel, depth, **kwargs): class MooringSystem(Cargo): - """Mooring System Cargo""" + """Mooring System Cargo.""" def __init__( self, @@ -290,7 +304,7 @@ def __init__( anchor_type="Suction Pile", **kwargs, ): - """Creates an instance of MooringSystem""" + """Creates an instance of MooringSystem.""" self.num_lines = num_lines self.line_mass = line_mass diff --git a/ORBIT/phases/install/oss_install/common.py b/ORBIT/phases/install/oss_install/common.py index f90128ac..2e0db712 100644 --- a/ORBIT/phases/install/oss_install/common.py +++ b/ORBIT/phases/install/oss_install/common.py @@ -9,7 +9,7 @@ from marmot import process from ORBIT.core import Cargo -from ORBIT.core.logic import stabilize, jackdown_if_required +from ORBIT.core.logic import jackdown_if_required from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install.monopile_install.common import ( bolt_transition_piece, @@ -19,12 +19,10 @@ class Topside(Cargo): - """Topside Cargo""" + """Topside Cargo.""" def __init__(self, mass=None, deck_space=None, **kwargs): - """ - Creates an instance of `Topside`. - """ + """Creates an instance of `Topside`.""" self.mass = mass self.deck_space = deck_space @@ -49,7 +47,7 @@ def release(**kwargs): class Jacket(Cargo): - """Jacket Cargo""" + """Jacket Cargo.""" pass @@ -74,7 +72,9 @@ def lift_topside(vessel, **kwargs): lift_time = lift_height / crane_rate yield vessel.task_wrapper( - "Lift Topside", lift_time, constraints=vessel.operational_limits + "Lift Topside", + lift_time, + constraints=vessel.operational_limits, ) @@ -101,7 +101,9 @@ def attach_topside(vessel, **kwargs): attach_time = kwargs.get(key, pt[key]) yield vessel.task_wrapper( - "Attach Topside", attach_time, constraints=vessel.operational_limits + "Attach Topside", + attach_time, + constraints=vessel.operational_limits, ) @@ -109,6 +111,7 @@ def attach_topside(vessel, **kwargs): def install_topside(vessel, topside, **kwargs): """ Substation topside installation process. + Subprocesses: - Crane reequip - Lift topside diff --git a/ORBIT/phases/install/oss_install/floating.py b/ORBIT/phases/install/oss_install/floating.py index 1170ad7e..c30ad1f5 100644 --- a/ORBIT/phases/install/oss_install/floating.py +++ b/ORBIT/phases/install/oss_install/floating.py @@ -51,7 +51,6 @@ class FloatingSubstationInstallation(InstallPhase): "line_cost", "USD", "anchor_cost", - "USD", }, } @@ -76,12 +75,7 @@ def __init__(self, config, weather=None, **kwargs): self.setup_simulation() def setup_simulation(self): - """ - Initializes required objects for simulation. - - Creates port - - - Creates support vessel + towing vessels - """ + """Initializes required objects for simulation.""" self.distance = self.config["site"]["distance"] self.num_substations = self.config["num_substations"] @@ -92,7 +86,8 @@ def setup_simulation(self): @property def system_capex(self): """Returns total procurement cost of the substation substructures, - topsides and mooring.""" + topsides and mooring. + """ topside = self.config["offshore_substation_topside"]["unit_cost"] substructure = self.config["offshore_substation_substructure"][ @@ -123,7 +118,8 @@ def initialize_substructure_production(self): if substructure_type != "Floating": warn( f"Offshore substation substructure is {substructure_type}" - " and should be 'Floating'.\n" + " and should be 'Floating'.\n", + stacklevel=1, ) self.wet_storage = WetStorage(self.env, float("inf")) @@ -136,7 +132,11 @@ def initialize_substructure_production(self): to_assemble = [1] * self.num_substations self.assembly_line = SubstationAssemblyLine( - to_assemble, takt_time, attach_time, self.wet_storage, 1 + to_assemble, + takt_time, + attach_time, + self.wet_storage, + 1, ) self.env.register(self.assembly_line) @@ -169,12 +169,18 @@ def initialize_installation_vessel(self): @property def detailed_output(self): + """Returns an empty dictionary.""" return {} @process def install_floating_substations( - vessel, feed, distance, towing_speed, depth, number + vessel, + feed, + distance, + towing_speed, + depth, + number, ): """ Process steps that installation vessel at site performs to install floating @@ -310,9 +316,7 @@ def submit_action_log(self, action, duration, **kwargs): @process def assemble_substructure(self): - """ - Simulation process for assembling a substructure. - """ + """Simulation process for assembling a substructure.""" yield self.task("Substation Substructure Assembly", self.takt_time) yield self.task("Attach Topside", self.attach_time) diff --git a/ORBIT/phases/install/oss_install/standard.py b/ORBIT/phases/install/oss_install/standard.py index f931bc24..54e459c2 100644 --- a/ORBIT/phases/install/oss_install/standard.py +++ b/ORBIT/phases/install/oss_install/standard.py @@ -87,6 +87,7 @@ def system_capex(self): def setup_simulation(self, **kwargs): """ Initializes required objects for simulation. + - Creates port + crane - Creates monopile and topside - Creates heavy lift vessel and feeder @@ -123,9 +124,7 @@ def setup_simulation(self, **kwargs): ) def initialize_topsides_and_substructures(self): - """ - Creates offshore substation objects at port. - """ + """Creates offshore substation objects at port.""" top = Topside(**self.config["offshore_substation_topside"]) sub = Monopile(**self.config["offshore_substation_substructure"]) @@ -136,9 +135,7 @@ def initialize_topsides_and_substructures(self): self.port.put(top) def initialize_oss_install_vessel(self): - """ - Creates the offshore substation installation vessel object. - """ + """Creates the offshore substation installation vessel object.""" oss_vessel_specs = self.config.get("oss_install_vessel", None) name = oss_vessel_specs.get("name", "Heavy Lift Vessel") @@ -152,9 +149,7 @@ def initialize_oss_install_vessel(self): self.oss_vessel = oss_vessel def initialize_feeders(self): - """ - Initializes feeder barge objects. - """ + """Initializes feeder barge objects.""" number = self.config.get("num_feeders", 1) feeder_specs = self.config.get("feeder", None) @@ -162,7 +157,7 @@ def initialize_feeders(self): self.feeders = [] for n in range(number): # TODO: Add in option for named feeders. - name = "Feeder {}".format(n) + name = f"Feeder {n}" feeder = self.initialize_vessel(name, feeder_specs) self.env.register(feeder) @@ -197,7 +192,7 @@ def detailed_output(self): **self.agent_efficiencies, **self.get_max_cargo_mass_utilzations(transport_vessels), **self.get_max_deck_space_utilzations(transport_vessels), - } + }, } return outputs @@ -234,12 +229,16 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): # Prep for monopile install yield prep_for_site_operations( - vessel, survey_required=True, **kwargs + vessel, + survey_required=True, + **kwargs, ) # Get monopile monopile = yield vessel.get_item_from_storage( - "Monopile", vessel=queue.vessel, **kwargs + "Monopile", + vessel=queue.vessel, + **kwargs, ) yield upend_monopile(vessel, monopile.length, **kwargs) @@ -247,7 +246,10 @@ def install_oss_from_queue(vessel, queue, substations, distance, **kwargs): # Get topside topside = yield vessel.get_item_from_storage( - "Topside", vessel=queue.vessel, release=True, **kwargs + "Topside", + vessel=queue.vessel, + release=True, + **kwargs, ) yield install_topside(vessel, topside, **kwargs) n += 1 diff --git a/ORBIT/phases/install/quayside_assembly_tow/common.py b/ORBIT/phases/install/quayside_assembly_tow/common.py index 4083cc36..b62624ba 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/common.py +++ b/ORBIT/phases/install/quayside_assembly_tow/common.py @@ -1,5 +1,6 @@ """Common processes and cargo types for quayside assembly and tow-out -installations""" +installations. +""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -82,9 +83,7 @@ def submit_action_log(self, action, duration, **kwargs): @process def assemble_substructure(self): - """ - Simulation process for assembling a substructure. - """ + """Simulation process for assembling a substructure.""" yield self.task("Substructure Assembly", self.time) substructure = Substructure() @@ -183,7 +182,7 @@ def start(self): while True: start = self.env.now - sub = yield self.feed.get() + _ = yield self.feed.get() delay = self.env.now - start if delay > 0: @@ -271,7 +270,9 @@ def lift_and_attach_nacelle(self): """ yield self.task( - "Lift and Attach Nacelle", 12, constraints={"windspeed": le(15)} + "Lift and Attach Nacelle", + 12, + constraints={"windspeed": le(15)}, ) @process @@ -282,7 +283,9 @@ def lift_and_attach_blade(self): """ yield self.task( - "Lift and Attach Blade", 3.5, constraints={"windspeed": le(12)} + "Lift and Attach Blade", + 3.5, + constraints={"windspeed": le(12)}, ) @process @@ -293,18 +296,24 @@ def mechanical_completion(self): """ yield self.task( - "Mechanical Completion", 24, constraints={"windspeed": le(18)} + "Mechanical Completion", + 24, + constraints={"windspeed": le(18)}, ) @process def electrical_completion(self): """ Task representing time associated with performing electrical completion - work at quayside, including precommissioning. Assumes the tower is delivered to port in multiple sections, requiring cable pull-in after tower assembly. + work at quayside, including precommissioning. Assumes the tower is + delivered to port in multiple sections, requiring cable pull-in after + tower assembly. """ yield self.task( - "Electrical Completion", 72, constraints={"windspeed": le(18)} + "Electrical Completion", + 72, + constraints={"windspeed": le(18)}, ) @@ -363,7 +372,7 @@ def group_task( duration, num_vessels, num_ahts_vessels=0, - constraints={}, + constraints=None, **kwargs, ): """ @@ -381,7 +390,8 @@ def group_task( num_ahts_vessels : int Number of anchor handling tug vessels used for the operation. """ - + if constraints is None: + constraints = {} kwargs = {**kwargs, "num_vessels": num_vessels} kwargs = {**kwargs, "num_ahts_vessels": num_ahts_vessels} yield self.task(name, duration, constraints=constraints, **kwargs) diff --git a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py index 1e80b1fc..ce59c373 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py +++ b/ORBIT/phases/install/quayside_assembly_tow/gravity_base.py @@ -10,7 +10,7 @@ import simpy from marmot import le, process -from ORBIT.core import Vessel, WetStorage +from ORBIT.core import WetStorage from ORBIT.phases.install import InstallPhase from .common import TowingGroup, TurbineAssemblyLine, SubstructureAssemblyLine @@ -74,12 +74,7 @@ def __init__(self, config, weather=None, **kwargs): self.setup_simulation(**kwargs) def setup_simulation(self, **kwargs): - """ - Sets up simulation infrastructure. - - Initializes substructure production - - Initializes turbine assembly processes - - Initializes towing groups - """ + """Readies the installation processes.""" self.distance = self.config["site"]["distance"] self.num_turbines = self.config["plant"]["num_turbines"] @@ -99,9 +94,10 @@ def system_capex(self): def initialize_substructure_production(self): """ - Initializes the production of substructures at port. The number of - independent assembly lines and production time associated with a - substructure can be configured with the following parameters: + Initializes the production of substructures at port. + + The number of independent assembly lines and production time associated + with a substructure can be configured with the following parameters: - self.config["substructure"]["takt_time"] - self.config["port"]["sub_assembly_lines"] @@ -133,7 +129,10 @@ def initialize_substructure_production(self): self.sub_assembly_lines = [] for i in range(lines): a = SubstructureAssemblyLine( - to_assemble, time, self.wet_storage, i + 1 + to_assemble, + time, + self.wet_storage, + i + 1, ) self.env.register(a) @@ -142,8 +141,10 @@ def initialize_substructure_production(self): def initialize_turbine_assembly(self): """ - Initializes turbine assembly lines. The number of independent lines - can be configured with the following parameters: + Initializes turbine assembly lines. + + The number of independent lines can be configured with the following + parameters: - self.config["port"]["turb_assembly_lines"] """ @@ -166,7 +167,10 @@ def initialize_turbine_assembly(self): self.turbine_assembly_lines = [] for i in range(lines): a = TurbineAssemblyLine( - self.wet_storage, self.assembly_storage, turbine, i + 1 + self.wet_storage, + self.assembly_storage, + turbine, + i + 1, ) self.env.register(a) @@ -216,6 +220,7 @@ def initialize_support_vessel(self, **kwargs): """ ** The support vessel is deprecated and an AHTS vessel will perform the installation with the towing group. + # TODO: determine if the installation process for GBF is still sound. @@ -268,7 +273,7 @@ def initialize_support_vessel(self, **kwargs): @property def detailed_output(self): - """""" + """Compiles the detailed installation phase outputs.""" return { "operational_delays": { @@ -287,11 +292,11 @@ def detailed_output(self): self.support_vessel: self.operational_delay( str(self.support_vessel) ), - } + }, } def operational_delay(self, name): - """""" + """Gathers the operational delays from the logs.""" actions = [a for a in self.env.actions if a["agent"] == name] delay = sum(a["duration"] for a in actions if "Delay" in a["action"]) @@ -301,7 +306,13 @@ def operational_delay(self, name): @process def transfer_gbf_substructures_from_storage( - group, feed, distance, queue, towing_vessels, towing_speed, **kwargs + group, + feed, + distance, + queue, + towing_vessels, + towing_speed, + **kwargs, ): """ Process logic for the towing vessel group. @@ -325,7 +336,7 @@ def transfer_gbf_substructures_from_storage( while True: start = group.env.now - assembly = yield feed.get() + _ = yield feed.get() delay = group.env.now - start if delay > 0: @@ -356,25 +367,32 @@ def transfer_gbf_substructures_from_storage( ) queue.vessel = group - active_start = group.env.now + # active_start = group.env.now queue.activate.succeed() # Released by WTIV when objects are depleted group.release = group.env.event() yield group.release - active_time = group.env.now - active_start + # active_time = group.env.now - active_start queue.vessel = None queue.activate = group.env.event() yield group.group_task( - "Transit", transit_time, num_vessels=towing_vessels + "Transit", + transit_time, + num_vessels=towing_vessels, ) @process def install_gravity_base_foundations( - vessel, queue, distance, substructures, station_keeping_vessels, **kwargs + vessel, + queue, + distance, + substructures, + station_keeping_vessels, + **kwargs, ): """ Logic that a Multi-Purpose Support Vessel uses at site to complete the diff --git a/ORBIT/phases/install/quayside_assembly_tow/moored.py b/ORBIT/phases/install/quayside_assembly_tow/moored.py index 916a09fc..a550df78 100644 --- a/ORBIT/phases/install/quayside_assembly_tow/moored.py +++ b/ORBIT/phases/install/quayside_assembly_tow/moored.py @@ -77,6 +77,7 @@ def __init__(self, config, weather=None, **kwargs): def setup_simulation(self): """ Sets up simulation infrastructure. + - Initializes substructure production - Initializes turbine assembly processes - Initializes towing groups @@ -100,9 +101,10 @@ def system_capex(self): def initialize_substructure_production(self): """ - Initializes the production of substructures at port. The number of - independent assembly lines and production time associated with a - substructure can be configured with the following parameters: + Initializes the production of substructures at port. + + The number of independent assembly lines and production time associated + with a substructure can be configured with the following parameters: - self.config["substructure"]["takt_time"] - self.config["port"]["sub_assembly_lines"] @@ -133,7 +135,10 @@ def initialize_substructure_production(self): self.sub_assembly_lines = [] for i in range(lines): a = SubstructureAssemblyLine( - to_assemble, time, self.wet_storage, i + 1 + to_assemble, + time, + self.wet_storage, + i + 1, ) self.env.register(a) @@ -142,7 +147,9 @@ def initialize_substructure_production(self): def initialize_turbine_assembly(self): """ - Initializes turbine assembly lines. The number of independent lines + Initializes turbine assembly lines. + + The number of independent lines can be configured with the following parameters: - self.config["port"]["turb_assembly_lines"] @@ -166,7 +173,10 @@ def initialize_turbine_assembly(self): self.turbine_assembly_lines = [] for i in range(lines): a = TurbineAssemblyLine( - self.wet_storage, self.assembly_storage, turbine, i + 1 + self.wet_storage, + self.assembly_storage, + turbine, + i + 1, ) self.env.register(a) @@ -192,7 +202,8 @@ def initialize_towing_groups(self, **kwargs): if ahts_vessel is None: warn( "No ['ahts_vessel'] specified. num_ahts set to 0." - " ahts_vessel will be required in future releases.\n" + " ahts_vessel will be required in future releases.\n", + stacklevel=1, ) num_ahts = 0 @@ -275,7 +286,7 @@ def initialize_support_vessel(self): @property def detailed_output(self): - """return detailed outputs.""" + """Return detailed outputs.""" return { "operational_delays": { @@ -294,11 +305,11 @@ def detailed_output(self): # self.support_vessel: self.operational_delay( # str(self.support_vessel) # ), - } + }, } def operational_delay(self, name): - """return operational delays""" + """Return operational delays.""" actions = [a for a in self.env.actions if a["agent"] == name] delay = sum(a["duration"] for a in actions if "Delay" in a["action"]) @@ -350,7 +361,7 @@ def towing_group_actions( ): """ Process logic for the towing vessel group. Assumes there is an - anchor tug boat with each group + anchor tug boat with each group. Parameters ---------- @@ -458,7 +469,11 @@ def towing_group_actions( @process def install_moored_substructures( - vessel, queue, distance, substructures, station_keeping_vessels + vessel, + queue, + distance, + substructures, + station_keeping_vessels, ): """ ** DEPRECATED ** This method is deprecated and is now performed @@ -481,7 +496,8 @@ def install_moored_substructures( warn( "** DEPRECATED ** This method is deprecated and is now performed" - " in towing_group_action() by the towing group with AHTS vessel.\n" + " in towing_group_action() by the towing group with AHTS vessel.\n", + stacklevel=1, ) n = 0 diff --git a/ORBIT/phases/install/scour_protection_install/standard.py b/ORBIT/phases/install/scour_protection_install/standard.py index d2dffa37..4b8a628a 100644 --- a/ORBIT/phases/install/scour_protection_install/standard.py +++ b/ORBIT/phases/install/scour_protection_install/standard.py @@ -11,10 +11,13 @@ import simpy from marmot import process -from ORBIT.core import Vessel from ORBIT.core.defaults import process_times as pt from ORBIT.phases.install import InstallPhase -from ORBIT.core.exceptions import CargoMassExceeded, InsufficientAmount, VesselCapacityError +from ORBIT.core.exceptions import ( + CargoMassExceeded, + InsufficientAmount, + VesselCapacityError, +) class ScourProtectionInstallation(InstallPhase): @@ -63,12 +66,7 @@ def __init__(self, config, weather=None, **kwargs): self.setup_simulation(**kwargs) def setup_simulation(self, **kwargs): - """ - Sets up the required simulation infrastructure: - - creates a port - - initializes a scour protection installation vessel - - initializes vessel storage - """ + """Sets up the required simulation infrastructure.""" self.initialize_port() self.initialize_spi_vessel() @@ -120,9 +118,7 @@ def initialize_port(self): self.port = simpy.Container(self.env) def initialize_spi_vessel(self): - """ - Creates the scouring protection isntallation (SPI) vessel. - """ + """Creates the scouring protection isntallation (SPI) vessel.""" spi_specs = self.config["spi_vessel"] name = spi_specs.get("name", "SPI Vessel") @@ -183,7 +179,9 @@ def install_scour_protection( if vessel.at_port: # Load scour protection material yield load_material( - vessel, vessel.rock_storage.available_capacity, **kwargs + vessel, + vessel.rock_storage.available_capacity, + **kwargs, ) # Transit to site @@ -274,7 +272,9 @@ def drop_material(vessel, mass, **kwargs): if vessel.rock_storage.level < mass: raise InsufficientAmount( - vessel.rock_storage.level, "Scour Protection", mass + vessel.rock_storage.level, + "Scour Protection", + mass, ) key = "drop_rocks_time" diff --git a/ORBIT/phases/install/turbine_install/common.py b/ORBIT/phases/install/turbine_install/common.py index 057ff1bd..45106098 100644 --- a/ORBIT/phases/install/turbine_install/common.py +++ b/ORBIT/phases/install/turbine_install/common.py @@ -13,12 +13,10 @@ class TowerSection(Cargo): - """Tower Section Cargo""" + """Tower Section Cargo.""" def __init__(self, length=None, mass=None, deck_space=None, **kwargs): - """ - Creates an instance of `TowerSection`. - """ + """Creates an instance of `TowerSection`.""" self.length = length self.mass = mass @@ -44,12 +42,10 @@ def release(**kwargs): class Nacelle(Cargo): - """Nacelle Cargo""" + """Nacelle Cargo.""" def __init__(self, mass=None, deck_space=None, **kwargs): - """ - Creates an instance of `Nacelle`. - """ + """Creates an instance of `Nacelle`.""" self.mass = mass self.deck_space = deck_space @@ -74,12 +70,10 @@ def release(**kwargs): class Blade(Cargo): - """Blade Cargo""" + """Blade Cargo.""" def __init__(self, length=None, mass=None, deck_space=None, **kwargs): - """ - Creates an instance of `Blade`. - """ + """Creates an instance of `Blade`.""" self.length = length self.mass = mass diff --git a/ORBIT/phases/install/turbine_install/standard.py b/ORBIT/phases/install/turbine_install/standard.py index c05e3088..f0afea5a 100644 --- a/ORBIT/phases/install/turbine_install/standard.py +++ b/ORBIT/phases/install/turbine_install/standard.py @@ -13,7 +13,6 @@ import simpy from marmot import process -from ORBIT.core import Vessel from ORBIT.core.logic import ( jackdown_if_required, shuttle_items_to_queue, @@ -100,8 +99,8 @@ def system_capex(self): def setup_simulation(self, **kwargs): """ - Sets up simulation infrastructure, routing to specific methods dependent - on number of feeders. + Sets up simulation infrastructure, routing to specific methods + dependent on number of feeders. """ if self.config.get("num_feeders", None): @@ -115,7 +114,8 @@ def setup_simulation(self, **kwargs): def setup_simulation_without_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation without feeder barges. + Creates the infrastructure for turbine installation without feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -136,7 +136,8 @@ def setup_simulation_without_feeders(self, **kwargs): def setup_simulation_with_feeders(self, **kwargs): """ - Sets up infrastructure for turbine installation using feeder barges. + Creates the infrastructure for turbine installation using feeder + barges. """ site_distance = self.config["site"]["distance"] @@ -166,9 +167,7 @@ def setup_simulation_with_feeders(self, **kwargs): ) def initialize_wtiv(self): - """ - Initializes the WTIV simulation object and the onboard vessel storage. - """ + """Initializes the WTIV simulation object and its onboard storage.""" wtiv_specs = self.config.get("wtiv", None) name = wtiv_specs.get("name", "WTIV") @@ -182,9 +181,7 @@ def initialize_wtiv(self): self.wtiv = wtiv def initialize_feeders(self): - """ - Initializes feeder barge objects. - """ + """Initializes feeder barge objects.""" number = self.config.get("num_feeders", None) feeder_specs = self.config.get("feeder", None) @@ -192,7 +189,7 @@ def initialize_feeders(self): self.feeders = [] for n in range(number): # TODO: Add in option for named feeders. - name = "Feeder {}".format(n) + name = f"Feeder {n}" feeder = self.initialize_vessel(name, feeder_specs) self.env.register(feeder) @@ -203,9 +200,7 @@ def initialize_feeders(self): self.feeders.append(feeder) def initialize_turbines(self): - """ - Initializes turbine components at port. - """ + """Initializes turbine components at port.""" tower = deepcopy(self.config["turbine"]["tower"]) self.num_sections = tower.get("sections", 1) @@ -240,7 +235,8 @@ def initialize_turbines(self): def initialize_queue(self): """ Initializes the queue, modeled as a ``SimPy.Resource`` that feeders - join at site. This limits the simulation to one active feeder at a time. + join at site. This limits the simulation to one active feeder at a + time. """ self.active_feeder = simpy.Resource(self.env, capacity=1) @@ -262,7 +258,7 @@ def detailed_output(self): **self.agent_efficiencies, **self.get_max_cargo_mass_utilzations(transport_vessels), **self.get_max_deck_space_utilzations(transport_vessels), - } + }, } return outputs @@ -270,7 +266,13 @@ def detailed_output(self): @process def solo_install_turbines( - vessel, port, distance, turbines, tower_sections, num_blades, **kwargs + vessel, + port, + distance, + turbines, + tower_sections, + num_blades, + **kwargs, ): """ Logic that a Wind Turbine Installation Vessel (WTIV) uses during a single @@ -302,7 +304,10 @@ def solo_install_turbines( try: # Get turbine components yield get_list_of_items_from_port( - vessel, port, component_list, **kwargs + vessel, + port, + component_list, + **kwargs, ) except ItemNotFound: @@ -334,7 +339,10 @@ def solo_install_turbines( # Install tower section height = section.length * (i + 1) yield install_tower_section( - vessel, section, height, **kwargs + vessel, + section, + height, + **kwargs, ) # Get turbine nacelle @@ -344,17 +352,22 @@ def solo_install_turbines( # Install nacelle yield vessel.task_wrapper( - "Reequip", reequip_time, constraints=vessel.transit_limits + "Reequip", + reequip_time, + constraints=vessel.transit_limits, ) yield install_nacelle(vessel, nacelle, **kwargs) # Install turbine blades yield vessel.task_wrapper( - "Reequip", reequip_time, constraints=vessel.transit_limits + "Reequip", + reequip_time, + constraints=vessel.transit_limits, ) for _ in range(num_blades): blade = yield vessel.get_item_from_storage( - "Blade", **kwargs + "Blade", + **kwargs, ) yield install_turbine_blade(vessel, blade, **kwargs) @@ -374,7 +387,13 @@ def solo_install_turbines( @process def install_turbine_components_from_queue( - wtiv, queue, distance, turbines, tower_sections, num_blades, **kwargs + wtiv, + queue, + distance, + turbines, + tower_sections, + num_blades, + **kwargs, ): """ Logic that a Wind Turbine Installation Vessel (WTIV) uses to install @@ -416,36 +435,50 @@ def install_turbine_components_from_queue( for i in range(tower_sections): # Get tower section section = yield wtiv.get_item_from_storage( - "TowerSection", vessel=queue.vessel, **kwargs + "TowerSection", + vessel=queue.vessel, + **kwargs, ) # Install tower section height = section.length * (i + 1) yield install_tower_section( - wtiv, section, height, **kwargs + wtiv, + section, + height, + **kwargs, ) # Get turbine nacelle nacelle = yield wtiv.get_item_from_storage( - "Nacelle", vessel=queue.vessel, **kwargs + "Nacelle", + vessel=queue.vessel, + **kwargs, ) # Install nacelle yield wtiv.task_wrapper( - "Reequip", reequip_time, constraints=wtiv.transit_limits + "Reequip", + reequip_time, + constraints=wtiv.transit_limits, ) yield install_nacelle(wtiv, nacelle, **kwargs) # Install turbine blades yield wtiv.task_wrapper( - "Reequip", reequip_time, constraints=wtiv.transit_limits + "Reequip", + reequip_time, + constraints=wtiv.transit_limits, ) for i in range(num_blades): release = True if i + 1 == num_blades else False blade = yield wtiv.get_item_from_storage( - "Blade", vessel=queue.vessel, release=release, **kwargs + "Blade", + vessel=queue.vessel, + release=release, + **kwargs, ) yield install_turbine_blade(wtiv, blade, **kwargs) @@ -458,7 +491,11 @@ def install_turbine_components_from_queue( start = wtiv.env.now yield queue.activate delay_time = wtiv.env.now - start - wtiv.submit_action_log("Delay: Not enough vessels for turbines", delay_time, location="Site") + wtiv.submit_action_log( + "Delay: Not enough vessels for turbines", + delay_time, + location="Site", + ) # Transit to port wtiv.at_site = False diff --git a/ORBIT/supply_chain.py b/ORBIT/supply_chain.py index b17e2ae8..2c09bd70 100644 --- a/ORBIT/supply_chain.py +++ b/ORBIT/supply_chain.py @@ -1,3 +1,5 @@ +"""Provides the ``SupplyChainManager`` model.""" + __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2022, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" @@ -5,70 +7,52 @@ from copy import deepcopy -from benedict import benedict -from ORBIT import ProjectManager +from benedict import benedict +from ORBIT import ProjectManager DEFAULT_MULTIPLIERS = { - "blades": { - "domestic": .026, - "imported": .30 - }, - "nacelle": { - "domestic": .025, - "imported": .10 - }, - "tower": { - "domestic": .04, - "imported": .20, - "tariffs": .25, - }, - "monopile": { - "domestic": .085, - "imported": .28, - "tariffs": .25, - }, - "transition_piece": { - "domestic": .169, - "imported": .17, - "tariffs": .25, - }, - "array_cable": { - "domestic": .19, - "imported": 0. - }, - "export_cable": { - "domestic": .231, - "imported": 0. - }, - "oss_topside": { - "domestic": 0., - "imported": 0. - }, - "oss_substructure": { - "domestic": 0., - "imported": 0. - }, - } - - -TURBINE_CAPEX_SPLIT = { - "blades": 0.135, - "nacelle": 0.274, - "tower": 0.162 + "blades": {"domestic": 0.026, "imported": 0.30}, + "nacelle": {"domestic": 0.025, "imported": 0.10}, + "tower": { + "domestic": 0.04, + "imported": 0.20, + "tariffs": 0.25, + }, + "monopile": { + "domestic": 0.085, + "imported": 0.28, + "tariffs": 0.25, + }, + "transition_piece": { + "domestic": 0.169, + "imported": 0.17, + "tariffs": 0.25, + }, + "array_cable": {"domestic": 0.19, "imported": 0.0}, + "export_cable": {"domestic": 0.231, "imported": 0.0}, + "oss_topside": {"domestic": 0.0, "imported": 0.0}, + "oss_substructure": {"domestic": 0.0, "imported": 0.0}, } +TURBINE_CAPEX_SPLIT = {"blades": 0.135, "nacelle": 0.274, "tower": 0.162} + + LABOR_SPLIT = { "tower": 0.5, "monopile": 0.5, "transition_piece": 0.5, - "oss_topside": 0.5 + "oss_topside": 0.5, } class SupplyChainManager: + """ + Enables a more detailed cost breakdown and financial accounting tool for + modeling supply chain changes related to wind farms. + """ def __init__(self, supply_chain_configuration, **kwargs): """ @@ -108,20 +92,20 @@ def run_project(self, config, weather=None, **kwargs): return project def pre_process(self, config): - """""" + """Prepares the configuration to account for detailed costs.""" # Save original plant design - plant = deepcopy(config['plant']) + plant = deepcopy(config["plant"]) # Run ProjectManager without install phases to generate design results - install_phases = config['install_phases'] - config['install_phases'] = [] + install_phases = config["install_phases"] + config["install_phases"] = [] project = ProjectManager(config) project.run() config = deepcopy(project.config) # Replace calculated plant design with original - config['plant'] = plant + config["plant"] = plant # Run pre ORBIT supply chain adjustments config = self.process_turbine_capex(config) @@ -130,13 +114,13 @@ def pre_process(self, config): config = self.process_offshore_substation_topside_capex(config) # Add install phases back in - config['install_phases'] = install_phases - config['design_phases'] = [] + config["install_phases"] = install_phases + config["design_phases"] = [] return config def post_process(self, project): - """""" + """Computes the modified array and export cabling costs.""" project = self.process_array_cable_capex(project) project = self.process_export_cable_capex(project) @@ -154,45 +138,51 @@ def process_turbine_capex(self, config): ORBIT configuration. """ - blade_scenario = self.sc_config['blades'] - nacelle_scenario = self.sc_config['nacelle'] - tower_scenario = self.sc_config['blades'] + blade_scenario = self.sc_config["blades"] + nacelle_scenario = self.sc_config["nacelle"] + tower_scenario = self.sc_config["blades"] blade_mult = self.multipliers["blades"].get(blade_scenario, None) - if blade_mult == None: - print(f"Warning: scenario '{blade_scenario}' not found for category 'blades'.") - blade_mult = 0. + if blade_mult is None: + print( + f"Warning: scenario '{blade_scenario}' not found for category 'blades'." # noqa: E501 + ) + blade_mult = 0.0 nacelle_mult = self.multipliers["nacelle"].get(nacelle_scenario, None) - if nacelle_mult == None: - print(f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'.") - nacelle_mult = 0. + if nacelle_mult is None: + print( + f"Warning: scenario '{nacelle_scenario}' not found for category 'nacelle'." # noqa: E501 + ) + nacelle_mult = 0.0 - raw_cost = config.get('project_parameters.turbine_capex', 1300) - blade_adder = raw_cost * self.turbine_split['blades'] * blade_mult - nacelle_adder = raw_cost * self.turbine_split['nacelle'] * nacelle_mult + raw_cost = config.get("project_parameters.turbine_capex", 1300) + blade_adder = raw_cost * self.turbine_split["blades"] * blade_mult + nacelle_adder = raw_cost * self.turbine_split["nacelle"] * nacelle_mult if tower_scenario == "domestic, imported steel": tower_adder = self.multipliers["tower"]["domestic"] * raw_cost - tower_tariffs = raw_cost * self.turbine_split['tower'] *\ - (1 - self.labor_split['tower']) * self.multipliers["tower"]['tariffs'] + tower_tariffs = ( + raw_cost + * self.turbine_split["tower"] + * (1 - self.labor_split["tower"]) + * self.multipliers["tower"]["tariffs"] + ) else: - tower_tariffs = 0. + tower_tariffs = 0.0 tower_mult = self.multipliers["tower"].get(tower_scenario, None) - if tower_mult == None: - print(f"Warning: scenario '{tower_scenario}' not found for category 'tower'.") - tower_mult = 0. + if tower_mult is None: + print( + f"Warning: scenario '{tower_scenario}' not found for category 'tower'." # noqa: E501 + ) + tower_mult = 0.0 - tower_adder = raw_cost * self.turbine_split['tower'] * tower_mult + tower_adder = raw_cost * self.turbine_split["tower"] * tower_mult - config['project_parameters.turbine_capex'] = sum([ - raw_cost, - blade_adder, - nacelle_adder, - tower_adder, - tower_tariffs - ]) + config["project_parameters.turbine_capex"] = sum( + [raw_cost, blade_adder, nacelle_adder, tower_adder, tower_tariffs] + ) return config @@ -206,28 +196,29 @@ def process_monopile_capex(self, config): ORBIT configuration. """ - raw_cost = config['monopile.unit_cost'] - scenario = self.sc_config['monopile'] + raw_cost = config["monopile.unit_cost"] + scenario = self.sc_config["monopile"] if scenario == "domestic, imported steel": - adder = self.multipliers['monopile']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['monopile']) *\ - self.multipliers["monopile"]['tariffs'] + adder = self.multipliers["monopile"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["monopile"]) + * self.multipliers["monopile"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["monopile"].get(scenario, None) - if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'monopile'.") - mult = 0. + if mult is None: + print( + f"Warning: scenario '{scenario}' not found for category 'monopile'." # noqa: E501 + ) + mult = 0.0 adder = raw_cost * mult - config['monopile.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["monopile.unit_cost"] = sum([raw_cost, adder, tariffs]) return config @@ -242,28 +233,29 @@ def process_transition_piece_capex(self, config): ORBIT configuration. """ - raw_cost = config['transition_piece.unit_cost'] - scenario = self.sc_config['transition_piece'] + raw_cost = config["transition_piece.unit_cost"] + scenario = self.sc_config["transition_piece"] if scenario == "domestic, imported steel": - adder = self.multipliers['transition_piece']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['transition_piece']) *\ - self.multipliers["transition_piece"]['tariffs'] + adder = self.multipliers["transition_piece"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["transition_piece"]) + * self.multipliers["transition_piece"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["transition_piece"].get(scenario, None) - if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'transition_piece'.") - mult = 0. + if mult is None: + print( + f"Warning: scenario '{scenario}' not found for category 'transition_piece'." # noqa: E501 + ) + mult = 0.0 adder = raw_cost * mult - config['transition_piece.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["transition_piece.unit_cost"] = sum([raw_cost, adder, tariffs]) return config @@ -278,28 +270,31 @@ def process_offshore_substation_topside_capex(self, config): ORBIT configuration. """ - raw_cost = config['offshore_substation_topside.unit_cost'] - scenario = self.sc_config['oss_topside'] + raw_cost = config["offshore_substation_topside.unit_cost"] + scenario = self.sc_config["oss_topside"] if scenario == "domestic, imported steel": - adder = self.multipliers['oss_topside']['domestic'] * raw_cost - tariffs = raw_cost * (1 - self.labor_split['oss_topside']) *\ - self.multipliers["oss_topside"]['tariffs'] + adder = self.multipliers["oss_topside"]["domestic"] * raw_cost + tariffs = ( + raw_cost + * (1 - self.labor_split["oss_topside"]) + * self.multipliers["oss_topside"]["tariffs"] + ) else: - tariffs = 0. + tariffs = 0.0 mult = self.multipliers["oss_topside"].get(scenario, None) - if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'oss_topside'.") - mult = 0. + if mult is None: + print( + f"Warning: scenario '{scenario}' not found for category 'oss_topside'." # noqa: E501 + ) + mult = 0.0 adder = raw_cost * mult - config['offshore_substation_topside.unit_cost'] = sum([ - raw_cost, - adder, - tariffs - ]) + config["offshore_substation_topside.unit_cost"] = sum( + [raw_cost, adder, tariffs], + ) return config @@ -313,13 +308,15 @@ def process_array_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config['array_cable'] + scenario = self.sc_config["array_cable"] mult = self.multipliers["array_cable"].get(scenario, None) - if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'array_cable'.") - mult = 0. + if mult is None: + print( + f"Warning: scenario '{scenario}' not found for category 'array_cable'." # noqa: E501 # noqa: E501 + ) + mult = 0.0 - project.system_costs['ArrayCableInstallation'] *= (1 + mult) + project.system_costs["ArrayCableInstallation"] *= 1 + mult return project @@ -332,12 +329,14 @@ def process_export_cable_capex(self, project): project : ProjectManager """ - scenario = self.sc_config['export_cable'] + scenario = self.sc_config["export_cable"] mult = self.multipliers["export_cable"].get(scenario, None) - if mult == None: - print(f"Warning: scenario '{scenario}' not found for category 'export_cable'.") - mult = 0. + if mult is None: + print( + f"Warning: scenario '{scenario}' not found for category 'export_cable'." # noqa: E501 + ) + mult = 0.0 - project.system_costs['ExportCableInstallation'] *= (1 + mult) + project.system_costs["ExportCableInstallation"] *= 1 + mult return project diff --git a/README.rst b/README.rst index 088cf0ef..67b187fb 100644 --- a/README.rst +++ b/README.rst @@ -3,8 +3,10 @@ ORBIT Offshore Renewables Balance of system and Installation Tool +|PyPI version| |PyPI downloads| |Apache 2.0| |image| + +|Binder| |Pre-commit| |Black| |isort| |Ruff| -:Version: 1.0.8 :Authors: `Jake Nunemaker `_, `Matt Shields `_, `Rob Hammond `_ :Documentation: `ORBIT Docs `_ @@ -66,8 +68,7 @@ Instructions # OR if you are you going to be contributing to the code or building documentation pip install -e '.[dev]' -6. (Development only) Install the pre-commit hooks to autoformat code and - check that tests pass. +6. (Development only) Install the pre-commit hooks to autoformat and lint code. .. code-block:: console @@ -76,20 +77,27 @@ Instructions Dependencies ~~~~~~~~~~~~ -- Python 3.7+ +- Python 3.9+ - marmot-agents +- SimPy - NumPy +- Pandas - SciPy - Matplotlib - OpenMDAO (>=3.2) +- python-benedict +- statsmodels +- PyYAML Development Specific ~~~~~~~~~~~~~~~~~~~~ +- pre-commit - black - isort -- pre-commit +- ruff - pytest +- pytest-cov - sphinx - sphinx-rtd-theme @@ -98,4 +106,23 @@ Recommended packages for easy iteration and running of code: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - jupyterlab -- pandas + + +.. |PyPI version| image:: https://badge.fury.io/py/orbit-nrel.svg + :target: https://badge.fury.io/py/orbit-nrel +.. |PyPI downloads| image:: https://img.shields.io/pypi/dm/orbit-nrel?link=https%3A%2F%2Fpypi.org%2Fproject%2Forbit-nrel%2F + :target: https://pypi.org/project/orbit-nrel/ +.. |Apache 2.0| image:: https://img.shields.io/badge/License-Apache%202.0-blue.svg + :target: https://opensource.org/licenses/Apache-2.0 +.. |image| image:: https://img.shields.io/pypi/pyversions/orbit-nrel.svg + :target: https://pypi.python.org/pypi/orbit-nrel +.. |Binder| image:: https://mybinder.org/badge_logo.svg + :target: https://mybinder.org/v2/gh/WISDEM/ORBIT/dev?filepath=examples +.. |Pre-commit| image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white + :target: https://github.com/pre-commit/pre-commit +.. |Black| image:: https://img.shields.io/badge/code%20style-black-000000.svg + :target: https://github.com/psf/black +.. |isort| image:: https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336 + :target: https://pycqa.github.io/isort/ +.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff diff --git a/docs/conf.py b/docs/conf.py index 38ceb207..508ba970 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -1,24 +1,18 @@ """ +Configuration file for the Sphinx documentation builder. + Jake Nunemaker National Renewable Energy Lab 09/13/2019 - -Configuration file for the Sphinx documentation builder. """ - # -- Path setup -------------------------------------------------------------- -import os -import sys - -sys.path.insert(0, os.path.abspath("..")) import ORBIT - # -- Project information ----------------------------------------------------- project = "ORBIT" -copyright = "2020, National Renewable Energy Lab" +copyright = "2020, National Renewable Energy Lab" # noqa: A001 author = "Jake Nunemaker, Matt Shields, Rob Hammond" release = ORBIT.__version__ diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 914f37a6..92f5b249 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -5,7 +5,10 @@ ORBIT Changelog Unreleased (TBD) ---------------- -- merged SemiTaut_Mooring_Update + +Merged SemiTaut Moorings +~~~~~~~~~~~~~~~~~~~~~~~~ + - The ``MooringSystemDesign`` module now can use a Catenary or SemiTaut mooring system. User can specify "mooring_type". - The ``FloatingOffshoreSubstation`` and ``ElectricalDesign`` modules now actually have a floating option to remove any substructure mass (and cost) from older versions. User can specify "oss_substructure_type" - The ``MoredSubInstallation`` now utilizes an AHTS vessel which must be added to any config file as (ahts_vessel) @@ -16,10 +19,9 @@ Unreleased (TBD) - example_cable_lay_vessel min_draft changed from 4.8m to 8.5m, overall_length 99m to 171m, max_mass 4000t to 13000t - example_towing_vessel max_waveheight changed from 2.5m to 3.0m, max_windspeed 20m to 15m, transit_speed 6km/h to 14 km/h, day_rate 30k to 35k +Merged Electrical Refactor +~~~~~~~~~~~~~~~~~~~~~~~~~~ -Unreleased (TBD) ----------------- -- merged electrical-refactor - Updated ``ElectricalDesign`` module. This class combines the elements of ``ExportSystemDesign`` and the ``OffshoreSubstationDesign`` modules. Its purpose is to represent the export system more accurately by linking the type of cable (AC versus DC) and substation’s components (i.e. transformers versus converters).Figure 1 shows how to add ElectricalDesign() to a yaml @@ -42,11 +44,24 @@ how to use ParametricManager to compare the two design decisions. - Expanded tests to demonstrate new features in ``ElectricalDesign``. +Improvements +~~~~~~~~~~~~ +- Fully adopted `pyproject.toml` for managing all possible tool settings, and + removed the tool-specific files from the top-level of the directory. +- Replaced flake8 and pylint with ruff to adopt a cleaner, faster, and easier + to manage linting and autoformatting workflow. As a result, some of the more + onerous checks have been removed to discourage the use of + `git commit --no-verify`. This change has also added in other rules that + discourage Python anti-patterns and encourage modern Python usage. +- NOTE: Users may wish to run + `git config blame.ignoreRevsFile .git-blame-ignore-revs` to ignore the + reformatting edits in their blame. + 1.0.8 ----- - Added explicit methods for adding custom design or install phases to - ProjectManager. + ``ProjectManager``. - Added WOMBAT compatibility for custom array system files. - Fixed bug in custom array cable system design that breaks for plants with more than two substations. diff --git a/examples/1. Introduction.ipynb b/examples/1. Introduction.ipynb index 88bc1f4c..a7ff9c4c 100644 --- a/examples/1. Introduction.ipynb +++ b/examples/1. Introduction.ipynb @@ -1,280 +1,280 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from copy import deepcopy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ORBIT Introduction\n", - "\n", - "ORBIT is organized into two different types of modules: design and installation. Design modules are intended to model the sizing and cost of offshore wind subcomponents and installation modules simulate the installation of these subcomponents in a discrete event simulation framework. The easiest way to start working with ORBIT is to look at one module. This tutorial will look at the monopile design module and the next tutorial will look at the monopile installation module." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# To import a design module:\n", - "from ORBIT.phases.design import MonopileDesign" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "text/plain": [ - "{'site': {'depth': 'm', 'mean_windspeed': 'm/s'},\n", - " 'plant': {'num_turbines': 'int'},\n", - " 'turbine': {'rotor_diameter': 'm',\n", - " 'hub_height': 'm',\n", - " 'rated_windspeed': 'm/s'},\n", - " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", - " 'load_factor': 'float (optional)',\n", - " 'material_factor': 'float (optional)',\n", - " 'monopile_density': 'kg/m3 (optional)',\n", - " 'monopile_modulus': 'Pa (optional)',\n", - " 'monopile_tp_connection_thickness': 'm (optional)',\n", - " 'transition_piece_density': 'kg/m3 (optional)',\n", - " 'transition_piece_thickness': 'm (optional)',\n", - " 'transition_piece_length': 'm (optional)',\n", - " 'soil_coefficient': 'N/m3 (optional)',\n", - " 'air_density': 'kg/m3 (optional)',\n", - " 'weibull_scale_factor': 'float (optional)',\n", - " 'weibull_shape_factor': 'float (optional)',\n", - " 'turb_length_scale': 'm (optional)',\n", - " 'monopile_steel_cost': 'USD/t (optional)',\n", - " 'tp_steel_cost': 'USD/t (optional)'}}" + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from copy import deepcopy" ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Each module has a property `.expected_config` that gives hints as to how to configure the module properly.\n", - "# This property returns a nested dictionary with all of the inputs (including optional ones) that can be used\n", - "# to configure this module.\n", - "\n", - "# For example:\n", - "MonopileDesign.expected_config" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# For now, lets ignore the optional inputs in the 'monopile_design' subdict and just look at the required inputs:\n", - "config_unfilled = {\n", - " 'site': { # Inputs are grouped into subdicts, eg. site, plant, etc.\n", - " 'depth': 'm', # The value represents the unit where applicable\n", - " 'mean_windspeed': 'm/s'\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 'int'\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'rotor_diameter': 'm',\n", - " 'hub_height': 'm',\n", - " 'rated_windspeed': 'm/s'\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n", - "Total Substructure Cost: 276.77 M\n" - ] - } - ], - "source": [ - "# Filling out the config for a simple fixed bottom project:\n", - "config = {\n", - " 'site': {\n", - " 'depth': 25,\n", - " 'mean_windspeed': 9.5\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 50\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'rotor_diameter': 220,\n", - " 'hub_height': 120,\n", - " 'rated_windspeed': 13\n", - " }\n", - "}\n", - "\n", - "# To run the module, create an instance by passing the config into the module and then use module.run()\n", - "\n", - "module = MonopileDesign(config)\n", - "module.run()\n", - "print(f\"Total Substructure Cost: {module.total_cost/1e6:.2f} M\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ORBIT Introduction\n", + "\n", + "ORBIT is organized into two different types of modules: design and installation. Design modules are intended to model the sizing and cost of offshore wind subcomponents and installation modules simulate the installation of these subcomponents in a discrete event simulation framework. The easiest way to start working with ORBIT is to look at one module. This tutorial will look at the monopile design module and the next tutorial will look at the monopile installation module." + ] + }, { - "ename": "MissingInputs", - "evalue": "Input(s) '['site.depth', 'site.mean_windspeed']' missing in config.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mMissingInputs\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"site\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mmodule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMonopileDesign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Fun/repos/ORBIT/ORBIT/phases/design/monopile_design.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, config, **kwargs)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minitialize_library\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Fun/repos/ORBIT/ORBIT/phases/base.py\u001b[0m in \u001b[0;36mvalidate_config\u001b[0;34m(self, config)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmissing\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mMissingInputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mMissingInputs\u001b[0m: Input(s) '['site.depth', 'site.mean_windspeed']' missing in config." - ] - } - ], - "source": [ - "# If a required input is missing, an error message will be raised with the input and it's location within the configuration.\n", - "# This error message used 'dot-notation' to show the structure of the dictionary. Each \".\" represents a lower level in the dictionary.\n", - "# \"site.depth\" indicates that it is the 'depth' input in the 'site' subdict.\n", - "\n", - "# In the example below, the 'site' inputs have been removed.\n", - "# The following inputs will be missing: '['site.depth', 'site.mean_windspeed']'\n", - "\n", - "tmp = deepcopy(config)\n", - "_ = tmp.pop(\"site\")\n", - "\n", - "module = MonopileDesign(tmp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Optional Inputs" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# To import a design module:\n", + "from ORBIT.phases.design import MonopileDesign" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total Substructure Cost: 361.02 M\n" - ] - } - ], - "source": [ - "# Now lets add more optional inputs:\n", - "config = {\n", - " 'site': {\n", - " 'depth': 25,\n", - " 'mean_windspeed': 9.5\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 50\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'rotor_diameter': 220,\n", - " 'hub_height': 120,\n", - " 'rated_windspeed': 13\n", - " },\n", - " \n", - " # --- New Inputs ---\n", - " 'monopile_design': {\n", - " 'monopile_steel_cost': 3500, # USD/t\n", - " 'tp_steel_cost': 4500 # USD/t\n", - " }\n", - "}\n", - "\n", - "module = MonopileDesign(config)\n", - "module.run()\n", - "print(f\"Total Substructure Cost: {module.total_cost/1e6:.2f} M\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'site': {'depth': 'm', 'mean_windspeed': 'm/s'},\n", + " 'plant': {'num_turbines': 'int'},\n", + " 'turbine': {'rotor_diameter': 'm',\n", + " 'hub_height': 'm',\n", + " 'rated_windspeed': 'm/s'},\n", + " 'monopile_design': {'yield_stress': 'Pa (optional)',\n", + " 'load_factor': 'float (optional)',\n", + " 'material_factor': 'float (optional)',\n", + " 'monopile_density': 'kg/m3 (optional)',\n", + " 'monopile_modulus': 'Pa (optional)',\n", + " 'monopile_tp_connection_thickness': 'm (optional)',\n", + " 'transition_piece_density': 'kg/m3 (optional)',\n", + " 'transition_piece_thickness': 'm (optional)',\n", + " 'transition_piece_length': 'm (optional)',\n", + " 'soil_coefficient': 'N/m3 (optional)',\n", + " 'air_density': 'kg/m3 (optional)',\n", + " 'weibull_scale_factor': 'float (optional)',\n", + " 'weibull_shape_factor': 'float (optional)',\n", + " 'turb_length_scale': 'm (optional)',\n", + " 'monopile_steel_cost': 'USD/t (optional)',\n", + " 'tp_steel_cost': 'USD/t (optional)'}}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Each module has a property `.expected_config` that gives hints as to how to configure the module properly.\n", + "# This property returns a nested dictionary with all of the inputs (including optional ones) that can be used\n", + "# to configure this module.\n", + "\n", + "# For example:\n", + "MonopileDesign.expected_config" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# For now, lets ignore the optional inputs in the 'monopile_design' subdict and just look at the required inputs:\n", + "config_unfilled = {\n", + " 'site': { # Inputs are grouped into subdicts, eg. site, plant, etc.\n", + " 'depth': 'm', # The value represents the unit where applicable\n", + " 'mean_windspeed': 'm/s'\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 'int'\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'rotor_diameter': 'm',\n", + " 'hub_height': 'm',\n", + " 'rated_windspeed': 'm/s'\n", + " }\n", + "}" + ] + }, { - "data": { - "text/plain": [ - "{'monopile': {'diameter': 10.217490535969192,\n", - " 'thickness': 0.10852490535969192,\n", - " 'moment': 44.02602353978204,\n", - " 'embedment_length': 37.11640362329476,\n", - " 'length': 72.11640362329476,\n", - " 'mass': 1082.5344126589946,\n", - " 'deck_space': 104.39711285262001,\n", - " 'unit_cost': 3788870.444306481},\n", - " 'transition_piece': {'thickness': 0.10852490535969192,\n", - " 'diameter': 10.434540346688577,\n", - " 'mass': 762.5683087222009,\n", - " 'length': 25,\n", - " 'deck_space': 108.87963224667176,\n", - " 'unit_cost': 3431557.389249904}}" + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n", + "Total Substructure Cost: 276.77 M\n" + ] + } + ], + "source": [ + "# Filling out the config for a simple fixed bottom project:\n", + "config = {\n", + " 'site': {\n", + " 'depth': 25,\n", + " 'mean_windspeed': 9.5\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 50\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'rotor_diameter': 220,\n", + " 'hub_height': 120,\n", + " 'rated_windspeed': 13\n", + " }\n", + "}\n", + "\n", + "# To run the module, create an instance by passing the config into the module and then use module.run()\n", + "\n", + "module = MonopileDesign(config)\n", + "module.run()\n", + "print(f\"Total Substructure Cost: {module.total_cost/1e6:.2f} M\")" ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "MissingInputs", + "evalue": "Input(s) '['site.depth', 'site.mean_windspeed']' missing in config.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mMissingInputs\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtmp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"site\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mmodule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMonopileDesign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtmp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Fun/repos/ORBIT/ORBIT/phases/design/monopile_design.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, config, **kwargs)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minitialize_library\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Fun/repos/ORBIT/ORBIT/phases/base.py\u001b[0m in \u001b[0;36mvalidate_config\u001b[0;34m(self, config)\u001b[0m\n\u001b[1;32m 115\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 116\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmissing\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 117\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mMissingInputs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmissing\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 118\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mMissingInputs\u001b[0m: Input(s) '['site.depth', 'site.mean_windspeed']' missing in config." + ] + } + ], + "source": [ + "# If a required input is missing, an error message will be raised with the input and it's location within the configuration.\n", + "# This error message used 'dot-notation' to show the structure of the dictionary. Each \".\" represents a lower level in the dictionary.\n", + "# \"site.depth\" indicates that it is the 'depth' input in the 'site' subdict.\n", + "\n", + "# In the example below, the 'site' inputs have been removed.\n", + "# The following inputs will be missing: '['site.depth', 'site.mean_windspeed']'\n", + "\n", + "tmp = deepcopy(config)\n", + "_ = tmp.pop(\"site\")\n", + "\n", + "module = MonopileDesign(tmp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Optional Inputs" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total Substructure Cost: 361.02 M\n" + ] + } + ], + "source": [ + "# Now lets add more optional inputs:\n", + "config = {\n", + " 'site': {\n", + " 'depth': 25,\n", + " 'mean_windspeed': 9.5\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 50\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'rotor_diameter': 220,\n", + " 'hub_height': 120,\n", + " 'rated_windspeed': 13\n", + " },\n", + " \n", + " # --- New Inputs ---\n", + " 'monopile_design': {\n", + " 'monopile_steel_cost': 3500, # USD/t\n", + " 'tp_steel_cost': 4500 # USD/t\n", + " }\n", + "}\n", + "\n", + "module = MonopileDesign(config)\n", + "module.run()\n", + "print(f\"Total Substructure Cost: {module.total_cost/1e6:.2f} M\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'monopile': {'diameter': 10.217490535969192,\n", + " 'thickness': 0.10852490535969192,\n", + " 'moment': 44.02602353978204,\n", + " 'embedment_length': 37.11640362329476,\n", + " 'length': 72.11640362329476,\n", + " 'mass': 1082.5344126589946,\n", + " 'deck_space': 104.39711285262001,\n", + " 'unit_cost': 3788870.444306481},\n", + " 'transition_piece': {'thickness': 0.10852490535969192,\n", + " 'diameter': 10.434540346688577,\n", + " 'mass': 762.5683087222009,\n", + " 'length': 25,\n", + " 'deck_space': 108.87963224667176,\n", + " 'unit_cost': 3431557.389249904}}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# To look at more detailed results:\n", + "module.design_result" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "# To look at more detailed results:\n", - "module.design_result" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/2. Installation Modules.ipynb b/examples/2. Installation Modules.ipynb index 4f7247c2..2723ee0a 100644 --- a/examples/2. Installation Modules.ipynb +++ b/examples/2. Installation Modules.ipynb @@ -1,1742 +1,1742 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Installation Modules\n", - "\n", - "Installation modules have the same external structure (ie. 'expected_config') as design modules, however they have additional internal pieces to them that power the discrete event simulation framework." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# To import an installation module:\n", - "from ORBIT.phases.install import MonopileInstallation" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "text/plain": [ - "{'wtiv': 'dict | str',\n", - " 'feeder': 'dict | str (optional)',\n", - " 'num_feeders': 'int (optional)',\n", - " 'site': {'depth': 'm', 'distance': 'km'},\n", - " 'plant': {'num_turbines': 'int'},\n", - " 'turbine': {'hub_height': 'm'},\n", - " 'port': {'num_cranes': 'int (optional, default: 1)',\n", - " 'monthly_rate': 'USD/mo (optional)',\n", - " 'name': 'str (optional)'},\n", - " 'monopile': {'length': 'm',\n", - " 'diameter': 'm',\n", - " 'deck_space': 'm2',\n", - " 'mass': 't',\n", - " 'unit_cost': 'USD'},\n", - " 'transition_piece': {'deck_space': 'm2', 'mass': 't', 'unit_cost': 'USD'}}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Modules\n", + "\n", + "Installation modules have the same external structure (ie. 'expected_config') as design modules, however they have additional internal pieces to them that power the discrete event simulation framework." ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Expected config:\n", - "MonopileInstallation.expected_config" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "config_unfilled = {\n", - " 'site': { # Similar to the design module, inputs are grouped by category\n", - " 'depth': 'm', # Many of the inputs required are the same as the design module\n", - " 'distance': 'km'\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 'int'\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'hub_height': 'm'\n", - " },\n", - " \n", - " 'wtiv': 'dict | str', # The WTIV that will be installing the monopiles.\n", - " # Vessel are defined in the library in .yaml files.\n", - " \n", - " 'monopile': { # Notice that the result of the last module (monopile + transition piece sizing)\n", - " 'length': 'm', # is an input into the installation module.\n", - " 'diameter': 'm',\n", - " 'deck_space': 'm2',\n", - " 'mass': 't',\n", - " 'unit_cost': 'USD'\n", - " },\n", - " \n", - " 'transition_piece': {\n", - " 'deck_space': 'm2',\n", - " 'mass': 't',\n", - " 'unit_cost': 'USD'\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 21.94 M\n" - ] - } - ], - "source": [ - "config = {\n", - " 'site': {\n", - " 'depth': 25,\n", - " 'distance': 50\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 50\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'hub_height': 120\n", - " },\n", - " \n", - " 'wtiv': 'example_wtiv', # See 'example_wtiv.yaml'\n", - " \n", - " 'monopile': {\n", - " 'length': 72.1,\n", - " 'diameter': 10.2,\n", - " 'deck_space': 104.4,\n", - " 'mass': 1082.5,\n", - " 'unit_cost': 3788870\n", - " },\n", - " \n", - " 'transition_piece': {\n", - " 'deck_space': 108.9,\n", - " 'mass': 762.6,\n", - " 'unit_cost': 3431557\n", - " }\n", - "}\n", - "\n", - "module = MonopileInstallation(config)\n", - "module.run()\n", - "\n", - "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Simulation Logs" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# To import an installation module:\n", + "from ORBIT.phases.install import MonopileInstallation" + ] + }, { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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_height
01.0WTIVMobilize168.0000001260000.00ACTION0.000000Monopile InstallationNaNNaN
1NaNWTIVFasten Monopile12.00000090000.00ACTION12.000000Monopile Installation25.0120.0
2NaNWTIVFasten Transition Piece8.00000060000.00ACTION20.000000Monopile Installation25.0120.0
3NaNWTIVFasten Monopile12.00000090000.00ACTION32.000000Monopile Installation25.0120.0
4NaNWTIVFasten Transition Piece8.00000060000.00ACTION40.000000Monopile Installation25.0120.0
5NaNWTIVFasten Monopile12.00000090000.00ACTION52.000000Monopile Installation25.0120.0
6NaNWTIVFasten Transition Piece8.00000060000.00ACTION60.000000Monopile Installation25.0120.0
7NaNWTIVFasten Monopile12.00000090000.00ACTION72.000000Monopile Installation25.0120.0
8NaNWTIVFasten Transition Piece8.00000060000.00ACTION80.000000Monopile Installation25.0120.0
9NaNWTIVTransit5.00000037500.00ACTION85.000000Monopile InstallationNaNNaN
10NaNWTIVPosition Onsite2.00000015000.00ACTION87.000000Monopile InstallationNaNNaN
11NaNWTIVJackup0.3333332500.00ACTION87.333333Monopile Installation25.0120.0
12NaNWTIVRovSurvey1.0000007500.00ACTION88.333333Monopile Installation25.0120.0
13NaNWTIVRelease Monopile3.00000022500.00ACTION91.333333Monopile InstallationNaNNaN
14NaNWTIVUpend Monopile0.7210005407.50ACTION92.054333Monopile Installation25.0120.0
15NaNWTIVLower Monopile0.00350026.25ACTION92.057833Monopile Installation25.0120.0
16NaNWTIVCrane Reequip1.0000007500.00ACTION93.057833Monopile Installation25.0120.0
17NaNWTIVDrive Monopile1.50000011250.00ACTION94.557833Monopile Installation25.0120.0
18NaNWTIVRelease Transition Piece2.00000015000.00ACTION96.557833Monopile InstallationNaNNaN
19NaNWTIVCrane Reequip1.0000007500.00ACTION97.557833Monopile Installation25.0120.0
20NaNWTIVLower TP1.0000007500.00ACTION98.557833Monopile Installation25.0120.0
21NaNWTIVBolt TP4.00000030000.00ACTION102.557833Monopile Installation25.0120.0
22NaNWTIVJackdown0.3333332500.00ACTION102.891167Monopile Installation25.0120.0
23NaNWTIVPosition Onsite2.00000015000.00ACTION104.891167Monopile InstallationNaNNaN
24NaNWTIVJackup0.3333332500.00ACTION105.224500Monopile Installation25.0120.0
\n", - "
" + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'wtiv': 'dict | str',\n", + " 'feeder': 'dict | str (optional)',\n", + " 'num_feeders': 'int (optional)',\n", + " 'site': {'depth': 'm', 'distance': 'km'},\n", + " 'plant': {'num_turbines': 'int'},\n", + " 'turbine': {'hub_height': 'm'},\n", + " 'port': {'num_cranes': 'int (optional, default: 1)',\n", + " 'monthly_rate': 'USD/mo (optional)',\n", + " 'name': 'str (optional)'},\n", + " 'monopile': {'length': 'm',\n", + " 'diameter': 'm',\n", + " 'deck_space': 'm2',\n", + " 'mass': 't',\n", + " 'unit_cost': 'USD'},\n", + " 'transition_piece': {'deck_space': 'm2', 'mass': 't', 'unit_cost': 'USD'}}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action duration cost \\\n", - "0 1.0 WTIV Mobilize 168.000000 1260000.00 \n", - "1 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "2 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "3 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "4 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "5 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "6 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "7 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "8 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "9 NaN WTIV Transit 5.000000 37500.00 \n", - "10 NaN WTIV Position Onsite 2.000000 15000.00 \n", - "11 NaN WTIV Jackup 0.333333 2500.00 \n", - "12 NaN WTIV RovSurvey 1.000000 7500.00 \n", - "13 NaN WTIV Release Monopile 3.000000 22500.00 \n", - "14 NaN WTIV Upend Monopile 0.721000 5407.50 \n", - "15 NaN WTIV Lower Monopile 0.003500 26.25 \n", - "16 NaN WTIV Crane Reequip 1.000000 7500.00 \n", - "17 NaN WTIV Drive Monopile 1.500000 11250.00 \n", - "18 NaN WTIV Release Transition Piece 2.000000 15000.00 \n", - "19 NaN WTIV Crane Reequip 1.000000 7500.00 \n", - "20 NaN WTIV Lower TP 1.000000 7500.00 \n", - "21 NaN WTIV Bolt TP 4.000000 30000.00 \n", - "22 NaN WTIV Jackdown 0.333333 2500.00 \n", - "23 NaN WTIV Position Onsite 2.000000 15000.00 \n", - "24 NaN WTIV Jackup 0.333333 2500.00 \n", - "\n", - " level time phase site_depth hub_height \n", - "0 ACTION 0.000000 Monopile Installation NaN NaN \n", - "1 ACTION 12.000000 Monopile Installation 25.0 120.0 \n", - "2 ACTION 20.000000 Monopile Installation 25.0 120.0 \n", - "3 ACTION 32.000000 Monopile Installation 25.0 120.0 \n", - "4 ACTION 40.000000 Monopile Installation 25.0 120.0 \n", - "5 ACTION 52.000000 Monopile Installation 25.0 120.0 \n", - "6 ACTION 60.000000 Monopile Installation 25.0 120.0 \n", - "7 ACTION 72.000000 Monopile Installation 25.0 120.0 \n", - "8 ACTION 80.000000 Monopile Installation 25.0 120.0 \n", - "9 ACTION 85.000000 Monopile Installation NaN NaN \n", - "10 ACTION 87.000000 Monopile Installation NaN NaN \n", - "11 ACTION 87.333333 Monopile Installation 25.0 120.0 \n", - "12 ACTION 88.333333 Monopile Installation 25.0 120.0 \n", - "13 ACTION 91.333333 Monopile Installation NaN NaN \n", - "14 ACTION 92.054333 Monopile Installation 25.0 120.0 \n", - "15 ACTION 92.057833 Monopile Installation 25.0 120.0 \n", - "16 ACTION 93.057833 Monopile Installation 25.0 120.0 \n", - "17 ACTION 94.557833 Monopile Installation 25.0 120.0 \n", - "18 ACTION 96.557833 Monopile Installation NaN NaN \n", - "19 ACTION 97.557833 Monopile Installation 25.0 120.0 \n", - "20 ACTION 98.557833 Monopile Installation 25.0 120.0 \n", - "21 ACTION 102.557833 Monopile Installation 25.0 120.0 \n", - "22 ACTION 102.891167 Monopile Installation 25.0 120.0 \n", - "23 ACTION 104.891167 Monopile Installation NaN NaN \n", - "24 ACTION 105.224500 Monopile Installation 25.0 120.0 " + "source": [ + "# Expected config:\n", + "MonopileInstallation.expected_config" ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The logs of all simulation steps taken by the vessel(s) are stored and available for analysis.\n", - "\n", - "# The following code returns a list of all actions with the associated agent (vessel), duration, cost, and time completed.\n", - "# Once we configure a weather file, this will also include any accrued weather delays.\n", - "\n", - "import pandas as pd\n", - "\n", - "df = pd.DataFrame(module.env.actions)\n", - "df.head(25)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Inlcude Weather" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "config_unfilled = {\n", + " 'site': { # Similar to the design module, inputs are grouped by category\n", + " 'depth': 'm', # Many of the inputs required are the same as the design module\n", + " 'distance': 'km'\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 'int'\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'hub_height': 'm'\n", + " },\n", + " \n", + " 'wtiv': 'dict | str', # The WTIV that will be installing the monopiles.\n", + " # Vessel are defined in the library in .yaml files.\n", + " \n", + " 'monopile': { # Notice that the result of the last module (monopile + transition piece sizing)\n", + " 'length': 'm', # is an input into the installation module.\n", + " 'diameter': 'm',\n", + " 'deck_space': 'm2',\n", + " 'mass': 't',\n", + " 'unit_cost': 'USD'\n", + " },\n", + " \n", + " 'transition_piece': {\n", + " 'deck_space': 'm2',\n", + " 'mass': 't',\n", + " 'unit_cost': 'USD'\n", + " }\n", + "}" + ] + }, { - "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", - "
windspeedwaveheight
datetime
2009-10-21 23:00:005.0752260.59
2009-10-22 00:00:005.4384000.65
2009-10-22 01:00:004.9470520.55
2009-10-22 02:00:004.3671950.57
2009-10-22 03:00:004.1352620.49
.........
2013-12-31 19:00:009.6041720.97
2013-12-31 20:00:009.8941040.97
2013-12-31 21:00:009.9093630.98
2013-12-31 22:00:0011.8564381.13
2013-12-31 23:00:0012.3691481.53
\n", - "

36769 rows × 2 columns

\n", - "
" + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 21.94 M\n" + ] + } ], - "text/plain": [ - " windspeed waveheight\n", - "datetime \n", - "2009-10-21 23:00:00 5.075226 0.59\n", - "2009-10-22 00:00:00 5.438400 0.65\n", - "2009-10-22 01:00:00 4.947052 0.55\n", - "2009-10-22 02:00:00 4.367195 0.57\n", - "2009-10-22 03:00:00 4.135262 0.49\n", - "... ... ...\n", - "2013-12-31 19:00:00 9.604172 0.97\n", - "2013-12-31 20:00:00 9.894104 0.97\n", - "2013-12-31 21:00:00 9.909363 0.98\n", - "2013-12-31 22:00:00 11.856438 1.13\n", - "2013-12-31 23:00:00 12.369148 1.53\n", - "\n", - "[36769 rows x 2 columns]" + "source": [ + "config = {\n", + " 'site': {\n", + " 'depth': 25,\n", + " 'distance': 50\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 50\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'hub_height': 120\n", + " },\n", + " \n", + " 'wtiv': 'example_wtiv', # See 'example_wtiv.yaml'\n", + " \n", + " 'monopile': {\n", + " 'length': 72.1,\n", + " 'diameter': 10.2,\n", + " 'deck_space': 104.4,\n", + " 'mass': 1082.5,\n", + " 'unit_cost': 3788870\n", + " },\n", + " \n", + " 'transition_piece': {\n", + " 'deck_space': 108.9,\n", + " 'mass': 762.6,\n", + " 'unit_cost': 3431557\n", + " }\n", + "}\n", + "\n", + "module = MonopileInstallation(config)\n", + "module.run()\n", + "\n", + "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Weather data can be loaded and included in the simulation. Each action can have associated weather\n", - "# constraints (eg. windspeed < 15 m/s, sig. waveheight < 2.5). As the simulation progresses, each action\n", - "# checks that it can proceed given the weather forecast. If the constraints are not met, the agent will\n", - "# accrue weather delays until they are.\n", - "\n", - "# To load a weather file:\n", - "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=['datetime']).set_index(\"datetime\")\n", - "weather" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 27.95 M\n" - ] - } - ], - "source": [ - "# To include weather in the simulation, pass it into the 'weather' keyword:\n", - "\n", - "module = MonopileInstallation(config, weather=weather)\n", - "module.run()\n", - "\n", - "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simulation Logs" + ] + }, { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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_height
01.0WTIVMobilize168.0000001260000.00ACTION0.000000Monopile InstallationNaNNaN
1NaNWTIVFasten Monopile12.00000090000.00ACTION12.000000Monopile Installation25.0120.0
2NaNWTIVFasten Transition Piece8.00000060000.00ACTION20.000000Monopile Installation25.0120.0
3NaNWTIVFasten Monopile12.00000090000.00ACTION32.000000Monopile Installation25.0120.0
4NaNWTIVFasten Transition Piece8.00000060000.00ACTION40.000000Monopile Installation25.0120.0
5NaNWTIVFasten Monopile12.00000090000.00ACTION52.000000Monopile Installation25.0120.0
6NaNWTIVFasten Transition Piece8.00000060000.00ACTION60.000000Monopile Installation25.0120.0
7NaNWTIVDelay29.000000217500.00ACTION89.000000Monopile Installation25.0120.0
8NaNWTIVFasten Monopile12.00000090000.00ACTION101.000000Monopile Installation25.0120.0
9NaNWTIVFasten Transition Piece8.00000060000.00ACTION109.000000Monopile Installation25.0120.0
10NaNWTIVTransit5.00000037500.00ACTION114.000000Monopile InstallationNaNNaN
11NaNWTIVPosition Onsite2.00000015000.00ACTION116.000000Monopile InstallationNaNNaN
12NaNWTIVJackup0.3333332500.00ACTION116.333333Monopile Installation25.0120.0
13NaNWTIVRovSurvey1.0000007500.00ACTION117.333333Monopile Installation25.0120.0
14NaNWTIVRelease Monopile3.00000022500.00ACTION120.333333Monopile InstallationNaNNaN
15NaNWTIVUpend Monopile0.7210005407.50ACTION121.054333Monopile Installation25.0120.0
16NaNWTIVLower Monopile0.00350026.25ACTION121.057833Monopile Installation25.0120.0
17NaNWTIVCrane Reequip1.0000007500.00ACTION122.057833Monopile Installation25.0120.0
18NaNWTIVDrive Monopile1.50000011250.00ACTION123.557833Monopile Installation25.0120.0
19NaNWTIVRelease Transition Piece2.00000015000.00ACTION125.557833Monopile InstallationNaNNaN
20NaNWTIVCrane Reequip1.0000007500.00ACTION126.557833Monopile Installation25.0120.0
21NaNWTIVLower TP1.0000007500.00ACTION127.557833Monopile Installation25.0120.0
22NaNWTIVBolt TP4.00000030000.00ACTION131.557833Monopile Installation25.0120.0
23NaNWTIVJackdown0.3333332500.00ACTION131.891167Monopile Installation25.0120.0
24NaNWTIVPosition Onsite2.00000015000.00ACTION133.891167Monopile InstallationNaNNaN
\n", - "
" + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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_height
01.0WTIVMobilize168.0000001260000.00ACTION0.000000Monopile InstallationNaNNaN
1NaNWTIVFasten Monopile12.00000090000.00ACTION12.000000Monopile Installation25.0120.0
2NaNWTIVFasten Transition Piece8.00000060000.00ACTION20.000000Monopile Installation25.0120.0
3NaNWTIVFasten Monopile12.00000090000.00ACTION32.000000Monopile Installation25.0120.0
4NaNWTIVFasten Transition Piece8.00000060000.00ACTION40.000000Monopile Installation25.0120.0
5NaNWTIVFasten Monopile12.00000090000.00ACTION52.000000Monopile Installation25.0120.0
6NaNWTIVFasten Transition Piece8.00000060000.00ACTION60.000000Monopile Installation25.0120.0
7NaNWTIVFasten Monopile12.00000090000.00ACTION72.000000Monopile Installation25.0120.0
8NaNWTIVFasten Transition Piece8.00000060000.00ACTION80.000000Monopile Installation25.0120.0
9NaNWTIVTransit5.00000037500.00ACTION85.000000Monopile InstallationNaNNaN
10NaNWTIVPosition Onsite2.00000015000.00ACTION87.000000Monopile InstallationNaNNaN
11NaNWTIVJackup0.3333332500.00ACTION87.333333Monopile Installation25.0120.0
12NaNWTIVRovSurvey1.0000007500.00ACTION88.333333Monopile Installation25.0120.0
13NaNWTIVRelease Monopile3.00000022500.00ACTION91.333333Monopile InstallationNaNNaN
14NaNWTIVUpend Monopile0.7210005407.50ACTION92.054333Monopile Installation25.0120.0
15NaNWTIVLower Monopile0.00350026.25ACTION92.057833Monopile Installation25.0120.0
16NaNWTIVCrane Reequip1.0000007500.00ACTION93.057833Monopile Installation25.0120.0
17NaNWTIVDrive Monopile1.50000011250.00ACTION94.557833Monopile Installation25.0120.0
18NaNWTIVRelease Transition Piece2.00000015000.00ACTION96.557833Monopile InstallationNaNNaN
19NaNWTIVCrane Reequip1.0000007500.00ACTION97.557833Monopile Installation25.0120.0
20NaNWTIVLower TP1.0000007500.00ACTION98.557833Monopile Installation25.0120.0
21NaNWTIVBolt TP4.00000030000.00ACTION102.557833Monopile Installation25.0120.0
22NaNWTIVJackdown0.3333332500.00ACTION102.891167Monopile Installation25.0120.0
23NaNWTIVPosition Onsite2.00000015000.00ACTION104.891167Monopile InstallationNaNNaN
24NaNWTIVJackup0.3333332500.00ACTION105.224500Monopile Installation25.0120.0
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration cost \\\n", + "0 1.0 WTIV Mobilize 168.000000 1260000.00 \n", + "1 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "2 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "3 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "4 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "5 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "6 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "7 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "8 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "9 NaN WTIV Transit 5.000000 37500.00 \n", + "10 NaN WTIV Position Onsite 2.000000 15000.00 \n", + "11 NaN WTIV Jackup 0.333333 2500.00 \n", + "12 NaN WTIV RovSurvey 1.000000 7500.00 \n", + "13 NaN WTIV Release Monopile 3.000000 22500.00 \n", + "14 NaN WTIV Upend Monopile 0.721000 5407.50 \n", + "15 NaN WTIV Lower Monopile 0.003500 26.25 \n", + "16 NaN WTIV Crane Reequip 1.000000 7500.00 \n", + "17 NaN WTIV Drive Monopile 1.500000 11250.00 \n", + "18 NaN WTIV Release Transition Piece 2.000000 15000.00 \n", + "19 NaN WTIV Crane Reequip 1.000000 7500.00 \n", + "20 NaN WTIV Lower TP 1.000000 7500.00 \n", + "21 NaN WTIV Bolt TP 4.000000 30000.00 \n", + "22 NaN WTIV Jackdown 0.333333 2500.00 \n", + "23 NaN WTIV Position Onsite 2.000000 15000.00 \n", + "24 NaN WTIV Jackup 0.333333 2500.00 \n", + "\n", + " level time phase site_depth hub_height \n", + "0 ACTION 0.000000 Monopile Installation NaN NaN \n", + "1 ACTION 12.000000 Monopile Installation 25.0 120.0 \n", + "2 ACTION 20.000000 Monopile Installation 25.0 120.0 \n", + "3 ACTION 32.000000 Monopile Installation 25.0 120.0 \n", + "4 ACTION 40.000000 Monopile Installation 25.0 120.0 \n", + "5 ACTION 52.000000 Monopile Installation 25.0 120.0 \n", + "6 ACTION 60.000000 Monopile Installation 25.0 120.0 \n", + "7 ACTION 72.000000 Monopile Installation 25.0 120.0 \n", + "8 ACTION 80.000000 Monopile Installation 25.0 120.0 \n", + "9 ACTION 85.000000 Monopile Installation NaN NaN \n", + "10 ACTION 87.000000 Monopile Installation NaN NaN \n", + "11 ACTION 87.333333 Monopile Installation 25.0 120.0 \n", + "12 ACTION 88.333333 Monopile Installation 25.0 120.0 \n", + "13 ACTION 91.333333 Monopile Installation NaN NaN \n", + "14 ACTION 92.054333 Monopile Installation 25.0 120.0 \n", + "15 ACTION 92.057833 Monopile Installation 25.0 120.0 \n", + "16 ACTION 93.057833 Monopile Installation 25.0 120.0 \n", + "17 ACTION 94.557833 Monopile Installation 25.0 120.0 \n", + "18 ACTION 96.557833 Monopile Installation NaN NaN \n", + "19 ACTION 97.557833 Monopile Installation 25.0 120.0 \n", + "20 ACTION 98.557833 Monopile Installation 25.0 120.0 \n", + "21 ACTION 102.557833 Monopile Installation 25.0 120.0 \n", + "22 ACTION 102.891167 Monopile Installation 25.0 120.0 \n", + "23 ACTION 104.891167 Monopile Installation NaN NaN \n", + "24 ACTION 105.224500 Monopile Installation 25.0 120.0 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action duration cost \\\n", - "0 1.0 WTIV Mobilize 168.000000 1260000.00 \n", - "1 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "2 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "3 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "4 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "5 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "6 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "7 NaN WTIV Delay 29.000000 217500.00 \n", - "8 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", - "9 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", - "10 NaN WTIV Transit 5.000000 37500.00 \n", - "11 NaN WTIV Position Onsite 2.000000 15000.00 \n", - "12 NaN WTIV Jackup 0.333333 2500.00 \n", - "13 NaN WTIV RovSurvey 1.000000 7500.00 \n", - "14 NaN WTIV Release Monopile 3.000000 22500.00 \n", - "15 NaN WTIV Upend Monopile 0.721000 5407.50 \n", - "16 NaN WTIV Lower Monopile 0.003500 26.25 \n", - "17 NaN WTIV Crane Reequip 1.000000 7500.00 \n", - "18 NaN WTIV Drive Monopile 1.500000 11250.00 \n", - "19 NaN WTIV Release Transition Piece 2.000000 15000.00 \n", - "20 NaN WTIV Crane Reequip 1.000000 7500.00 \n", - "21 NaN WTIV Lower TP 1.000000 7500.00 \n", - "22 NaN WTIV Bolt TP 4.000000 30000.00 \n", - "23 NaN WTIV Jackdown 0.333333 2500.00 \n", - "24 NaN WTIV Position Onsite 2.000000 15000.00 \n", - "\n", - " level time phase site_depth hub_height \n", - "0 ACTION 0.000000 Monopile Installation NaN NaN \n", - "1 ACTION 12.000000 Monopile Installation 25.0 120.0 \n", - "2 ACTION 20.000000 Monopile Installation 25.0 120.0 \n", - "3 ACTION 32.000000 Monopile Installation 25.0 120.0 \n", - "4 ACTION 40.000000 Monopile Installation 25.0 120.0 \n", - "5 ACTION 52.000000 Monopile Installation 25.0 120.0 \n", - "6 ACTION 60.000000 Monopile Installation 25.0 120.0 \n", - "7 ACTION 89.000000 Monopile Installation 25.0 120.0 \n", - "8 ACTION 101.000000 Monopile Installation 25.0 120.0 \n", - "9 ACTION 109.000000 Monopile Installation 25.0 120.0 \n", - "10 ACTION 114.000000 Monopile Installation NaN NaN \n", - "11 ACTION 116.000000 Monopile Installation NaN NaN \n", - "12 ACTION 116.333333 Monopile Installation 25.0 120.0 \n", - "13 ACTION 117.333333 Monopile Installation 25.0 120.0 \n", - "14 ACTION 120.333333 Monopile Installation NaN NaN \n", - "15 ACTION 121.054333 Monopile Installation 25.0 120.0 \n", - "16 ACTION 121.057833 Monopile Installation 25.0 120.0 \n", - "17 ACTION 122.057833 Monopile Installation 25.0 120.0 \n", - "18 ACTION 123.557833 Monopile Installation 25.0 120.0 \n", - "19 ACTION 125.557833 Monopile Installation NaN NaN \n", - "20 ACTION 126.557833 Monopile Installation 25.0 120.0 \n", - "21 ACTION 127.557833 Monopile Installation 25.0 120.0 \n", - "22 ACTION 131.557833 Monopile Installation 25.0 120.0 \n", - "23 ACTION 131.891167 Monopile Installation 25.0 120.0 \n", - "24 ACTION 133.891167 Monopile Installation NaN NaN " + "source": [ + "# The logs of all simulation steps taken by the vessel(s) are stored and available for analysis.\n", + "\n", + "# The following code returns a list of all actions with the associated agent (vessel), duration, cost, and time completed.\n", + "# Once we configure a weather file, this will also include any accrued weather delays.\n", + "\n", + "import pandas as pd\n", + "\n", + "df = pd.DataFrame(module.env.actions)\n", + "df.head(25)" ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.DataFrame(module.env.actions)\n", - "df.head(25) # Note the weather delay on line 7" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Including Feeder Barges" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 23.02 M\n" - ] - } - ], - "source": [ - "# The MonopileInstallation module can also be configured to use a WTIV + Feeder Barge installation strategy.\n", - "# To configure this module to use feeder barges, add the 'num_feeders' and 'feeder' input to the config:\n", - "\n", - "config = {\n", - " 'site': {\n", - " 'depth': 25,\n", - " 'distance': 50\n", - " },\n", - " \n", - " 'plant': {\n", - " 'num_turbines': 50\n", - " },\n", - " \n", - " 'turbine': {\n", - " 'hub_height': 120\n", - " },\n", - " \n", - " # --- Vessels ---\n", - " 'wtiv': 'example_wtiv',\n", - " 'feeder': 'example_feeder',\n", - " 'num_feeders': 2,\n", - " \n", - " 'monopile': {\n", - " 'length': 72.1,\n", - " 'diameter': 10.2,\n", - " 'deck_space': 104.4,\n", - " 'mass': 1082.5,\n", - " 'unit_cost': 3788870\n", - " },\n", - " \n", - " 'transition_piece': {\n", - " 'deck_space': 108.9,\n", - " 'mass': 762.6,\n", - " 'unit_cost': 3431557\n", - " }\n", - "}\n", - "\n", - "module = MonopileInstallation(config)\n", - "module.run()\n", - "\n", - "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Inlcude Weather" + ] + }, { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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_multiplieragentactiondurationcostleveltimephaselocationsite_depth
01.0WTIVMobilize168.0000001.260000e+06ACTION0.000000Monopile InstallationNaNNaN
10.5Feeder 0Mobilize72.0000001.125000e+05ACTION0.000000Monopile InstallationNaNNaN
20.5Feeder 1Mobilize72.0000001.125000e+05ACTION0.000000Monopile InstallationNaNNaN
3NaNWTIVTransit5.0000003.750000e+04ACTION5.000000Monopile InstallationNaNNaN
4NaNFeeder 0Fasten Monopile12.0000003.750000e+04ACTION12.000000Monopile InstallationNaNNaN
5NaNFeeder 0Fasten Transition Piece8.0000002.500000e+04ACTION20.000000Monopile InstallationNaNNaN
6NaNFeeder 1Queue20.0000006.250000e+04ACTION20.000000Monopile InstallationNaNNaN
7NaNFeeder 0Transit8.3333332.604167e+04ACTION28.333333Monopile InstallationNaNNaN
8NaNFeeder 0Jackup1.6666675.208333e+03ACTION30.000000Monopile InstallationNaNNaN
9NaNWTIVDelay25.0000001.875000e+05ACTION30.000000Monopile InstallationSiteNaN
10NaNFeeder 1Fasten Monopile12.0000003.750000e+04ACTION32.000000Monopile InstallationNaNNaN
11NaNWTIVPosition Onsite2.0000001.500000e+04ACTION32.000000Monopile InstallationNaNNaN
12NaNWTIVJackup0.3333332.500000e+03ACTION32.333333Monopile InstallationNaN25.0
13NaNWTIVRovSurvey1.0000007.500000e+03ACTION33.333333Monopile InstallationNaN25.0
14NaNWTIVRelease Monopile3.0000002.250000e+04ACTION36.333333Monopile InstallationNaNNaN
15NaNWTIVUpend Monopile0.7210005.407500e+03ACTION37.054333Monopile InstallationNaN25.0
16NaNWTIVLower Monopile0.0035002.625000e+01ACTION37.057833Monopile InstallationNaN25.0
17NaNWTIVCrane Reequip1.0000007.500000e+03ACTION38.057833Monopile InstallationNaN25.0
18NaNWTIVDrive Monopile1.5000001.125000e+04ACTION39.557833Monopile InstallationNaN25.0
19NaNFeeder 1Fasten Transition Piece8.0000002.500000e+04ACTION40.000000Monopile InstallationNaNNaN
20NaNWTIVRelease Transition Piece2.0000001.500000e+04ACTION41.557833Monopile InstallationNaNNaN
21NaNFeeder 0ActiveFeeder11.5578333.611823e+04ACTION41.557833Monopile InstallationSiteNaN
22NaNWTIVCrane Reequip1.0000007.500000e+03ACTION42.557833Monopile InstallationNaN25.0
23NaNFeeder 0Jackdown1.6666675.208333e+03ACTION43.224500Monopile InstallationNaNNaN
24NaNWTIVLower TP1.0000007.500000e+03ACTION43.557833Monopile InstallationNaN25.0
\n", - "
" + "cell_type": "code", + "execution_count": 21, + "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", + "
windspeedwaveheight
datetime
2009-10-21 23:00:005.0752260.59
2009-10-22 00:00:005.4384000.65
2009-10-22 01:00:004.9470520.55
2009-10-22 02:00:004.3671950.57
2009-10-22 03:00:004.1352620.49
.........
2013-12-31 19:00:009.6041720.97
2013-12-31 20:00:009.8941040.97
2013-12-31 21:00:009.9093630.98
2013-12-31 22:00:0011.8564381.13
2013-12-31 23:00:0012.3691481.53
\n", + "

36769 rows \u00d7 2 columns

\n", + "
" + ], + "text/plain": [ + " windspeed waveheight\n", + "datetime \n", + "2009-10-21 23:00:00 5.075226 0.59\n", + "2009-10-22 00:00:00 5.438400 0.65\n", + "2009-10-22 01:00:00 4.947052 0.55\n", + "2009-10-22 02:00:00 4.367195 0.57\n", + "2009-10-22 03:00:00 4.135262 0.49\n", + "... ... ...\n", + "2013-12-31 19:00:00 9.604172 0.97\n", + "2013-12-31 20:00:00 9.894104 0.97\n", + "2013-12-31 21:00:00 9.909363 0.98\n", + "2013-12-31 22:00:00 11.856438 1.13\n", + "2013-12-31 23:00:00 12.369148 1.53\n", + "\n", + "[36769 rows x 2 columns]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action duration \\\n", - "0 1.0 WTIV Mobilize 168.000000 \n", - "1 0.5 Feeder 0 Mobilize 72.000000 \n", - "2 0.5 Feeder 1 Mobilize 72.000000 \n", - "3 NaN WTIV Transit 5.000000 \n", - "4 NaN Feeder 0 Fasten Monopile 12.000000 \n", - "5 NaN Feeder 0 Fasten Transition Piece 8.000000 \n", - "6 NaN Feeder 1 Queue 20.000000 \n", - "7 NaN Feeder 0 Transit 8.333333 \n", - "8 NaN Feeder 0 Jackup 1.666667 \n", - "9 NaN WTIV Delay 25.000000 \n", - "10 NaN Feeder 1 Fasten Monopile 12.000000 \n", - "11 NaN WTIV Position Onsite 2.000000 \n", - "12 NaN WTIV Jackup 0.333333 \n", - "13 NaN WTIV RovSurvey 1.000000 \n", - "14 NaN WTIV Release Monopile 3.000000 \n", - "15 NaN WTIV Upend Monopile 0.721000 \n", - "16 NaN WTIV Lower Monopile 0.003500 \n", - "17 NaN WTIV Crane Reequip 1.000000 \n", - "18 NaN WTIV Drive Monopile 1.500000 \n", - "19 NaN Feeder 1 Fasten Transition Piece 8.000000 \n", - "20 NaN WTIV Release Transition Piece 2.000000 \n", - "21 NaN Feeder 0 ActiveFeeder 11.557833 \n", - "22 NaN WTIV Crane Reequip 1.000000 \n", - "23 NaN Feeder 0 Jackdown 1.666667 \n", - "24 NaN WTIV Lower TP 1.000000 \n", - "\n", - " cost level time phase location \\\n", - "0 1.260000e+06 ACTION 0.000000 Monopile Installation NaN \n", - "1 1.125000e+05 ACTION 0.000000 Monopile Installation NaN \n", - "2 1.125000e+05 ACTION 0.000000 Monopile Installation NaN \n", - "3 3.750000e+04 ACTION 5.000000 Monopile Installation NaN \n", - "4 3.750000e+04 ACTION 12.000000 Monopile Installation NaN \n", - "5 2.500000e+04 ACTION 20.000000 Monopile Installation NaN \n", - "6 6.250000e+04 ACTION 20.000000 Monopile Installation NaN \n", - "7 2.604167e+04 ACTION 28.333333 Monopile Installation NaN \n", - "8 5.208333e+03 ACTION 30.000000 Monopile Installation NaN \n", - "9 1.875000e+05 ACTION 30.000000 Monopile Installation Site \n", - "10 3.750000e+04 ACTION 32.000000 Monopile Installation NaN \n", - "11 1.500000e+04 ACTION 32.000000 Monopile Installation NaN \n", - "12 2.500000e+03 ACTION 32.333333 Monopile Installation NaN \n", - "13 7.500000e+03 ACTION 33.333333 Monopile Installation NaN \n", - "14 2.250000e+04 ACTION 36.333333 Monopile Installation NaN \n", - "15 5.407500e+03 ACTION 37.054333 Monopile Installation NaN \n", - "16 2.625000e+01 ACTION 37.057833 Monopile Installation NaN \n", - "17 7.500000e+03 ACTION 38.057833 Monopile Installation NaN \n", - "18 1.125000e+04 ACTION 39.557833 Monopile Installation NaN \n", - "19 2.500000e+04 ACTION 40.000000 Monopile Installation NaN \n", - "20 1.500000e+04 ACTION 41.557833 Monopile Installation NaN \n", - "21 3.611823e+04 ACTION 41.557833 Monopile Installation Site \n", - "22 7.500000e+03 ACTION 42.557833 Monopile Installation NaN \n", - "23 5.208333e+03 ACTION 43.224500 Monopile Installation NaN \n", - "24 7.500000e+03 ACTION 43.557833 Monopile Installation NaN \n", - "\n", - " site_depth \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - "5 NaN \n", - "6 NaN \n", - "7 NaN \n", - "8 NaN \n", - "9 NaN \n", - "10 NaN \n", - "11 NaN \n", - "12 25.0 \n", - "13 25.0 \n", - "14 NaN \n", - "15 25.0 \n", - "16 25.0 \n", - "17 25.0 \n", - "18 25.0 \n", - "19 NaN \n", - "20 NaN \n", - "21 NaN \n", - "22 25.0 \n", - "23 NaN \n", - "24 25.0 " + "source": [ + "# Weather data can be loaded and included in the simulation. Each action can have associated weather\n", + "# constraints (eg. windspeed < 15 m/s, sig. waveheight < 2.5). As the simulation progresses, each action\n", + "# checks that it can proceed given the weather forecast. If the constraints are not met, the agent will\n", + "# accrue weather delays until they are.\n", + "\n", + "# To load a weather file:\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=['datetime']).set_index(\"datetime\")\n", + "weather" ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 27.95 M\n" + ] + } + ], + "source": [ + "# To include weather in the simulation, pass it into the 'weather' keyword:\n", + "\n", + "module = MonopileInstallation(config, weather=weather)\n", + "module.run()\n", + "\n", + "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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_height
01.0WTIVMobilize168.0000001260000.00ACTION0.000000Monopile InstallationNaNNaN
1NaNWTIVFasten Monopile12.00000090000.00ACTION12.000000Monopile Installation25.0120.0
2NaNWTIVFasten Transition Piece8.00000060000.00ACTION20.000000Monopile Installation25.0120.0
3NaNWTIVFasten Monopile12.00000090000.00ACTION32.000000Monopile Installation25.0120.0
4NaNWTIVFasten Transition Piece8.00000060000.00ACTION40.000000Monopile Installation25.0120.0
5NaNWTIVFasten Monopile12.00000090000.00ACTION52.000000Monopile Installation25.0120.0
6NaNWTIVFasten Transition Piece8.00000060000.00ACTION60.000000Monopile Installation25.0120.0
7NaNWTIVDelay29.000000217500.00ACTION89.000000Monopile Installation25.0120.0
8NaNWTIVFasten Monopile12.00000090000.00ACTION101.000000Monopile Installation25.0120.0
9NaNWTIVFasten Transition Piece8.00000060000.00ACTION109.000000Monopile Installation25.0120.0
10NaNWTIVTransit5.00000037500.00ACTION114.000000Monopile InstallationNaNNaN
11NaNWTIVPosition Onsite2.00000015000.00ACTION116.000000Monopile InstallationNaNNaN
12NaNWTIVJackup0.3333332500.00ACTION116.333333Monopile Installation25.0120.0
13NaNWTIVRovSurvey1.0000007500.00ACTION117.333333Monopile Installation25.0120.0
14NaNWTIVRelease Monopile3.00000022500.00ACTION120.333333Monopile InstallationNaNNaN
15NaNWTIVUpend Monopile0.7210005407.50ACTION121.054333Monopile Installation25.0120.0
16NaNWTIVLower Monopile0.00350026.25ACTION121.057833Monopile Installation25.0120.0
17NaNWTIVCrane Reequip1.0000007500.00ACTION122.057833Monopile Installation25.0120.0
18NaNWTIVDrive Monopile1.50000011250.00ACTION123.557833Monopile Installation25.0120.0
19NaNWTIVRelease Transition Piece2.00000015000.00ACTION125.557833Monopile InstallationNaNNaN
20NaNWTIVCrane Reequip1.0000007500.00ACTION126.557833Monopile Installation25.0120.0
21NaNWTIVLower TP1.0000007500.00ACTION127.557833Monopile Installation25.0120.0
22NaNWTIVBolt TP4.00000030000.00ACTION131.557833Monopile Installation25.0120.0
23NaNWTIVJackdown0.3333332500.00ACTION131.891167Monopile Installation25.0120.0
24NaNWTIVPosition Onsite2.00000015000.00ACTION133.891167Monopile InstallationNaNNaN
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration cost \\\n", + "0 1.0 WTIV Mobilize 168.000000 1260000.00 \n", + "1 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "2 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "3 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "4 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "5 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "6 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "7 NaN WTIV Delay 29.000000 217500.00 \n", + "8 NaN WTIV Fasten Monopile 12.000000 90000.00 \n", + "9 NaN WTIV Fasten Transition Piece 8.000000 60000.00 \n", + "10 NaN WTIV Transit 5.000000 37500.00 \n", + "11 NaN WTIV Position Onsite 2.000000 15000.00 \n", + "12 NaN WTIV Jackup 0.333333 2500.00 \n", + "13 NaN WTIV RovSurvey 1.000000 7500.00 \n", + "14 NaN WTIV Release Monopile 3.000000 22500.00 \n", + "15 NaN WTIV Upend Monopile 0.721000 5407.50 \n", + "16 NaN WTIV Lower Monopile 0.003500 26.25 \n", + "17 NaN WTIV Crane Reequip 1.000000 7500.00 \n", + "18 NaN WTIV Drive Monopile 1.500000 11250.00 \n", + "19 NaN WTIV Release Transition Piece 2.000000 15000.00 \n", + "20 NaN WTIV Crane Reequip 1.000000 7500.00 \n", + "21 NaN WTIV Lower TP 1.000000 7500.00 \n", + "22 NaN WTIV Bolt TP 4.000000 30000.00 \n", + "23 NaN WTIV Jackdown 0.333333 2500.00 \n", + "24 NaN WTIV Position Onsite 2.000000 15000.00 \n", + "\n", + " level time phase site_depth hub_height \n", + "0 ACTION 0.000000 Monopile Installation NaN NaN \n", + "1 ACTION 12.000000 Monopile Installation 25.0 120.0 \n", + "2 ACTION 20.000000 Monopile Installation 25.0 120.0 \n", + "3 ACTION 32.000000 Monopile Installation 25.0 120.0 \n", + "4 ACTION 40.000000 Monopile Installation 25.0 120.0 \n", + "5 ACTION 52.000000 Monopile Installation 25.0 120.0 \n", + "6 ACTION 60.000000 Monopile Installation 25.0 120.0 \n", + "7 ACTION 89.000000 Monopile Installation 25.0 120.0 \n", + "8 ACTION 101.000000 Monopile Installation 25.0 120.0 \n", + "9 ACTION 109.000000 Monopile Installation 25.0 120.0 \n", + "10 ACTION 114.000000 Monopile Installation NaN NaN \n", + "11 ACTION 116.000000 Monopile Installation NaN NaN \n", + "12 ACTION 116.333333 Monopile Installation 25.0 120.0 \n", + "13 ACTION 117.333333 Monopile Installation 25.0 120.0 \n", + "14 ACTION 120.333333 Monopile Installation NaN NaN \n", + "15 ACTION 121.054333 Monopile Installation 25.0 120.0 \n", + "16 ACTION 121.057833 Monopile Installation 25.0 120.0 \n", + "17 ACTION 122.057833 Monopile Installation 25.0 120.0 \n", + "18 ACTION 123.557833 Monopile Installation 25.0 120.0 \n", + "19 ACTION 125.557833 Monopile Installation NaN NaN \n", + "20 ACTION 126.557833 Monopile Installation 25.0 120.0 \n", + "21 ACTION 127.557833 Monopile Installation 25.0 120.0 \n", + "22 ACTION 131.557833 Monopile Installation 25.0 120.0 \n", + "23 ACTION 131.891167 Monopile Installation 25.0 120.0 \n", + "24 ACTION 133.891167 Monopile Installation NaN NaN " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(module.env.actions)\n", + "df.head(25) # Note the weather delay on line 7" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Including Feeder Barges" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 23.02 M\n" + ] + } + ], + "source": [ + "# The MonopileInstallation module can also be configured to use a WTIV + Feeder Barge installation strategy.\n", + "# To configure this module to use feeder barges, add the 'num_feeders' and 'feeder' input to the config:\n", + "\n", + "config = {\n", + " 'site': {\n", + " 'depth': 25,\n", + " 'distance': 50\n", + " },\n", + " \n", + " 'plant': {\n", + " 'num_turbines': 50\n", + " },\n", + " \n", + " 'turbine': {\n", + " 'hub_height': 120\n", + " },\n", + " \n", + " # --- Vessels ---\n", + " 'wtiv': 'example_wtiv',\n", + " 'feeder': 'example_feeder',\n", + " 'num_feeders': 2,\n", + " \n", + " 'monopile': {\n", + " 'length': 72.1,\n", + " 'diameter': 10.2,\n", + " 'deck_space': 104.4,\n", + " 'mass': 1082.5,\n", + " 'unit_cost': 3788870\n", + " },\n", + " \n", + " 'transition_piece': {\n", + " 'deck_space': 108.9,\n", + " 'mass': 762.6,\n", + " 'unit_cost': 3431557\n", + " }\n", + "}\n", + "\n", + "module = MonopileInstallation(config)\n", + "module.run()\n", + "\n", + "print(f\"Installation CapEx: {module.installation_capex/1e6:.2f} M\")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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_multiplieragentactiondurationcostleveltimephaselocationsite_depth
01.0WTIVMobilize168.0000001.260000e+06ACTION0.000000Monopile InstallationNaNNaN
10.5Feeder 0Mobilize72.0000001.125000e+05ACTION0.000000Monopile InstallationNaNNaN
20.5Feeder 1Mobilize72.0000001.125000e+05ACTION0.000000Monopile InstallationNaNNaN
3NaNWTIVTransit5.0000003.750000e+04ACTION5.000000Monopile InstallationNaNNaN
4NaNFeeder 0Fasten Monopile12.0000003.750000e+04ACTION12.000000Monopile InstallationNaNNaN
5NaNFeeder 0Fasten Transition Piece8.0000002.500000e+04ACTION20.000000Monopile InstallationNaNNaN
6NaNFeeder 1Queue20.0000006.250000e+04ACTION20.000000Monopile InstallationNaNNaN
7NaNFeeder 0Transit8.3333332.604167e+04ACTION28.333333Monopile InstallationNaNNaN
8NaNFeeder 0Jackup1.6666675.208333e+03ACTION30.000000Monopile InstallationNaNNaN
9NaNWTIVDelay25.0000001.875000e+05ACTION30.000000Monopile InstallationSiteNaN
10NaNFeeder 1Fasten Monopile12.0000003.750000e+04ACTION32.000000Monopile InstallationNaNNaN
11NaNWTIVPosition Onsite2.0000001.500000e+04ACTION32.000000Monopile InstallationNaNNaN
12NaNWTIVJackup0.3333332.500000e+03ACTION32.333333Monopile InstallationNaN25.0
13NaNWTIVRovSurvey1.0000007.500000e+03ACTION33.333333Monopile InstallationNaN25.0
14NaNWTIVRelease Monopile3.0000002.250000e+04ACTION36.333333Monopile InstallationNaNNaN
15NaNWTIVUpend Monopile0.7210005.407500e+03ACTION37.054333Monopile InstallationNaN25.0
16NaNWTIVLower Monopile0.0035002.625000e+01ACTION37.057833Monopile InstallationNaN25.0
17NaNWTIVCrane Reequip1.0000007.500000e+03ACTION38.057833Monopile InstallationNaN25.0
18NaNWTIVDrive Monopile1.5000001.125000e+04ACTION39.557833Monopile InstallationNaN25.0
19NaNFeeder 1Fasten Transition Piece8.0000002.500000e+04ACTION40.000000Monopile InstallationNaNNaN
20NaNWTIVRelease Transition Piece2.0000001.500000e+04ACTION41.557833Monopile InstallationNaNNaN
21NaNFeeder 0ActiveFeeder11.5578333.611823e+04ACTION41.557833Monopile InstallationSiteNaN
22NaNWTIVCrane Reequip1.0000007.500000e+03ACTION42.557833Monopile InstallationNaN25.0
23NaNFeeder 0Jackdown1.6666675.208333e+03ACTION43.224500Monopile InstallationNaNNaN
24NaNWTIVLower TP1.0000007.500000e+03ACTION43.557833Monopile InstallationNaN25.0
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration \\\n", + "0 1.0 WTIV Mobilize 168.000000 \n", + "1 0.5 Feeder 0 Mobilize 72.000000 \n", + "2 0.5 Feeder 1 Mobilize 72.000000 \n", + "3 NaN WTIV Transit 5.000000 \n", + "4 NaN Feeder 0 Fasten Monopile 12.000000 \n", + "5 NaN Feeder 0 Fasten Transition Piece 8.000000 \n", + "6 NaN Feeder 1 Queue 20.000000 \n", + "7 NaN Feeder 0 Transit 8.333333 \n", + "8 NaN Feeder 0 Jackup 1.666667 \n", + "9 NaN WTIV Delay 25.000000 \n", + "10 NaN Feeder 1 Fasten Monopile 12.000000 \n", + "11 NaN WTIV Position Onsite 2.000000 \n", + "12 NaN WTIV Jackup 0.333333 \n", + "13 NaN WTIV RovSurvey 1.000000 \n", + "14 NaN WTIV Release Monopile 3.000000 \n", + "15 NaN WTIV Upend Monopile 0.721000 \n", + "16 NaN WTIV Lower Monopile 0.003500 \n", + "17 NaN WTIV Crane Reequip 1.000000 \n", + "18 NaN WTIV Drive Monopile 1.500000 \n", + "19 NaN Feeder 1 Fasten Transition Piece 8.000000 \n", + "20 NaN WTIV Release Transition Piece 2.000000 \n", + "21 NaN Feeder 0 ActiveFeeder 11.557833 \n", + "22 NaN WTIV Crane Reequip 1.000000 \n", + "23 NaN Feeder 0 Jackdown 1.666667 \n", + "24 NaN WTIV Lower TP 1.000000 \n", + "\n", + " cost level time phase location \\\n", + "0 1.260000e+06 ACTION 0.000000 Monopile Installation NaN \n", + "1 1.125000e+05 ACTION 0.000000 Monopile Installation NaN \n", + "2 1.125000e+05 ACTION 0.000000 Monopile Installation NaN \n", + "3 3.750000e+04 ACTION 5.000000 Monopile Installation NaN \n", + "4 3.750000e+04 ACTION 12.000000 Monopile Installation NaN \n", + "5 2.500000e+04 ACTION 20.000000 Monopile Installation NaN \n", + "6 6.250000e+04 ACTION 20.000000 Monopile Installation NaN \n", + "7 2.604167e+04 ACTION 28.333333 Monopile Installation NaN \n", + "8 5.208333e+03 ACTION 30.000000 Monopile Installation NaN \n", + "9 1.875000e+05 ACTION 30.000000 Monopile Installation Site \n", + "10 3.750000e+04 ACTION 32.000000 Monopile Installation NaN \n", + "11 1.500000e+04 ACTION 32.000000 Monopile Installation NaN \n", + "12 2.500000e+03 ACTION 32.333333 Monopile Installation NaN \n", + "13 7.500000e+03 ACTION 33.333333 Monopile Installation NaN \n", + "14 2.250000e+04 ACTION 36.333333 Monopile Installation NaN \n", + "15 5.407500e+03 ACTION 37.054333 Monopile Installation NaN \n", + "16 2.625000e+01 ACTION 37.057833 Monopile Installation NaN \n", + "17 7.500000e+03 ACTION 38.057833 Monopile Installation NaN \n", + "18 1.125000e+04 ACTION 39.557833 Monopile Installation NaN \n", + "19 2.500000e+04 ACTION 40.000000 Monopile Installation NaN \n", + "20 1.500000e+04 ACTION 41.557833 Monopile Installation NaN \n", + "21 3.611823e+04 ACTION 41.557833 Monopile Installation Site \n", + "22 7.500000e+03 ACTION 42.557833 Monopile Installation NaN \n", + "23 5.208333e+03 ACTION 43.224500 Monopile Installation NaN \n", + "24 7.500000e+03 ACTION 43.557833 Monopile Installation NaN \n", + "\n", + " site_depth \n", + "0 NaN \n", + "1 NaN \n", + "2 NaN \n", + "3 NaN \n", + "4 NaN \n", + "5 NaN \n", + "6 NaN \n", + "7 NaN \n", + "8 NaN \n", + "9 NaN \n", + "10 NaN \n", + "11 NaN \n", + "12 25.0 \n", + "13 25.0 \n", + "14 NaN \n", + "15 25.0 \n", + "16 25.0 \n", + "17 25.0 \n", + "18 25.0 \n", + "19 NaN \n", + "20 NaN \n", + "21 NaN \n", + "22 25.0 \n", + "23 NaN \n", + "24 25.0 " + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(module.env.actions)\n", + "df.head(25) # Note that there are no actions for two feeder barges interwoven into the actions list" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "df = pd.DataFrame(module.env.actions)\n", - "df.head(25) # Note that there are no actions for two feeder barges interwoven into the actions list" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/4. Example Fixed Project.ipynb b/examples/4. Example Fixed Project.ipynb index d01275cb..90c3beda 100644 --- a/examples/4. Example Fixed Project.ipynb +++ b/examples/4. Example Fixed Project.ipynb @@ -1,921 +1,921 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example Fixed Project\n", - "\n", - "The rest of 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. These example projects each exhibit different functionalities within ORBIT. Using these examples and combinations of them, most project configurations can be modeled. " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "from ORBIT import ProjectManager, load_config\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" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Num turbines: 50\n", - "Turbine: SWT_6MW_154m_110m\n", - "\n", - "Site: {'depth': 22.5, 'distance': 124, 'distance_to_landfall': 35, 'mean_windspeed': 9}\n" - ] - } - ], - "source": [ - "fixed_config = load_config(\"configs/example_fixed_project.yaml\") # Configs can be loaded with absolute or relative paths\n", - "\n", - "print(type(fixed_config)) # They are loaded in as dictionaries.\n", - "\n", - "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\") # Once a configuration is loaded, different parameters can \n", - "print(f\"Turbine: {fixed_config['turbine']}\") # be accessed using dict access.\n", - "print(f\"\\nSite: {fixed_config['site']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Phases\n", - "\n", - "This fixed project represents a generic Offshore Wind farm with 50 6MW turbines. It includes 5 design modules and 6 installation modules as seen below. This is a common set of modules to run for a fixed bottom project. This config will model the procurement and installation of monopiles, scour protection, array system, export system, offshore substation and the turbines." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example Fixed Project\n", + "\n", + "The rest of 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. These example projects each exhibit different functionalities within ORBIT. Using these examples and combinations of them, most project configurations can be modeled. " + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design phases: ['MonopileDesign', 'ScourProtectionDesign', 'ArraySystemDesign', 'ExportSystemDesign', 'OffshoreSubstationDesign']\n", - "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MonopileInstallation', 'OffshoreSubstationInstallation', 'ScourProtectionInstallation', 'TurbineInstallation']\n" - ] - } - ], - "source": [ - "print(f\"Design phases: {fixed_config['design_phases']}\")\n", - "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run\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": 12, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "from ORBIT import ProjectManager, load_config\n", + "\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" - ] - } - ], - "source": [ - "project = ProjectManager(fixed_config, weather=weather)\n", - "project.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Top Level Outputs\n", - "\n", - "ProjectManager offers several high level result categories:\n", - "- Installation CapEx\n", - "- System CapEx (procurement of BOS subcomponents)\n", - "- Turbine CapEx\n", - "- Soft CapEx (project management costs)\n", - "- Total CapEx\n", - "- Total installation time\n", - "- etc." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the project configuration" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 181 M\n", - "System CapEx: 257 M\n", - "Turbine CapEx: 390 M\n", - "Soft CapEx: 194 M\n", - "Total CapEx: 1173 M\n", - "\n", - "Installation Time: 12731 h\n" - ] - } - ], - "source": [ - "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", - "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", - "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", - "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", - "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", - "\n", - "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### CapEx Breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Num turbines: 50\n", + "Turbine: SWT_6MW_154m_110m\n", + "\n", + "Site: {'depth': 22.5, 'distance': 124, 'distance_to_landfall': 35, 'mean_windspeed': 9}\n" + ] + } + ], + "source": [ + "fixed_config = load_config(\"configs/example_fixed_project.yaml\") # Configs can be loaded with absolute or relative paths\n", + "\n", + "print(type(fixed_config)) # They are loaded in as dictionaries.\n", + "\n", + "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\") # Once a configuration is loaded, different parameters can \n", + "print(f\"Turbine: {fixed_config['turbine']}\") # be accessed using dict access.\n", + "print(f\"\\nSite: {fixed_config['site']}\")" + ] + }, { - "data": { - "text/plain": [ - "{'Array System': 24416575.834140003,\n", - " 'Export System': 22813500.0,\n", - " 'Offshore Substation': 49739550.0,\n", - " 'Scour Protection': 5896000,\n", - " 'Substructure': 154436243.91851607,\n", - " 'Array System Installation': 19828893.780554257,\n", - " 'Export System Installation': 63231897.48006167,\n", - " 'Offshore Substation Installation': 4323839.723173516,\n", - " 'Scour Protection Installation': 19613097.60273973,\n", - " 'Substructure Installation': 28858058.87808971,\n", - " 'Turbine Installation': 44667905.25114152,\n", - " 'Turbine': 390000000,\n", - " 'Soft': 193500000,\n", - " 'Project': 151250000.0}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Phases\n", + "\n", + "This fixed project represents a generic Offshore Wind farm with 50 6MW turbines. It includes 5 design modules and 6 installation modules as seen below. This is a common set of modules to run for a fixed bottom project. This config will model the procurement and installation of monopiles, scour protection, array system, export system, offshore substation and the turbines." ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The breakdown of project costs by module is available at 'capex_breakdown'\n", - "project.capex_breakdown" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Installation Actions" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "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", - "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speedlocationsite_depthhub_height
00.5Array Cable Installation VesselMobilize72.000000180000.0ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Heavy Lift VesselMobilize72.000000750000.0ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
20.5Feeder 0Mobilize72.000000180000.0ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
30.5SPI VesselMobilize72.000000180000.0ACTION0.000000ScourProtectionInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSPI VesselLoad SP Material4.00000020000.0ACTION4.000000ScourProtectionInstallationScourProtectionInstallationNaNNaNNaNNaNNaNNaN
................................................
3098NaNWTIVAttach Blade3.50000026250.0ACTION5758.182005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3099NaNWTIVRelease Blade1.0000007500.0ACTION5759.182005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
3100NaNWTIVLift Blade1.1000008250.0ACTION5760.282005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3101NaNWTIVAttach Blade3.50000026250.0ACTION5763.782005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3102NaNWTIVJackdown0.3166672375.0ACTION5764.098671TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
\n", - "

3103 rows × 15 columns

\n", - "
" + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Design phases: ['MonopileDesign', 'ScourProtectionDesign', 'ArraySystemDesign', 'ExportSystemDesign', 'OffshoreSubstationDesign']\n", + "\n", + "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MonopileInstallation', 'OffshoreSubstationInstallation', 'ScourProtectionInstallation', 'TurbineInstallation']\n" + ] + } ], - "text/plain": [ - " cost_multiplier agent action \\\n", - "0 0.5 Array Cable Installation Vessel Mobilize \n", - "1 0.5 Heavy Lift Vessel Mobilize \n", - "2 0.5 Feeder 0 Mobilize \n", - "3 0.5 SPI Vessel Mobilize \n", - "4 NaN SPI Vessel Load SP Material \n", - "... ... ... ... \n", - "3098 NaN WTIV Attach Blade \n", - "3099 NaN WTIV Release Blade \n", - "3100 NaN WTIV Lift Blade \n", - "3101 NaN WTIV Attach Blade \n", - "3102 NaN WTIV Jackdown \n", - "\n", - " duration cost level time \\\n", - "0 72.000000 180000.0 ACTION 0.000000 \n", - "1 72.000000 750000.0 ACTION 0.000000 \n", - "2 72.000000 180000.0 ACTION 0.000000 \n", - "3 72.000000 180000.0 ACTION 0.000000 \n", - "4 4.000000 20000.0 ACTION 4.000000 \n", - "... ... ... ... ... \n", - "3098 3.500000 26250.0 ACTION 5758.182005 \n", - "3099 1.000000 7500.0 ACTION 5759.182005 \n", - "3100 1.100000 8250.0 ACTION 5760.282005 \n", - "3101 3.500000 26250.0 ACTION 5763.782005 \n", - "3102 0.316667 2375.0 ACTION 5764.098671 \n", - "\n", - " phase phase_name \\\n", - "0 ArrayCableInstallation NaN \n", - "1 OffshoreSubstationInstallation NaN \n", - "2 OffshoreSubstationInstallation NaN \n", - "3 ScourProtectionInstallation NaN \n", - "4 ScourProtectionInstallation ScourProtectionInstallation \n", - "... ... ... \n", - "3098 TurbineInstallation TurbineInstallation \n", - "3099 TurbineInstallation NaN \n", - "3100 TurbineInstallation TurbineInstallation \n", - "3101 TurbineInstallation TurbineInstallation \n", - "3102 TurbineInstallation TurbineInstallation \n", - "\n", - " max_waveheight max_windspeed transit_speed location site_depth \\\n", - "0 NaN NaN NaN NaN NaN \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", - "... ... ... ... ... ... \n", - "3098 NaN NaN NaN NaN 22.5 \n", - "3099 NaN NaN NaN NaN NaN \n", - "3100 NaN NaN NaN NaN 22.5 \n", - "3101 NaN NaN NaN NaN 22.5 \n", - "3102 NaN NaN NaN NaN 22.5 \n", - "\n", - " hub_height \n", - "0 NaN \n", - "1 NaN \n", - "2 NaN \n", - "3 NaN \n", - "4 NaN \n", - "... ... \n", - "3098 110.0 \n", - "3099 NaN \n", - "3100 110.0 \n", - "3101 110.0 \n", - "3102 110.0 \n", - "\n", - "[3103 rows x 15 columns]" + "source": [ + "print(f\"Design phases: {fixed_config['design_phases']}\")\n", + "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")" ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.DataFrame(project.actions) # The project simulation logs are also available for all modules\n", - "df" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "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", - "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speedlocationsite_depthhub_height
5171.0WTIVMobilize168.0000001260000.0ACTION1524.932005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
523NaNWTIVFasten Tower Section4.00000030000.0ACTION1528.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
527NaNWTIVFasten Tower Section4.00000030000.0ACTION1532.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
534NaNWTIVFasten Nacelle4.00000030000.0ACTION1536.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
536NaNWTIVFasten Blade1.50000011250.0ACTION1538.432005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
................................................
3098NaNWTIVAttach Blade3.50000026250.0ACTION5758.182005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3099NaNWTIVRelease Blade1.0000007500.0ACTION5759.182005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
3100NaNWTIVLift Blade1.1000008250.0ACTION5760.282005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3101NaNWTIVAttach Blade3.50000026250.0ACTION5763.782005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3102NaNWTIVJackdown0.3166672375.0ACTION5764.098671TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
\n", - "

1505 rows × 15 columns

\n", - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run\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": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" + ] + } ], - "text/plain": [ - " cost_multiplier agent action duration cost \\\n", - "517 1.0 WTIV Mobilize 168.000000 1260000.0 \n", - "523 NaN WTIV Fasten Tower Section 4.000000 30000.0 \n", - "527 NaN WTIV Fasten Tower Section 4.000000 30000.0 \n", - "534 NaN WTIV Fasten Nacelle 4.000000 30000.0 \n", - "536 NaN WTIV Fasten Blade 1.500000 11250.0 \n", - "... ... ... ... ... ... \n", - "3098 NaN WTIV Attach Blade 3.500000 26250.0 \n", - "3099 NaN WTIV Release Blade 1.000000 7500.0 \n", - "3100 NaN WTIV Lift Blade 1.100000 8250.0 \n", - "3101 NaN WTIV Attach Blade 3.500000 26250.0 \n", - "3102 NaN WTIV Jackdown 0.316667 2375.0 \n", - "\n", - " level time phase phase_name \\\n", - "517 ACTION 1524.932005 TurbineInstallation NaN \n", - "523 ACTION 1528.932005 TurbineInstallation TurbineInstallation \n", - "527 ACTION 1532.932005 TurbineInstallation TurbineInstallation \n", - "534 ACTION 1536.932005 TurbineInstallation TurbineInstallation \n", - "536 ACTION 1538.432005 TurbineInstallation TurbineInstallation \n", - "... ... ... ... ... \n", - "3098 ACTION 5758.182005 TurbineInstallation TurbineInstallation \n", - "3099 ACTION 5759.182005 TurbineInstallation NaN \n", - "3100 ACTION 5760.282005 TurbineInstallation TurbineInstallation \n", - "3101 ACTION 5763.782005 TurbineInstallation TurbineInstallation \n", - "3102 ACTION 5764.098671 TurbineInstallation TurbineInstallation \n", - "\n", - " max_waveheight max_windspeed transit_speed location site_depth \\\n", - "517 NaN NaN NaN NaN NaN \n", - "523 NaN NaN NaN NaN 22.5 \n", - "527 NaN NaN NaN NaN 22.5 \n", - "534 NaN NaN NaN NaN 22.5 \n", - "536 NaN NaN NaN NaN 22.5 \n", - "... ... ... ... ... ... \n", - "3098 NaN NaN NaN NaN 22.5 \n", - "3099 NaN NaN NaN NaN NaN \n", - "3100 NaN NaN NaN NaN 22.5 \n", - "3101 NaN NaN NaN NaN 22.5 \n", - "3102 NaN NaN NaN NaN 22.5 \n", - "\n", - " hub_height \n", - "517 NaN \n", - "523 110.0 \n", - "527 110.0 \n", - "534 110.0 \n", - "536 110.0 \n", - "... ... \n", - "3098 110.0 \n", - "3099 NaN \n", - "3100 110.0 \n", - "3101 110.0 \n", - "3102 110.0 \n", - "\n", - "[1505 rows x 15 columns]" + "source": [ + "project = ProjectManager(fixed_config, weather=weather)\n", + "project.run()" ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# These logs can be sorted by phase by using DataFrame operations\n", - "\n", - "turbine_install = df.loc[df['phase']==\"TurbineInstallation\"]\n", - "turbine_install" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top Level Outputs\n", + "\n", + "ProjectManager offers several high level result categories:\n", + "- Installation CapEx\n", + "- System CapEx (procurement of BOS subcomponents)\n", + "- Turbine CapEx\n", + "- Soft CapEx (project management costs)\n", + "- Total CapEx\n", + "- Total installation time\n", + "- etc." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation CapEx: 181 M\n", + "System CapEx: 257 M\n", + "Turbine CapEx: 390 M\n", + "Soft CapEx: 194 M\n", + "Total CapEx: 1173 M\n", + "\n", + "Installation Time: 12731 h\n" + ] + } + ], + "source": [ + "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", + "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", + "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", + "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", + "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", + "\n", + "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### CapEx Breakdown" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 24416575.834140003,\n", + " 'Export System': 22813500.0,\n", + " 'Offshore Substation': 49739550.0,\n", + " 'Scour Protection': 5896000,\n", + " 'Substructure': 154436243.91851607,\n", + " 'Array System Installation': 19828893.780554257,\n", + " 'Export System Installation': 63231897.48006167,\n", + " 'Offshore Substation Installation': 4323839.723173516,\n", + " 'Scour Protection Installation': 19613097.60273973,\n", + " 'Substructure Installation': 28858058.87808971,\n", + " 'Turbine Installation': 44667905.25114152,\n", + " 'Turbine': 390000000,\n", + " 'Soft': 193500000,\n", + " 'Project': 151250000.0}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The breakdown of project costs by module is available at 'capex_breakdown'\n", + "project.capex_breakdown" + ] + }, { - "data": { - "text/plain": [ - "action\n", - "Attach Blade 525.000000\n", - "Attach Nacelle 300.000000\n", - "Attach Tower Section 600.000000\n", - "Delay 669.000000\n", - "Fasten Blade 225.000000\n", - "Fasten Nacelle 200.000000\n", - "Fasten Tower Section 400.000000\n", - "Jackdown 15.833333\n", - "Jackup 15.833333\n", - "Lift Blade 165.000000\n", - "Lift Nacelle 55.000000\n", - "Lift Tower Section 82.500000\n", - "Mobilize 168.000000\n", - "Position Onsite 100.000000\n", - "Reequip 100.000000\n", - "Release Blade 150.000000\n", - "Release Nacelle 150.000000\n", - "Release Tower Section 300.000000\n", - "Transit 186.000000\n", - "Name: duration, dtype: float64" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Installation Actions" ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "execution_count": 17, + "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", + "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speedlocationsite_depthhub_height
00.5Array Cable Installation VesselMobilize72.000000180000.0ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Heavy Lift VesselMobilize72.000000750000.0ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
20.5Feeder 0Mobilize72.000000180000.0ACTION0.000000OffshoreSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
30.5SPI VesselMobilize72.000000180000.0ACTION0.000000ScourProtectionInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSPI VesselLoad SP Material4.00000020000.0ACTION4.000000ScourProtectionInstallationScourProtectionInstallationNaNNaNNaNNaNNaNNaN
................................................
3098NaNWTIVAttach Blade3.50000026250.0ACTION5758.182005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3099NaNWTIVRelease Blade1.0000007500.0ACTION5759.182005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
3100NaNWTIVLift Blade1.1000008250.0ACTION5760.282005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3101NaNWTIVAttach Blade3.50000026250.0ACTION5763.782005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3102NaNWTIVJackdown0.3166672375.0ACTION5764.098671TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
\n", + "

3103 rows \u00d7 15 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action \\\n", + "0 0.5 Array Cable Installation Vessel Mobilize \n", + "1 0.5 Heavy Lift Vessel Mobilize \n", + "2 0.5 Feeder 0 Mobilize \n", + "3 0.5 SPI Vessel Mobilize \n", + "4 NaN SPI Vessel Load SP Material \n", + "... ... ... ... \n", + "3098 NaN WTIV Attach Blade \n", + "3099 NaN WTIV Release Blade \n", + "3100 NaN WTIV Lift Blade \n", + "3101 NaN WTIV Attach Blade \n", + "3102 NaN WTIV Jackdown \n", + "\n", + " duration cost level time \\\n", + "0 72.000000 180000.0 ACTION 0.000000 \n", + "1 72.000000 750000.0 ACTION 0.000000 \n", + "2 72.000000 180000.0 ACTION 0.000000 \n", + "3 72.000000 180000.0 ACTION 0.000000 \n", + "4 4.000000 20000.0 ACTION 4.000000 \n", + "... ... ... ... ... \n", + "3098 3.500000 26250.0 ACTION 5758.182005 \n", + "3099 1.000000 7500.0 ACTION 5759.182005 \n", + "3100 1.100000 8250.0 ACTION 5760.282005 \n", + "3101 3.500000 26250.0 ACTION 5763.782005 \n", + "3102 0.316667 2375.0 ACTION 5764.098671 \n", + "\n", + " phase phase_name \\\n", + "0 ArrayCableInstallation NaN \n", + "1 OffshoreSubstationInstallation NaN \n", + "2 OffshoreSubstationInstallation NaN \n", + "3 ScourProtectionInstallation NaN \n", + "4 ScourProtectionInstallation ScourProtectionInstallation \n", + "... ... ... \n", + "3098 TurbineInstallation TurbineInstallation \n", + "3099 TurbineInstallation NaN \n", + "3100 TurbineInstallation TurbineInstallation \n", + "3101 TurbineInstallation TurbineInstallation \n", + "3102 TurbineInstallation TurbineInstallation \n", + "\n", + " max_waveheight max_windspeed transit_speed location site_depth \\\n", + "0 NaN NaN NaN NaN NaN \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", + "... ... ... ... ... ... \n", + "3098 NaN NaN NaN NaN 22.5 \n", + "3099 NaN NaN NaN NaN NaN \n", + "3100 NaN NaN NaN NaN 22.5 \n", + "3101 NaN NaN NaN NaN 22.5 \n", + "3102 NaN NaN NaN NaN 22.5 \n", + "\n", + " hub_height \n", + "0 NaN \n", + "1 NaN \n", + "2 NaN \n", + "3 NaN \n", + "4 NaN \n", + "... ... \n", + "3098 110.0 \n", + "3099 NaN \n", + "3100 110.0 \n", + "3101 110.0 \n", + "3102 110.0 \n", + "\n", + "[3103 rows x 15 columns]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(project.actions) # The project simulation logs are also available for all modules\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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", + "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speedlocationsite_depthhub_height
5171.0WTIVMobilize168.0000001260000.0ACTION1524.932005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
523NaNWTIVFasten Tower Section4.00000030000.0ACTION1528.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
527NaNWTIVFasten Tower Section4.00000030000.0ACTION1532.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
534NaNWTIVFasten Nacelle4.00000030000.0ACTION1536.932005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
536NaNWTIVFasten Blade1.50000011250.0ACTION1538.432005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
................................................
3098NaNWTIVAttach Blade3.50000026250.0ACTION5758.182005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3099NaNWTIVRelease Blade1.0000007500.0ACTION5759.182005TurbineInstallationNaNNaNNaNNaNNaNNaNNaN
3100NaNWTIVLift Blade1.1000008250.0ACTION5760.282005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3101NaNWTIVAttach Blade3.50000026250.0ACTION5763.782005TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
3102NaNWTIVJackdown0.3166672375.0ACTION5764.098671TurbineInstallationTurbineInstallationNaNNaNNaNNaN22.5110.0
\n", + "

1505 rows \u00d7 15 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration cost \\\n", + "517 1.0 WTIV Mobilize 168.000000 1260000.0 \n", + "523 NaN WTIV Fasten Tower Section 4.000000 30000.0 \n", + "527 NaN WTIV Fasten Tower Section 4.000000 30000.0 \n", + "534 NaN WTIV Fasten Nacelle 4.000000 30000.0 \n", + "536 NaN WTIV Fasten Blade 1.500000 11250.0 \n", + "... ... ... ... ... ... \n", + "3098 NaN WTIV Attach Blade 3.500000 26250.0 \n", + "3099 NaN WTIV Release Blade 1.000000 7500.0 \n", + "3100 NaN WTIV Lift Blade 1.100000 8250.0 \n", + "3101 NaN WTIV Attach Blade 3.500000 26250.0 \n", + "3102 NaN WTIV Jackdown 0.316667 2375.0 \n", + "\n", + " level time phase phase_name \\\n", + "517 ACTION 1524.932005 TurbineInstallation NaN \n", + "523 ACTION 1528.932005 TurbineInstallation TurbineInstallation \n", + "527 ACTION 1532.932005 TurbineInstallation TurbineInstallation \n", + "534 ACTION 1536.932005 TurbineInstallation TurbineInstallation \n", + "536 ACTION 1538.432005 TurbineInstallation TurbineInstallation \n", + "... ... ... ... ... \n", + "3098 ACTION 5758.182005 TurbineInstallation TurbineInstallation \n", + "3099 ACTION 5759.182005 TurbineInstallation NaN \n", + "3100 ACTION 5760.282005 TurbineInstallation TurbineInstallation \n", + "3101 ACTION 5763.782005 TurbineInstallation TurbineInstallation \n", + "3102 ACTION 5764.098671 TurbineInstallation TurbineInstallation \n", + "\n", + " max_waveheight max_windspeed transit_speed location site_depth \\\n", + "517 NaN NaN NaN NaN NaN \n", + "523 NaN NaN NaN NaN 22.5 \n", + "527 NaN NaN NaN NaN 22.5 \n", + "534 NaN NaN NaN NaN 22.5 \n", + "536 NaN NaN NaN NaN 22.5 \n", + "... ... ... ... ... ... \n", + "3098 NaN NaN NaN NaN 22.5 \n", + "3099 NaN NaN NaN NaN NaN \n", + "3100 NaN NaN NaN NaN 22.5 \n", + "3101 NaN NaN NaN NaN 22.5 \n", + "3102 NaN NaN NaN NaN 22.5 \n", + "\n", + " hub_height \n", + "517 NaN \n", + "523 110.0 \n", + "527 110.0 \n", + "534 110.0 \n", + "536 110.0 \n", + "... ... \n", + "3098 110.0 \n", + "3099 NaN \n", + "3100 110.0 \n", + "3101 110.0 \n", + "3102 110.0 \n", + "\n", + "[1505 rows x 15 columns]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# These logs can be sorted by phase by using DataFrame operations\n", + "\n", + "turbine_install = df.loc[df['phase']==\"TurbineInstallation\"]\n", + "turbine_install" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "action\n", + "Attach Blade 525.000000\n", + "Attach Nacelle 300.000000\n", + "Attach Tower Section 600.000000\n", + "Delay 669.000000\n", + "Fasten Blade 225.000000\n", + "Fasten Nacelle 200.000000\n", + "Fasten Tower Section 400.000000\n", + "Jackdown 15.833333\n", + "Jackup 15.833333\n", + "Lift Blade 165.000000\n", + "Lift Nacelle 55.000000\n", + "Lift Tower Section 82.500000\n", + "Mobilize 168.000000\n", + "Position Onsite 100.000000\n", + "Reequip 100.000000\n", + "Release Blade 150.000000\n", + "Release Nacelle 150.000000\n", + "Release Tower Section 300.000000\n", + "Transit 186.000000\n", + "Name: duration, dtype: float64" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Operations can also be grouped to see a total amount of time spend on each operation\n", + "\n", + "turbine_install.groupby([\"action\"]).sum()['duration']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.15" } - ], - "source": [ - "# Operations can also be grouped to see a total amount of time spend on each operation\n", - "\n", - "turbine_install.groupby([\"action\"]).sum()['duration']" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.9.15" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/Example - Cable Install Configurations.ipynb b/examples/Example - Cable Install Configurations.ipynb index d4f20772..4b2a2f46 100644 --- a/examples/Example - Cable Install Configurations.ipynb +++ b/examples/Example - Cable Install Configurations.ipynb @@ -1,887 +1,887 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ORBIT Example - Cable Installation Options\n", - "\n", - "Last Updated: 07/88/2021" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "from ORBIT import ProjectManager" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### ArrayCableInstallation Module" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ + "cells": [ { - "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", - "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.000000180000.000000ACTION0.000000ArrayCableInstallationNaNNaNNaNNaN
1NaNArray Cable Installation VesselLoad Cable6.00000030000.000000ACTION6.000000ArrayCableInstallationArrayCableInstallationNaNNaNNaN
2NaNArray Cable Installation VesselTransit1.7391308695.652174ACTION7.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
3NaNArray Cable Installation VesselPosition Onsite2.00000010000.000000ACTION9.739130ArrayCableInstallationNaNNaNNaNNaN
4NaNArray Cable Installation VesselPrepare Cable1.0000005000.000000ACTION10.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
5NaNArray Cable Installation VesselPull In Cable5.50000027500.000000ACTION16.239130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
6NaNArray Cable Installation VesselTerminate Cable5.50000027500.000000ACTION21.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
7NaNArray Cable Installation VesselLower Cable1.0000005000.000000ACTION22.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
8NaNArray Cable Installation VesselLay/Bury Cable6.66666733333.333333ACTION29.405797ArrayCableInstallationArrayCableInstallation2.025.011.5
9NaNArray Cable Installation VesselPrepare Cable1.0000005000.000000ACTION30.405797ArrayCableInstallationArrayCableInstallationNaNNaNNaN
\n", - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ORBIT Example - Cable Installation Options\n", + "\n", + "Last Updated: 07/88/2021" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from ORBIT import ProjectManager" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### ArrayCableInstallation Module" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.000000180000.000000ACTION0.000000ArrayCableInstallationNaNNaNNaNNaN
1NaNArray Cable Installation VesselLoad Cable6.00000030000.000000ACTION6.000000ArrayCableInstallationArrayCableInstallationNaNNaNNaN
2NaNArray Cable Installation VesselTransit1.7391308695.652174ACTION7.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
3NaNArray Cable Installation VesselPosition Onsite2.00000010000.000000ACTION9.739130ArrayCableInstallationNaNNaNNaNNaN
4NaNArray Cable Installation VesselPrepare Cable1.0000005000.000000ACTION10.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
5NaNArray Cable Installation VesselPull In Cable5.50000027500.000000ACTION16.239130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
6NaNArray Cable Installation VesselTerminate Cable5.50000027500.000000ACTION21.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
7NaNArray Cable Installation VesselLower Cable1.0000005000.000000ACTION22.739130ArrayCableInstallationArrayCableInstallationNaNNaNNaN
8NaNArray Cable Installation VesselLay/Bury Cable6.66666733333.333333ACTION29.405797ArrayCableInstallationArrayCableInstallation2.025.011.5
9NaNArray Cable Installation VesselPrepare Cable1.0000005000.000000ACTION30.405797ArrayCableInstallationArrayCableInstallationNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action \\\n", + "0 0.5 Array Cable Installation Vessel Mobilize \n", + "1 NaN Array Cable Installation Vessel Load Cable \n", + "2 NaN Array Cable Installation Vessel Transit \n", + "3 NaN Array Cable Installation Vessel Position Onsite \n", + "4 NaN Array Cable Installation Vessel Prepare Cable \n", + "5 NaN Array Cable Installation Vessel Pull In Cable \n", + "6 NaN Array Cable Installation Vessel Terminate Cable \n", + "7 NaN Array Cable Installation Vessel Lower Cable \n", + "8 NaN Array Cable Installation Vessel Lay/Bury Cable \n", + "9 NaN Array Cable Installation Vessel Prepare Cable \n", + "\n", + " duration cost level time phase \\\n", + "0 72.000000 180000.000000 ACTION 0.000000 ArrayCableInstallation \n", + "1 6.000000 30000.000000 ACTION 6.000000 ArrayCableInstallation \n", + "2 1.739130 8695.652174 ACTION 7.739130 ArrayCableInstallation \n", + "3 2.000000 10000.000000 ACTION 9.739130 ArrayCableInstallation \n", + "4 1.000000 5000.000000 ACTION 10.739130 ArrayCableInstallation \n", + "5 5.500000 27500.000000 ACTION 16.239130 ArrayCableInstallation \n", + "6 5.500000 27500.000000 ACTION 21.739130 ArrayCableInstallation \n", + "7 1.000000 5000.000000 ACTION 22.739130 ArrayCableInstallation \n", + "8 6.666667 33333.333333 ACTION 29.405797 ArrayCableInstallation \n", + "9 1.000000 5000.000000 ACTION 30.405797 ArrayCableInstallation \n", + "\n", + " phase_name max_waveheight max_windspeed transit_speed \n", + "0 NaN NaN NaN NaN \n", + "1 ArrayCableInstallation NaN NaN NaN \n", + "2 ArrayCableInstallation NaN NaN NaN \n", + "3 NaN NaN NaN NaN \n", + "4 ArrayCableInstallation NaN NaN NaN \n", + "5 ArrayCableInstallation NaN NaN NaN \n", + "6 ArrayCableInstallation NaN NaN NaN \n", + "7 ArrayCableInstallation NaN NaN NaN \n", + "8 ArrayCableInstallation 2.0 25.0 11.5 \n", + "9 ArrayCableInstallation NaN NaN NaN " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action \\\n", - "0 0.5 Array Cable Installation Vessel Mobilize \n", - "1 NaN Array Cable Installation Vessel Load Cable \n", - "2 NaN Array Cable Installation Vessel Transit \n", - "3 NaN Array Cable Installation Vessel Position Onsite \n", - "4 NaN Array Cable Installation Vessel Prepare Cable \n", - "5 NaN Array Cable Installation Vessel Pull In Cable \n", - "6 NaN Array Cable Installation Vessel Terminate Cable \n", - "7 NaN Array Cable Installation Vessel Lower Cable \n", - "8 NaN Array Cable Installation Vessel Lay/Bury Cable \n", - "9 NaN Array Cable Installation Vessel Prepare Cable \n", - "\n", - " duration cost level time phase \\\n", - "0 72.000000 180000.000000 ACTION 0.000000 ArrayCableInstallation \n", - "1 6.000000 30000.000000 ACTION 6.000000 ArrayCableInstallation \n", - "2 1.739130 8695.652174 ACTION 7.739130 ArrayCableInstallation \n", - "3 2.000000 10000.000000 ACTION 9.739130 ArrayCableInstallation \n", - "4 1.000000 5000.000000 ACTION 10.739130 ArrayCableInstallation \n", - "5 5.500000 27500.000000 ACTION 16.239130 ArrayCableInstallation \n", - "6 5.500000 27500.000000 ACTION 21.739130 ArrayCableInstallation \n", - "7 1.000000 5000.000000 ACTION 22.739130 ArrayCableInstallation \n", - "8 6.666667 33333.333333 ACTION 29.405797 ArrayCableInstallation \n", - "9 1.000000 5000.000000 ACTION 30.405797 ArrayCableInstallation \n", - "\n", - " phase_name max_waveheight max_windspeed transit_speed \n", - "0 NaN NaN NaN NaN \n", - "1 ArrayCableInstallation NaN NaN NaN \n", - "2 ArrayCableInstallation NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 ArrayCableInstallation NaN NaN NaN \n", - "5 ArrayCableInstallation NaN NaN NaN \n", - "6 ArrayCableInstallation NaN NaN NaN \n", - "7 ArrayCableInstallation NaN NaN NaN \n", - "8 ArrayCableInstallation 2.0 25.0 11.5 \n", - "9 ArrayCableInstallation NaN NaN NaN " + "source": [ + "# The configuration below can be modified to change the installation strategies utilized in ArrayCableInstallation module\n", + "# by toggling on/off which vessels are configured:\n", + "\n", + "config = {\n", + " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will perform a simultaneous lay/bury installation strategy\n", + " # as there is no 'bury_vessel' defined in the config\n", + "\n", + "# \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", + "# \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", + " \n", + " \"site\": {\"distance\": 20, \"depth\": 35},\n", + " \"port\": {},\n", + " \"array_system\": {\n", + " \"system_cost\": 50e6,\n", + " \"cables\": {\n", + " \"ExampleCable\": {\n", + " \"linear_density\": 40, # t/km\n", + " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", + " }\n", + " }\n", + " },\n", + " \n", + " \"install_phases\": [\"ArrayCableInstallation\"]\n", + "}\n", + "\n", + "# Run\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "# Outputs\n", + "df = pd.DataFrame(project.actions)\n", + "df.iloc[0:10] # Notice the action \"Lay/Bury Cable\" in row 8." ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# The configuration below can be modified to change the installation strategies utilized in ArrayCableInstallation module\n", - "# by toggling on/off which vessels are configured:\n", - "\n", - "config = {\n", - " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will perform a simultaneous lay/bury installation strategy\n", - " # as there is no 'bury_vessel' defined in the config\n", - "\n", - "# \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", - "# \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", - " \n", - " \"site\": {\"distance\": 20, \"depth\": 35},\n", - " \"port\": {},\n", - " \"array_system\": {\n", - " \"system_cost\": 50e6,\n", - " \"cables\": {\n", - " \"ExampleCable\": {\n", - " \"linear_density\": 40, # t/km\n", - " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", - " }\n", - " }\n", - " },\n", - " \n", - " \"install_phases\": [\"ArrayCableInstallation\"]\n", - "}\n", - "\n", - "# Run\n", - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "# Outputs\n", - "df = pd.DataFrame(project.actions)\n", - "df.iloc[0:10] # Notice the action \"Lay/Bury Cable\" in row 8." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Including a separate burial vessel" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Including a separate burial vessel" + ] + }, { - "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", - "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
10.5Array Cable Burial VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
2NaNArray Cable Installation VesselLoad Cable6.0000030000.000000ACTION6.00000ArrayCableInstallationArrayCableInstallationNaNNaNNaN
3NaNArray Cable Installation VesselTransit1.739138695.652174ACTION7.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
4NaNArray Cable Installation VesselPosition Onsite2.0000010000.000000ACTION9.73913ArrayCableInstallationNaNNaNNaNNaN
5NaNArray Cable Installation VesselPrepare Cable1.000005000.000000ACTION10.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
6NaNArray Cable Installation VesselPull In Cable5.5000027500.000000ACTION16.23913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
7NaNArray Cable Installation VesselTerminate Cable5.5000027500.000000ACTION21.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
8NaNArray Cable Installation VesselLower Cable1.000005000.000000ACTION22.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
9NaNArray Cable Installation VesselLay Cable2.0000010000.000000ACTION24.73913ArrayCableInstallationArrayCableInstallation2.025.011.5
\n", - "
" + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
10.5Array Cable Burial VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
2NaNArray Cable Installation VesselLoad Cable6.0000030000.000000ACTION6.00000ArrayCableInstallationArrayCableInstallationNaNNaNNaN
3NaNArray Cable Installation VesselTransit1.739138695.652174ACTION7.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
4NaNArray Cable Installation VesselPosition Onsite2.0000010000.000000ACTION9.73913ArrayCableInstallationNaNNaNNaNNaN
5NaNArray Cable Installation VesselPrepare Cable1.000005000.000000ACTION10.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
6NaNArray Cable Installation VesselPull In Cable5.5000027500.000000ACTION16.23913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
7NaNArray Cable Installation VesselTerminate Cable5.5000027500.000000ACTION21.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
8NaNArray Cable Installation VesselLower Cable1.000005000.000000ACTION22.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
9NaNArray Cable Installation VesselLay Cable2.0000010000.000000ACTION24.73913ArrayCableInstallationArrayCableInstallation2.025.011.5
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action \\\n", + "0 0.5 Array Cable Installation Vessel Mobilize \n", + "1 0.5 Array Cable Burial Vessel Mobilize \n", + "2 NaN Array Cable Installation Vessel Load Cable \n", + "3 NaN Array Cable Installation Vessel Transit \n", + "4 NaN Array Cable Installation Vessel Position Onsite \n", + "5 NaN Array Cable Installation Vessel Prepare Cable \n", + "6 NaN Array Cable Installation Vessel Pull In Cable \n", + "7 NaN Array Cable Installation Vessel Terminate Cable \n", + "8 NaN Array Cable Installation Vessel Lower Cable \n", + "9 NaN Array Cable Installation Vessel Lay Cable \n", + "\n", + " duration cost level time phase \\\n", + "0 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", + "1 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", + "2 6.00000 30000.000000 ACTION 6.00000 ArrayCableInstallation \n", + "3 1.73913 8695.652174 ACTION 7.73913 ArrayCableInstallation \n", + "4 2.00000 10000.000000 ACTION 9.73913 ArrayCableInstallation \n", + "5 1.00000 5000.000000 ACTION 10.73913 ArrayCableInstallation \n", + "6 5.50000 27500.000000 ACTION 16.23913 ArrayCableInstallation \n", + "7 5.50000 27500.000000 ACTION 21.73913 ArrayCableInstallation \n", + "8 1.00000 5000.000000 ACTION 22.73913 ArrayCableInstallation \n", + "9 2.00000 10000.000000 ACTION 24.73913 ArrayCableInstallation \n", + "\n", + " phase_name max_waveheight max_windspeed transit_speed \n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 ArrayCableInstallation NaN NaN NaN \n", + "3 ArrayCableInstallation NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "5 ArrayCableInstallation NaN NaN NaN \n", + "6 ArrayCableInstallation NaN NaN NaN \n", + "7 ArrayCableInstallation NaN NaN NaN \n", + "8 ArrayCableInstallation NaN NaN NaN \n", + "9 ArrayCableInstallation 2.0 25.0 11.5 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action \\\n", - "0 0.5 Array Cable Installation Vessel Mobilize \n", - "1 0.5 Array Cable Burial Vessel Mobilize \n", - "2 NaN Array Cable Installation Vessel Load Cable \n", - "3 NaN Array Cable Installation Vessel Transit \n", - "4 NaN Array Cable Installation Vessel Position Onsite \n", - "5 NaN Array Cable Installation Vessel Prepare Cable \n", - "6 NaN Array Cable Installation Vessel Pull In Cable \n", - "7 NaN Array Cable Installation Vessel Terminate Cable \n", - "8 NaN Array Cable Installation Vessel Lower Cable \n", - "9 NaN Array Cable Installation Vessel Lay Cable \n", - "\n", - " duration cost level time phase \\\n", - "0 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", - "1 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", - "2 6.00000 30000.000000 ACTION 6.00000 ArrayCableInstallation \n", - "3 1.73913 8695.652174 ACTION 7.73913 ArrayCableInstallation \n", - "4 2.00000 10000.000000 ACTION 9.73913 ArrayCableInstallation \n", - "5 1.00000 5000.000000 ACTION 10.73913 ArrayCableInstallation \n", - "6 5.50000 27500.000000 ACTION 16.23913 ArrayCableInstallation \n", - "7 5.50000 27500.000000 ACTION 21.73913 ArrayCableInstallation \n", - "8 1.00000 5000.000000 ACTION 22.73913 ArrayCableInstallation \n", - "9 2.00000 10000.000000 ACTION 24.73913 ArrayCableInstallation \n", - "\n", - " phase_name max_waveheight max_windspeed transit_speed \n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 ArrayCableInstallation NaN NaN NaN \n", - "3 ArrayCableInstallation NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - "5 ArrayCableInstallation NaN NaN NaN \n", - "6 ArrayCableInstallation NaN NaN NaN \n", - "7 ArrayCableInstallation NaN NaN NaN \n", - "8 ArrayCableInstallation NaN NaN NaN \n", - "9 ArrayCableInstallation 2.0 25.0 11.5 " + "source": [ + "config = {\n", + " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will now lay the cable but will not bury it.\n", + " \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # This vessel will now complete the burial process separate from the installation vessel.\n", + "# \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", + " \n", + " \"site\": {\"distance\": 20, \"depth\": 35},\n", + " \"port\": {},\n", + " \"array_system\": {\n", + " \"system_cost\": 50e6,\n", + " \"cables\": {\n", + " \"ExampleCable\": {\n", + " \"linear_density\": 40, # t/km\n", + " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", + " }\n", + " }\n", + " },\n", + " \n", + " \"install_phases\": [\"ArrayCableInstallation\"]\n", + "}\n", + "\n", + "# Run\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "# Outputs\n", + "df = pd.DataFrame(project.actions)\n", + "df.iloc[0:10]\n", + "\n", + "# There is an additional vessel mobilization in Row 1 and Row 9 is now just \"Lay Cable\"\n", + "# The burial process now occurs separate from the installation vessel." ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "config = {\n", - " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will now lay the cable but will not bury it.\n", - " \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # This vessel will now complete the burial process separate from the installation vessel.\n", - "# \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # <--- Commented out. Will be ignored by the code.\n", - " \n", - " \"site\": {\"distance\": 20, \"depth\": 35},\n", - " \"port\": {},\n", - " \"array_system\": {\n", - " \"system_cost\": 50e6,\n", - " \"cables\": {\n", - " \"ExampleCable\": {\n", - " \"linear_density\": 40, # t/km\n", - " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", - " }\n", - " }\n", - " },\n", - " \n", - " \"install_phases\": [\"ArrayCableInstallation\"]\n", - "}\n", - "\n", - "# Run\n", - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "# Outputs\n", - "df = pd.DataFrame(project.actions)\n", - "df.iloc[0:10]\n", - "\n", - "# There is an additional vessel mobilization in Row 1 and Row 9 is now just \"Lay Cable\"\n", - "# The burial process now occurs separate from the installation vessel." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Including a Trenching Vessel" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "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", - "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
10.5Array Cable Burial VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
20.5Array Cable Trench VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
3NaNArray Cable Trench VesselTransit1.739138695.652174ACTION1.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
4NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION3.73913ArrayCableInstallationNaNNaNNaNNaN
5NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION23.03913ArrayCableInstallationArrayCableInstallation2.025.011.5
6NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION25.03913ArrayCableInstallationNaNNaNNaNNaN
7NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION44.33913ArrayCableInstallationArrayCableInstallation2.025.011.5
8NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION46.33913ArrayCableInstallationNaNNaNNaNNaN
9NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION65.63913ArrayCableInstallationArrayCableInstallation2.025.011.5
\n", - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Including a Trenching Vessel" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + "
cost_multiplieragentactiondurationcostleveltimephasephase_namemax_waveheightmax_windspeedtransit_speed
00.5Array Cable Installation VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
10.5Array Cable Burial VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
20.5Array Cable Trench VesselMobilize72.00000180000.000000ACTION0.00000ArrayCableInstallationNaNNaNNaNNaN
3NaNArray Cable Trench VesselTransit1.739138695.652174ACTION1.73913ArrayCableInstallationArrayCableInstallationNaNNaNNaN
4NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION3.73913ArrayCableInstallationNaNNaNNaNNaN
5NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION23.03913ArrayCableInstallationArrayCableInstallation2.025.011.5
6NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION25.03913ArrayCableInstallationNaNNaNNaNNaN
7NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION44.33913ArrayCableInstallationArrayCableInstallation2.025.011.5
8NaNArray Cable Trench VesselPosition Onsite2.0000010000.000000ACTION46.33913ArrayCableInstallationNaNNaNNaNNaN
9NaNArray Cable Trench VesselDig Trench19.3000096500.000000ACTION65.63913ArrayCableInstallationArrayCableInstallation2.025.011.5
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action \\\n", + "0 0.5 Array Cable Installation Vessel Mobilize \n", + "1 0.5 Array Cable Burial Vessel Mobilize \n", + "2 0.5 Array Cable Trench Vessel Mobilize \n", + "3 NaN Array Cable Trench Vessel Transit \n", + "4 NaN Array Cable Trench Vessel Position Onsite \n", + "5 NaN Array Cable Trench Vessel Dig Trench \n", + "6 NaN Array Cable Trench Vessel Position Onsite \n", + "7 NaN Array Cable Trench Vessel Dig Trench \n", + "8 NaN Array Cable Trench Vessel Position Onsite \n", + "9 NaN Array Cable Trench Vessel Dig Trench \n", + "\n", + " duration cost level time phase \\\n", + "0 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", + "1 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", + "2 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", + "3 1.73913 8695.652174 ACTION 1.73913 ArrayCableInstallation \n", + "4 2.00000 10000.000000 ACTION 3.73913 ArrayCableInstallation \n", + "5 19.30000 96500.000000 ACTION 23.03913 ArrayCableInstallation \n", + "6 2.00000 10000.000000 ACTION 25.03913 ArrayCableInstallation \n", + "7 19.30000 96500.000000 ACTION 44.33913 ArrayCableInstallation \n", + "8 2.00000 10000.000000 ACTION 46.33913 ArrayCableInstallation \n", + "9 19.30000 96500.000000 ACTION 65.63913 ArrayCableInstallation \n", + "\n", + " phase_name max_waveheight max_windspeed transit_speed \n", + "0 NaN NaN NaN NaN \n", + "1 NaN NaN NaN NaN \n", + "2 NaN NaN NaN NaN \n", + "3 ArrayCableInstallation NaN NaN NaN \n", + "4 NaN NaN NaN NaN \n", + "5 ArrayCableInstallation 2.0 25.0 11.5 \n", + "6 NaN NaN NaN NaN \n", + "7 ArrayCableInstallation 2.0 25.0 11.5 \n", + "8 NaN NaN NaN NaN \n", + "9 ArrayCableInstallation 2.0 25.0 11.5 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action \\\n", - "0 0.5 Array Cable Installation Vessel Mobilize \n", - "1 0.5 Array Cable Burial Vessel Mobilize \n", - "2 0.5 Array Cable Trench Vessel Mobilize \n", - "3 NaN Array Cable Trench Vessel Transit \n", - "4 NaN Array Cable Trench Vessel Position Onsite \n", - "5 NaN Array Cable Trench Vessel Dig Trench \n", - "6 NaN Array Cable Trench Vessel Position Onsite \n", - "7 NaN Array Cable Trench Vessel Dig Trench \n", - "8 NaN Array Cable Trench Vessel Position Onsite \n", - "9 NaN Array Cable Trench Vessel Dig Trench \n", - "\n", - " duration cost level time phase \\\n", - "0 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", - "1 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", - "2 72.00000 180000.000000 ACTION 0.00000 ArrayCableInstallation \n", - "3 1.73913 8695.652174 ACTION 1.73913 ArrayCableInstallation \n", - "4 2.00000 10000.000000 ACTION 3.73913 ArrayCableInstallation \n", - "5 19.30000 96500.000000 ACTION 23.03913 ArrayCableInstallation \n", - "6 2.00000 10000.000000 ACTION 25.03913 ArrayCableInstallation \n", - "7 19.30000 96500.000000 ACTION 44.33913 ArrayCableInstallation \n", - "8 2.00000 10000.000000 ACTION 46.33913 ArrayCableInstallation \n", - "9 19.30000 96500.000000 ACTION 65.63913 ArrayCableInstallation \n", - "\n", - " phase_name max_waveheight max_windspeed transit_speed \n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 ArrayCableInstallation NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - "5 ArrayCableInstallation 2.0 25.0 11.5 \n", - "6 NaN NaN NaN NaN \n", - "7 ArrayCableInstallation 2.0 25.0 11.5 \n", - "8 NaN NaN NaN NaN \n", - "9 ArrayCableInstallation 2.0 25.0 11.5 " + "source": [ + "config = {\n", + " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will lay the cable but will not bury it.\n", + " \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # This vessel will complete the burial process separate from the installation vessel.\n", + " \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # This vessel will complete the trenching process prior to the other two vessels beginning their work.\n", + " \n", + " \"site\": {\"distance\": 20, \"depth\": 35},\n", + " \"port\": {},\n", + " \"array_system\": {\n", + " \"system_cost\": 50e6,\n", + " \"cables\": {\n", + " \"ExampleCable\": {\n", + " \"linear_density\": 40, # t/km\n", + " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", + " }\n", + " }\n", + " },\n", + " \n", + " \"install_phases\": [\"ArrayCableInstallation\"]\n", + "}\n", + "\n", + "# Run\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "# Outputs\n", + "df = pd.DataFrame(project.actions)\n", + "df.iloc[0:10]\n", + "\n", + "# There are now three vessel mobilizations at the beginning of the installation.\n", + "# The first process to be completed is the trenching (\"Dig Trench\"). After this is completed the other vessels will begin their tasks." ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "config = {\n", - " \"array_cable_install_vessel\": \"example_cable_lay_vessel\", # This vessel will lay the cable but will not bury it.\n", - " \"array_cable_bury_vessel\": \"example_cable_lay_vessel\", # This vessel will complete the burial process separate from the installation vessel.\n", - " \"array_cable_trench_vessel\": \"example_cable_lay_vessel\", # This vessel will complete the trenching process prior to the other two vessels beginning their work.\n", - " \n", - " \"site\": {\"distance\": 20, \"depth\": 35},\n", - " \"port\": {},\n", - " \"array_system\": {\n", - " \"system_cost\": 50e6,\n", - " \"cables\": {\n", - " \"ExampleCable\": {\n", - " \"linear_density\": 40, # t/km\n", - " \"cable_sections\": [(2, 25), (1, 25)] # (length, num) pairs. This example: 25 2km cables and 25 1km cables .\n", - " }\n", - " }\n", - " },\n", - " \n", - " \"install_phases\": [\"ArrayCableInstallation\"]\n", - "}\n", - "\n", - "# Run\n", - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "# Outputs\n", - "df = pd.DataFrame(project.actions)\n", - "df.iloc[0:10]\n", - "\n", - "# There are now three vessel mobilizations at the beginning of the installation.\n", - "# The first process to be completed is the trenching (\"Dig Trench\"). After this is completed the other vessels will begin their tasks." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/Example - Cash Flow.ipynb b/examples/Example - Cash Flow.ipynb index 6d7e0c48..09b18dd1 100644 --- a/examples/Example - Cash Flow.ipynb +++ b/examples/Example - Cash Flow.ipynb @@ -1,540 +1,540 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ORBIT Example - Cash Flow and NPV\n", - "\n", - "Last Updated: 07/28/2021" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# This notebook provides an example of the cash flow and net present value functionality in ORBIT.\n", - "\n", - "import os\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "from ORBIT import ProjectManager, load_config\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" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "config = load_config(\"configs/example_fixed_project.yaml\")\n", - "\n", - "# config['install_phases'] = {\n", - "# 'ArrayCableInstallation': 0,\n", - "# 'ExportCableInstallation': 2000,\n", - "# 'MonopileInstallation': ('ScourProtectionInstallation', 0.5),\n", - "# 'OffshoreSubstationInstallation': 0,\n", - "# 'ScourProtectionInstallation': 0,\n", - "# 'TurbineInstallation': ('MonopileInstallation', 0.1)\n", - "# }" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For this example, a project with the following phases will be configured:\n", - "\n", - "- ProjectDevelopment\n", - "- MonopileDesign\n", - "- ArraySystemDesign\n", - "- ExportSystemDesign\n", - "- OffshoreSubstationDesign\n", - "- ArrayCableInstallation\n", - "- ExportCableInstallation\n", - "- MonopileInstallation\n", - "- OffshoreSubstationInstallation\n", - "- TurbineInstallation\n", - "\n", - "The configuration below represents a \"complete\" project that will be able to produce\n", - "power when the requisite pieces are done being installed. As each array string is able to\n", - "generate power, the project will begin to generate additional revenue and incur\n", - "O&M costs." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" - ] - } - ], - "source": [ - "project = ProjectManager(config, weather=weather)\n", - "project.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### NPV" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ORBIT Example - Cash Flow and NPV\n", + "\n", + "Last Updated: 07/28/2021" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Net Present Value: 426.31 M\n" - ] - } - ], - "source": [ - "# In addition to the other results shown in previous examples, the NPV of the project is available:\n", - "\n", - "print(f\"Net Present Value: {project.npv/1e6:.2f} M\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Project Progress + String Energization Points\n", - "\n", - "The \"progress points\" of the project are tracked in the output below. These are used to determine when array strings and turbines can be energized and revenue begins." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# This notebook provides an example of the cash flow and net present value functionality in ORBIT.\n", + "\n", + "import os\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from ORBIT import ProjectManager, load_config\n", + "\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, { - "data": { - "text/plain": [ - "[('Offshore Substation', 120.0925357142857),\n", - " ('Array String', 313.9859420289855),\n", - " ('Array String', 618.4459420289855),\n", - " ('Array String', 843.9059420289856),\n", - " ('Array String', 1253.1092753623188),\n", - " ('Substructure', 1496.5764009525235),\n", - " ('Substructure', 1516.3403019050465),\n", - " ('Substructure', 1534.1042028575694),\n", - " ('Substructure', 1551.8681038100924),\n", - " ('Substructure', 1569.6320047626155),\n", - " ('Substructure', 1627.3959057151385),\n", - " ('Substructure', 1675.1598066676615),\n", - " ('Array String', 1688.5692753623189),\n", - " ('Turbine', 1791.015338095949),\n", - " ('Turbine', 1842.1986714292825),\n", - " ('Substructure', 1888.7237076201845),\n", - " ('Turbine', 1893.382004762616),\n", - " ('Substructure', 1906.4876085727078),\n", - " ('Array String', 1918.029275362319),\n", - " ('Substructure', 1924.2515095252309),\n", - " ('Substructure', 1942.015410477754),\n", - " ('Turbine', 1944.5653380959493),\n", - " ('Substructure', 1959.7793114302772),\n", - " ('Substructure', 1977.5432123828004),\n", - " ('Turbine', 1997.7486714292827)]" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load the Project Configuration" ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.progress.data[:25]" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ + }, { - "data": { - "text/plain": [ - "([2626.8153260869567,\n", - " 2626.8153260869567,\n", - " 3208.7320047626126,\n", - " 3866.13200476261,\n", - " 4333.532004762608,\n", - " 4829.932004762606,\n", - " 5156.032004762603,\n", - " 5620.432004762601,\n", - " 5764.09867142927],\n", - " [6, 6, 6, 6, 6, 6, 6, 6, 2])" + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "config = load_config(\"configs/example_fixed_project.yaml\")\n", + "\n", + "# config['install_phases'] = {\n", + "# 'ArrayCableInstallation': 0,\n", + "# 'ExportCableInstallation': 2000,\n", + "# 'MonopileInstallation': ('ScourProtectionInstallation', 0.5),\n", + "# 'OffshoreSubstationInstallation': 0,\n", + "# 'ScourProtectionInstallation': 0,\n", + "# 'TurbineInstallation': ('MonopileInstallation', 0.1)\n", + "# }" ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.progress.energize_points" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "__Format__: [string installation times], [number of turbines energized]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Monthly Cash Flow\n", - "\n", - "The monthly cash flow is shown below.\n", - "\n", - "- Revenue is generated as each turbine and associated array string is powered and the export system has been installed.\n", - "- A simple generation model is implemented for now (constant NCF), however this is an area for future development.\n", - "- The expenses from each installation phase are collected and totaled per month.\n", - "- As turbines are powered, the project begins accruing additional operating expenses." - ] - }, - { - "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", - "
ExpensesRevenueCash Flow
01.159244e+070.0-1.159244e+07
19.592865e+060.0-9.592865e+06
27.878374e+070.0-7.878374e+07
31.748031e+071681920.0-1.579839e+07
41.231171e+072522880.0-9.788830e+06
51.000148e+074204800.0-5.796680e+06
68.155250e+065045760.0-3.109490e+06
78.677000e+067008000.0-1.669000e+06
83.750000e+067008000.03.258000e+06
93.750000e+067008000.03.258000e+06
103.750000e+067008000.03.258000e+06
113.750000e+067008000.03.258000e+06
123.750000e+067008000.03.258000e+06
133.750000e+067008000.03.258000e+06
143.750000e+067008000.03.258000e+06
153.750000e+067008000.03.258000e+06
163.750000e+067008000.03.258000e+06
173.750000e+067008000.03.258000e+06
183.750000e+067008000.03.258000e+06
193.750000e+067008000.03.258000e+06
203.750000e+067008000.03.258000e+06
213.750000e+067008000.03.258000e+06
223.750000e+067008000.03.258000e+06
233.750000e+067008000.03.258000e+06
243.750000e+067008000.03.258000e+06
\n", - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this example, a project with the following phases will be configured:\n", + "\n", + "- ProjectDevelopment\n", + "- MonopileDesign\n", + "- ArraySystemDesign\n", + "- ExportSystemDesign\n", + "- OffshoreSubstationDesign\n", + "- ArrayCableInstallation\n", + "- ExportCableInstallation\n", + "- MonopileInstallation\n", + "- OffshoreSubstationInstallation\n", + "- TurbineInstallation\n", + "\n", + "The configuration below represents a \"complete\" project that will be able to produce\n", + "power when the requisite pieces are done being installed. As each array string is able to\n", + "generate power, the project will begin to generate additional revenue and incur\n", + "O&M costs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/library'\n" + ] + } ], - "text/plain": [ - " Expenses Revenue Cash Flow\n", - "0 1.159244e+07 0.0 -1.159244e+07\n", - "1 9.592865e+06 0.0 -9.592865e+06\n", - "2 7.878374e+07 0.0 -7.878374e+07\n", - "3 1.748031e+07 1681920.0 -1.579839e+07\n", - "4 1.231171e+07 2522880.0 -9.788830e+06\n", - "5 1.000148e+07 4204800.0 -5.796680e+06\n", - "6 8.155250e+06 5045760.0 -3.109490e+06\n", - "7 8.677000e+06 7008000.0 -1.669000e+06\n", - "8 3.750000e+06 7008000.0 3.258000e+06\n", - "9 3.750000e+06 7008000.0 3.258000e+06\n", - "10 3.750000e+06 7008000.0 3.258000e+06\n", - "11 3.750000e+06 7008000.0 3.258000e+06\n", - "12 3.750000e+06 7008000.0 3.258000e+06\n", - "13 3.750000e+06 7008000.0 3.258000e+06\n", - "14 3.750000e+06 7008000.0 3.258000e+06\n", - "15 3.750000e+06 7008000.0 3.258000e+06\n", - "16 3.750000e+06 7008000.0 3.258000e+06\n", - "17 3.750000e+06 7008000.0 3.258000e+06\n", - "18 3.750000e+06 7008000.0 3.258000e+06\n", - "19 3.750000e+06 7008000.0 3.258000e+06\n", - "20 3.750000e+06 7008000.0 3.258000e+06\n", - "21 3.750000e+06 7008000.0 3.258000e+06\n", - "22 3.750000e+06 7008000.0 3.258000e+06\n", - "23 3.750000e+06 7008000.0 3.258000e+06\n", - "24 3.750000e+06 7008000.0 3.258000e+06" + "source": [ + "project = ProjectManager(config, weather=weather)\n", + "project.run()" ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.DataFrame(list(zip(\n", - " project.monthly_expenses.values(),\n", - " project.monthly_revenue.values(),\n", - " project.cash_flow.values()\n", - ")), columns=[\"Expenses\", \"Revenue\", \"Cash Flow\"])\n", - "\n", - "df.head(25)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Cash Flow Figure\n", - "\n", - "Play around with the start dates of the configuration above. As the dates are moved around, the underlying expenses and generation will shift, affecting the net present value of the project." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### NPV" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Net Present Value: 426.31 M\n" + ] + } + ], + "source": [ + "# In addition to the other results shown in previous examples, the NPV of the project is available:\n", + "\n", + "print(f\"Net Present Value: {project.npv/1e6:.2f} M\")" + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Project Progress + String Energization Points\n", + "\n", + "The \"progress points\" of the project are tracked in the output below. These are used to determine when array strings and turbines can be energized and revenue begins." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Offshore Substation', 120.0925357142857),\n", + " ('Array String', 313.9859420289855),\n", + " ('Array String', 618.4459420289855),\n", + " ('Array String', 843.9059420289856),\n", + " ('Array String', 1253.1092753623188),\n", + " ('Substructure', 1496.5764009525235),\n", + " ('Substructure', 1516.3403019050465),\n", + " ('Substructure', 1534.1042028575694),\n", + " ('Substructure', 1551.8681038100924),\n", + " ('Substructure', 1569.6320047626155),\n", + " ('Substructure', 1627.3959057151385),\n", + " ('Substructure', 1675.1598066676615),\n", + " ('Array String', 1688.5692753623189),\n", + " ('Turbine', 1791.015338095949),\n", + " ('Turbine', 1842.1986714292825),\n", + " ('Substructure', 1888.7237076201845),\n", + " ('Turbine', 1893.382004762616),\n", + " ('Substructure', 1906.4876085727078),\n", + " ('Array String', 1918.029275362319),\n", + " ('Substructure', 1924.2515095252309),\n", + " ('Substructure', 1942.015410477754),\n", + " ('Turbine', 1944.5653380959493),\n", + " ('Substructure', 1959.7793114302772),\n", + " ('Substructure', 1977.5432123828004),\n", + " ('Turbine', 1997.7486714292827)]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.progress.data[:25]" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([2626.8153260869567,\n", + " 2626.8153260869567,\n", + " 3208.7320047626126,\n", + " 3866.13200476261,\n", + " 4333.532004762608,\n", + " 4829.932004762606,\n", + " 5156.032004762603,\n", + " 5620.432004762601,\n", + " 5764.09867142927],\n", + " [6, 6, 6, 6, 6, 6, 6, 6, 2])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.progress.energize_points" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "__Format__: [string installation times], [number of turbines energized]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Monthly Cash Flow\n", + "\n", + "The monthly cash flow is shown below.\n", + "\n", + "- Revenue is generated as each turbine and associated array string is powered and the export system has been installed.\n", + "- A simple generation model is implemented for now (constant NCF), however this is an area for future development.\n", + "- The expenses from each installation phase are collected and totaled per month.\n", + "- As turbines are powered, the project begins accruing additional operating expenses." + ] + }, + { + "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", + "
ExpensesRevenueCash Flow
01.159244e+070.0-1.159244e+07
19.592865e+060.0-9.592865e+06
27.878374e+070.0-7.878374e+07
31.748031e+071681920.0-1.579839e+07
41.231171e+072522880.0-9.788830e+06
51.000148e+074204800.0-5.796680e+06
68.155250e+065045760.0-3.109490e+06
78.677000e+067008000.0-1.669000e+06
83.750000e+067008000.03.258000e+06
93.750000e+067008000.03.258000e+06
103.750000e+067008000.03.258000e+06
113.750000e+067008000.03.258000e+06
123.750000e+067008000.03.258000e+06
133.750000e+067008000.03.258000e+06
143.750000e+067008000.03.258000e+06
153.750000e+067008000.03.258000e+06
163.750000e+067008000.03.258000e+06
173.750000e+067008000.03.258000e+06
183.750000e+067008000.03.258000e+06
193.750000e+067008000.03.258000e+06
203.750000e+067008000.03.258000e+06
213.750000e+067008000.03.258000e+06
223.750000e+067008000.03.258000e+06
233.750000e+067008000.03.258000e+06
243.750000e+067008000.03.258000e+06
\n", + "
" + ], + "text/plain": [ + " Expenses Revenue Cash Flow\n", + "0 1.159244e+07 0.0 -1.159244e+07\n", + "1 9.592865e+06 0.0 -9.592865e+06\n", + "2 7.878374e+07 0.0 -7.878374e+07\n", + "3 1.748031e+07 1681920.0 -1.579839e+07\n", + "4 1.231171e+07 2522880.0 -9.788830e+06\n", + "5 1.000148e+07 4204800.0 -5.796680e+06\n", + "6 8.155250e+06 5045760.0 -3.109490e+06\n", + "7 8.677000e+06 7008000.0 -1.669000e+06\n", + "8 3.750000e+06 7008000.0 3.258000e+06\n", + "9 3.750000e+06 7008000.0 3.258000e+06\n", + "10 3.750000e+06 7008000.0 3.258000e+06\n", + "11 3.750000e+06 7008000.0 3.258000e+06\n", + "12 3.750000e+06 7008000.0 3.258000e+06\n", + "13 3.750000e+06 7008000.0 3.258000e+06\n", + "14 3.750000e+06 7008000.0 3.258000e+06\n", + "15 3.750000e+06 7008000.0 3.258000e+06\n", + "16 3.750000e+06 7008000.0 3.258000e+06\n", + "17 3.750000e+06 7008000.0 3.258000e+06\n", + "18 3.750000e+06 7008000.0 3.258000e+06\n", + "19 3.750000e+06 7008000.0 3.258000e+06\n", + "20 3.750000e+06 7008000.0 3.258000e+06\n", + "21 3.750000e+06 7008000.0 3.258000e+06\n", + "22 3.750000e+06 7008000.0 3.258000e+06\n", + "23 3.750000e+06 7008000.0 3.258000e+06\n", + "24 3.750000e+06 7008000.0 3.258000e+06" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.DataFrame(list(zip(\n", + " project.monthly_expenses.values(),\n", + " project.monthly_revenue.values(),\n", + " project.cash_flow.values()\n", + ")), columns=[\"Expenses\", \"Revenue\", \"Cash Flow\"])\n", + "\n", + "df.head(25)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cash Flow Figure\n", + "\n", + "Play around with the start dates of the configuration above. As the dates are moved around, the underlying expenses and generation will shift, affecting the net present value of the project." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6, 4), dpi=200)\n", + "axis = fig.add_subplot(111)\n", + "\n", + "last = 24\n", + "\n", + "df.loc[:last, \"Cash Flow\"].plot(kind='bar', ax=axis)\n", + "\n", + "## Formatting\n", + "_ = axis.axhline(0, color='k', lw=0.5)\n", + "\n", + "# Axis Labels\n", + "axis.set_xlabel(\"Month\")\n", + "\n", + "xticks = []\n", + "for i, tick in enumerate(axis.get_xticklabels()):\n", + " tick.set_rotation(0)\n", + " tick.set_fontsize(8)\n", + " xticks.append(tick)\n", + " \n", + "# xticks = [str(item.get_text()) for item in axis.get_xticklabels()]\n", + "xticks[-2] = \"...\"\n", + "xticks[-1] = str(df.index.max())\n", + "\n", + "_ = axis.set_xticklabels(xticks)\n", + "\n", + "axis.set_ylabel(\"Cash Flow ($M)\")\n", + "axis.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, loc: \"{:.0f}M\".format(int(x) / 1e6)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "fig = plt.figure(figsize=(6, 4), dpi=200)\n", - "axis = fig.add_subplot(111)\n", - "\n", - "last = 24\n", - "\n", - "df.loc[:last, \"Cash Flow\"].plot(kind='bar', ax=axis)\n", - "\n", - "## Formatting\n", - "_ = axis.axhline(0, color='k', lw=0.5)\n", - "\n", - "# Axis Labels\n", - "axis.set_xlabel(\"Month\")\n", - "\n", - "xticks = []\n", - "for i, tick in enumerate(axis.get_xticklabels()):\n", - " tick.set_rotation(0)\n", - " tick.set_fontsize(8)\n", - " xticks.append(tick)\n", - " \n", - "# xticks = [str(item.get_text()) for item in axis.get_xticklabels()]\n", - "xticks[-2] = \"...\"\n", - "xticks[-1] = str(df.index.max())\n", - "\n", - "_ = axis.set_xticklabels(xticks)\n", - "\n", - "axis.set_ylabel(\"Cash Flow ($M)\")\n", - "axis.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, loc: \"{:.0f}M\".format(int(x) / 1e6)))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/Example - Custom Array Layout.ipynb b/examples/Example - Custom Array Layout.ipynb index b091c0e0..d4932564 100644 --- a/examples/Example - Custom Array Layout.ipynb +++ b/examples/Example - Custom Array Layout.ipynb @@ -1,2132 +1,2132 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Custom Array Cabling Layout Example\n", - "## Dudgeon Windfarm\n", - "\n", - "\n", - "#### Author: Rob Hammond\n", - "#### Date: 4 May 2020\n", - "#### Update: 30 March 2021\n", - "\n", - "\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", - "\n", - "This notebook will guide you through four of the main use cases on using the custom array cable layout functionality of `ORBIT` for when custom turbine locations, cable lengths or burial speeds are needed.\n", - "\n", - "**Note:** All array cable layout files are CSVs, which can be edited in Microsoft Excel.\n", - "\n", - "**Update:** This example was updated to work with ORBIT >= 1.0.0" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '../library'\n" - ] - } - ], - "source": [ - "import os\n", - "from copy import deepcopy\n", - "from pprint import pprint\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "\n", - "import ORBIT\n", - "from ORBIT import ProjectManager\n", - "from ORBIT.core import library\n", - "from ORBIT.phases.design import CustomArraySystemDesign\n", - "from ORBIT.phases.install import ArrayCableInstallation\n", - "\n", - "# initialize the library location\n", - "library.initialize_library(\"../library\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Contents\n", - " - [Overview](#overview): How to use the inputs\n", - " - [Case 1](#case_1): Needing to know what to collect\n", - " - [Case 2](#case_2): Coordinates with a straight-line distance for cable length\n", - " - [Case 3](#case_3): Using distance from a reference point\n", - " - [Case 4](#case_4): Adjusting for exclusions in the cable paths\n", - " - [Case 5](#case_5): Fully customizing the cabling parameters\n", - " - [Applying the cases to `ArrayCableInstallation`](#running)\n", - " - [Using `ProjectManager` to model the entire process](#project_manager)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Overview\n", - "\n", - "#### Before starting it is important to demonstrate how to create a configuration file or how to set up a customized layout file.\n", - "\n", - "In the highest level of this repository there is a folder called `library` where all of the example data for this notebook is going to be stored. While any folder could be used, the folder structure must be strictly adhered to. More details on this structure can be found [here](https://github.com/WISDEM/ORBIT/blob/master/ORBIT/library.py#L9-L23).\n", - "\n", - "For this example of how to setup a configuration, I will be using the file `/ORBIT/library/project/config/example_custom_array_simple.yaml`. YAML' files are used for configuration throughout this codebase due their ease of encoding and loading `Python` data types.\n", - "\n", - "Now, we will load the configuration file and display it below." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Custom Array Cabling Layout Example\n", + "## Dudgeon Windfarm\n", + "\n", + "\n", + "#### Author: Rob Hammond\n", + "#### Date: 4 May 2020\n", + "#### Update: 30 March 2021\n", + "\n", + "\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", + "\n", + "This notebook will guide you through four of the main use cases on using the custom array cable layout functionality of `ORBIT` for when custom turbine locations, cable lengths or burial speeds are needed.\n", + "\n", + "**Note:** All array cable layout files are CSVs, which can be edited in Microsoft Excel.\n", + "\n", + "**Update:** This example was updated to work with ORBIT >= 1.0.0" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_array'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}\n" - ] - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_simple\")\n", - "pprint(config)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### A couple of things to notice in the configuration file for a custom array layout:\n", - "```python\n", - "{\n", - " # Array cabling system specific data configuration\n", - " '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", - " \n", - " # A YAML file named dudgeon_array.csv found in the same location\n", - " 'location_data': 'dudgeon_array'},\n", - " \n", - " # We are using a custom layout and the Dudgeon contains 67 turbines\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " \n", - " # The average water depth at the site\n", - " 'site': {'depth': 20},\n", - " \n", - " # Turbine details (optional for custom)\n", - " 'turbine': 'SWT_6MW_154m_110m'\n", - "}\n", - "```\n", - "\n", - "#### Now, let's see what is contained within the additional files from the configuration dictionary\n", - "\n", - "It should be noted that running the design class extracts the data from the files automatically to produce the below output." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '../library'\n" + ] + } + ], + "source": [ + "import os\n", + "from copy import deepcopy\n", + "from pprint import pprint\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import ORBIT\n", + "from ORBIT import ProjectManager\n", + "from ORBIT.core import library\n", + "from ORBIT.phases.design import CustomArraySystemDesign\n", + "from ORBIT.phases.install import ArrayCableInstallation\n", + "\n", + "# initialize the library location\n", + "library.initialize_library(\"../library\")" + ] + }, { - "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" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contents\n", + " - [Overview](#overview): How to use the inputs\n", + " - [Case 1](#case_1): Needing to know what to collect\n", + " - [Case 2](#case_2): Coordinates with a straight-line distance for cable length\n", + " - [Case 3](#case_3): Using distance from a reference point\n", + " - [Case 4](#case_4): Adjusting for exclusions in the cable paths\n", + " - [Case 5](#case_5): Fully customizing the cabling parameters\n", + " - [Applying the cases to `ArrayCableInstallation`](#running)\n", + " - [Using `ProjectManager` to model the entire process](#project_manager)" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/jnunemak/Fun/repos/ORBIT/ORBIT/phases/design/array_system_design.py:881\n", - "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." - ] - } - ], - "source": [ - "array = CustomArraySystemDesign(config)\n", - "array.run()\n", - "pprint(array.config)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### When the `dudgeon_array.csv` file is loaded, it is not passed back into the configuration dictionary, so let's dissect this file:\n", - "\n", - "1. The file must have all of the columns shown below (not case-sensitive).\n", - " - All columns must be completely filled out for turbines (note on substation(s) following).\n", - " - `cable_length` and `bury_speed` are optional and if these are not known, simply fill with a 0.\n", - "2. A latitude and longitude must be provided for all turbines and substation(s). This can either be a WGS-84 decimal coordinate or a distance-based \"coordinate\" where latitude and longitude are the distances from some reference point, in kilometers; see [Case 3](#case_3) for more details.\n", - "2. Define the offshore substation(s)\n", - " - For each substation, the values in columns `id` and `substation_id` _must_ be the same.\n", - " - There is no need to fill in any data for the columns `String`, `Order`, `cable_length` and `bury_speed`.\n", - "3. Define the turbines\n", - " - Each turbine should have a reference to its substation in the `substation_id` column.\n", - " - In this example, there is one substaion, so all of the values are \"DOW_OSS\".\n", - " - `string` and `order` should be 0-indexed for their ordering and not skip any numbers.\n", - " - In this example, the strings are ordered in clock-wise order starting from the string with turbines labeled with an \"A\" in the [Call to Mariners](http://dudgeonoffshorewind.co.uk/news/notices/Dudgeon%20-%20Notice%20to%20Mariners%20wk25.pdf)\n", - " - The ordering on a string should travel from substation to the farthest end of the cable" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Overview\n", + "\n", + "#### Before starting it is important to demonstrate how to create a configuration file or how to set up a customized layout file.\n", + "\n", + "In the highest level of this repository there is a folder called `library` where all of the example data for this notebook is going to be stored. While any folder could be used, the folder structure must be strictly adhered to. More details on this structure can be found [here](https://github.com/WISDEM/ORBIT/blob/master/ORBIT/library.py#L9-L23).\n", + "\n", + "For this example of how to setup a configuration, I will be using the file `/ORBIT/library/project/config/example_custom_array_simple.yaml`. YAML' files are used for configuration throughout this codebase due their ease of encoding and loading `Python` data types.\n", + "\n", + "Now, we will load the configuration file and display it below." + ] + }, { - "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", - "
idsubstation_idnameLongitudeLatitudeStringOrdercable_lengthbury_speed
1DAE_A1DOW_OSSDAE_A11.35878353.2439500000
2DAD_A2DOW_OSSDAD_A21.34903353.2484670100
3DAC_A3DOW_OSSDAC_A31.33928353.2529830200
4DAB_A4DOW_OSSDAB_A41.32955053.2575000300
5DAA_A5DOW_OSSDAA_A51.31980053.2620170400
..............................
59DAF_L2DOW_OSSDAF_L21.36853353.23943311100
60DAG_L3DOW_OSSDAG_L31.37825053.23491711200
61DAH_L4DOW_OSSDAH_L41.38800053.23040011300
62DAJ_L5DOW_OSSDAJ_L51.39775053.22588311400
0DOW_OSSDOW_OSSDOW_OSS1.37876753.264800
\n", - "

68 rows × 9 columns

\n", - "
" + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'location_data': 'dudgeon_array'},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}\n" + ] + } ], - "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", - ".. ... ... ... ... ... ... ... \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", - "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", - ".. ... ... \n", - "59 0 0 \n", - "60 0 0 \n", - "61 0 0 \n", - "62 0 0 \n", - "0 \n", - "\n", - "[68 rows x 9 columns]" + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_simple\")\n", + "pprint(config)" ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv(\"../library/cables/dudgeon_array.csv\").fillna(\"\")\n", - "df.sort_values(by=[\"String\", \"Order\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Case 1: Needing to know what to collect\n", - "\n", - "Here we know that we need to have a csv created to input all the data but need to see what data is necessary to collect.\n", - "\n", - "\n", - "First, we need to load in the configuration dictionary. Then, we will create a \"starter\" file that can be filled in for a new project, which will be saved in the \"library\"." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_array_no_data'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}\n", - "\n", - "+--------------------------------+\n", - "| PROJECT SPECIFICATIONS |\n", - "+---------------------------+----+\n", - "| N turbines full string | 6 |\n", - "| N full strings | 11 |\n", - "| N turbines partial string | 1 |\n", - "| N partial strings | 1 |\n", - "+---------------------------+----+\n", - "Saving custom array CSV to: /cables/dudgeon_array_no_data.csv\n" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### A couple of things to notice in the configuration file for a custom array layout:\n", + "```python\n", + "{\n", + " # Array cabling system specific data configuration\n", + " '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", + " \n", + " # A YAML file named dudgeon_array.csv found in the same location\n", + " 'location_data': 'dudgeon_array'},\n", + " \n", + " # We are using a custom layout and the Dudgeon contains 67 turbines\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " \n", + " # The average water depth at the site\n", + " 'site': {'depth': 20},\n", + " \n", + " # Turbine details (optional for custom)\n", + " 'turbine': 'SWT_6MW_154m_110m'\n", + "}\n", + "```\n", + "\n", + "#### Now, let's see what is contained within the additional files from the configuration dictionary\n", + "\n", + "It should be noted that running the design class extracts the data from the files automatically to produce the below output." + ] }, { - "name": "stdin", - "output_type": "stream", - "text": [ - "../library/cables/dudgeon_array_no_data.csv already exists, overwrite [y/n]? y\n" - ] + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "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" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: /Users/jnunemak/Fun/repos/ORBIT/ORBIT/phases/design/array_system_design.py:881\n", + "Missing data in columns ['cable_length', 'bury_speed']; all values will be calculated." + ] + } + ], + "source": [ + "array = CustomArraySystemDesign(config)\n", + "array.run()\n", + "pprint(array.config)" + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Save complete!\n" - ] - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_no_data\")\n", - "pprint(config)\n", - "print()\n", - "\n", - "array = CustomArraySystemDesign(config)\n", - "save_path = array.config[\"array_system_design\"][\"location_data\"]\n", - "array.create_project_csv(save_path)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Let's take a look at the data to see what it output\n", - "\n", - "**NOTE**:\n", - " 1. The offshore substation (row 0) is indicated via the `id` and `substation_id` columns being equal\n", - " 2. For substaions only the `id`, `substation_id`, `name`, `latitued`, and `longitude` are required\n", - " 3. `cable_length` and `bury_speed` are optional columns for turbines\n", - " 4. `string` and `order` are filled out to maximize the length of a string given the cable(s) provided so in this case we can have up to 6 turbines in a string. **These are also, very importantly, starting their numbering with 0.**" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "dudgeon_array_no_data = pd.read_csv(\"../library/cables/dudgeon_array_no_data.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### When the `dudgeon_array.csv` file is loaded, it is not passed back into the configuration dictionary, so let's dissect this file:\n", + "\n", + "1. The file must have all of the columns shown below (not case-sensitive).\n", + " - All columns must be completely filled out for turbines (note on substation(s) following).\n", + " - `cable_length` and `bury_speed` are optional and if these are not known, simply fill with a 0.\n", + "2. A latitude and longitude must be provided for all turbines and substation(s). This can either be a WGS-84 decimal coordinate or a distance-based \"coordinate\" where latitude and longitude are the distances from some reference point, in kilometers; see [Case 3](#case_3) for more details.\n", + "2. Define the offshore substation(s)\n", + " - For each substation, the values in columns `id` and `substation_id` _must_ be the same.\n", + " - There is no need to fill in any data for the columns `String`, `Order`, `cable_length` and `bury_speed`.\n", + "3. Define the turbines\n", + " - Each turbine should have a reference to its substation in the `substation_id` column.\n", + " - In this example, there is one substaion, so all of the values are \"DOW_OSS\".\n", + " - `string` and `order` should be 0-indexed for their ordering and not skip any numbers.\n", + " - In this example, the strings are ordered in clock-wise order starting from the string with turbines labeled with an \"A\" in the [Call to Mariners](http://dudgeonoffshorewind.co.uk/news/notices/Dudgeon%20-%20Notice%20to%20Mariners%20wk25.pdf)\n", + " - The ordering on a string should travel from substation to the farthest end of the cable" + ] + }, { - "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", - "
idsubstation_idnamelatitudelongitudestringordercable_lengthbury_speed
0oss1oss1offshore_substation0.00.0NaNNaNNaNNaN
1t0oss1turbine-00.00.00.00.00.00.0
2t1oss1turbine-10.00.00.01.00.00.0
3t2oss1turbine-20.00.00.02.00.00.0
4t3oss1turbine-30.00.00.03.00.00.0
..............................
63t62oss1turbine-620.00.010.02.00.00.0
64t63oss1turbine-630.00.010.03.00.00.0
65t64oss1turbine-640.00.010.04.00.00.0
66t65oss1turbine-650.00.010.05.00.00.0
67t66oss1turbine-660.00.011.00.00.00.0
\n", - "

68 rows × 9 columns

\n", - "
" + "cell_type": "code", + "execution_count": 4, + "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", + "
idsubstation_idnameLongitudeLatitudeStringOrdercable_lengthbury_speed
1DAE_A1DOW_OSSDAE_A11.35878353.2439500000
2DAD_A2DOW_OSSDAD_A21.34903353.2484670100
3DAC_A3DOW_OSSDAC_A31.33928353.2529830200
4DAB_A4DOW_OSSDAB_A41.32955053.2575000300
5DAA_A5DOW_OSSDAA_A51.31980053.2620170400
..............................
59DAF_L2DOW_OSSDAF_L21.36853353.23943311100
60DAG_L3DOW_OSSDAG_L31.37825053.23491711200
61DAH_L4DOW_OSSDAH_L41.38800053.23040011300
62DAJ_L5DOW_OSSDAJ_L51.39775053.22588311400
0DOW_OSSDOW_OSSDOW_OSS1.37876753.264800
\n", + "

68 rows \u00d7 9 columns

\n", + "
" + ], + "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", + ".. ... ... ... ... ... ... ... \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", + "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", + ".. ... ... \n", + "59 0 0 \n", + "60 0 0 \n", + "61 0 0 \n", + "62 0 0 \n", + "0 \n", + "\n", + "[68 rows x 9 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " id substation_id name latitude longitude string \\\n", - "0 oss1 oss1 offshore_substation 0.0 0.0 NaN \n", - "1 t0 oss1 turbine-0 0.0 0.0 0.0 \n", - "2 t1 oss1 turbine-1 0.0 0.0 0.0 \n", - "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", - "\n", - " order cable_length bury_speed \n", - "0 NaN NaN NaN \n", - "1 0.0 0.0 0.0 \n", - "2 1.0 0.0 0.0 \n", - "3 2.0 0.0 0.0 \n", - "4 3.0 0.0 0.0 \n", - ".. ... ... ... \n", - "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", - "\n", - "[68 rows x 9 columns]" + "source": [ + "df = pd.read_csv(\"../library/cables/dudgeon_array.csv\").fillna(\"\")\n", + "df.sort_values(by=[\"String\", \"Order\"])" ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dudgeon_array_no_data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Case 2: Standard straight-line distance for cable lengths\n", - "\n", - "Here we have the turbine and offshore substation locations that were extracted from the data source in the header but nothing specific regarding the actual cable lengths or the cable burial speeds for each section." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_array'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}\n" - ] - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_simple\")\n", - "pprint(config)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "array = CustomArraySystemDesign(config)\n", - "array.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Let's take a look at the data to see what it output\n", - "\n", - "**NOTE**: Here the cable length and bury speed are still set to 0 to indicate that they are unknown" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Case 1: Needing to know what to collect\n", + "\n", + "Here we know that we need to have a csv created to input all the data but need to see what data is necessary to collect.\n", + "\n", + "\n", + "First, we need to load in the configuration dictionary. Then, we will create a \"starter\" file that can be filled in for a new project, which will be saved in the \"library\"." ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "array.plot_array_system(show=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### It should be noted here that the the latitude and longitude here are WGS-84 decimal coordinates" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "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", - "
idsubstation_idsubstation_namesubstation_latitudesubstation_longitudeturbine_nameturbine_latitudeturbine_longitudestringordercable_lengthbury_speed
0DAE_A1DOW_OSSDOW_OSS53.26481.378767DAE_A153.2439501.358783000.00.0
1DAD_A2DOW_OSSDOW_OSS53.26481.378767DAD_A253.2484671.349033010.00.0
2DAC_A3DOW_OSSDOW_OSS53.26481.378767DAC_A353.2529831.339283020.00.0
3DAB_A4DOW_OSSDOW_OSS53.26481.378767DAB_A453.2575001.329550030.00.0
4DAA_A5DOW_OSSDOW_OSS53.26481.378767DAA_A553.2620171.319800040.00.0
.......................................
57DCE_L1DOW_OSSDOW_OSS53.26481.378767DCE_L153.2517831.3688331100.00.0
58DAF_L2DOW_OSSDOW_OSS53.26481.378767DAF_L253.2394331.3685331110.00.0
59DAG_L3DOW_OSSDOW_OSS53.26481.378767DAG_L353.2349171.3782501120.00.0
60DAH_L4DOW_OSSDOW_OSS53.26481.378767DAH_L453.2304001.3880001130.00.0
61DAJ_L5DOW_OSSDOW_OSS53.26481.378767DAJ_L553.2258831.3977501140.00.0
\n", - "

67 rows × 12 columns

\n", - "
" + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'location_data': 'dudgeon_array_no_data'},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}\n", + "\n", + "+--------------------------------+\n", + "| PROJECT SPECIFICATIONS |\n", + "+---------------------------+----+\n", + "| N turbines full string | 6 |\n", + "| N full strings | 11 |\n", + "| N turbines partial string | 1 |\n", + "| N partial strings | 1 |\n", + "+---------------------------+----+\n", + "Saving custom array CSV 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" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Save complete!\n" + ] + } ], - "text/plain": [ - " id substation_id substation_name substation_latitude \\\n", - "0 DAE_A1 DOW_OSS DOW_OSS 53.2648 \n", - "1 DAD_A2 DOW_OSS DOW_OSS 53.2648 \n", - "2 DAC_A3 DOW_OSS DOW_OSS 53.2648 \n", - "3 DAB_A4 DOW_OSS DOW_OSS 53.2648 \n", - "4 DAA_A5 DOW_OSS DOW_OSS 53.2648 \n", - ".. ... ... ... ... \n", - "57 DCE_L1 DOW_OSS DOW_OSS 53.2648 \n", - "58 DAF_L2 DOW_OSS DOW_OSS 53.2648 \n", - "59 DAG_L3 DOW_OSS DOW_OSS 53.2648 \n", - "60 DAH_L4 DOW_OSS DOW_OSS 53.2648 \n", - "61 DAJ_L5 DOW_OSS DOW_OSS 53.2648 \n", - "\n", - " substation_longitude turbine_name turbine_latitude turbine_longitude \\\n", - "0 1.378767 DAE_A1 53.243950 1.358783 \n", - "1 1.378767 DAD_A2 53.248467 1.349033 \n", - "2 1.378767 DAC_A3 53.252983 1.339283 \n", - "3 1.378767 DAB_A4 53.257500 1.329550 \n", - "4 1.378767 DAA_A5 53.262017 1.319800 \n", - ".. ... ... ... ... \n", - "57 1.378767 DCE_L1 53.251783 1.368833 \n", - "58 1.378767 DAF_L2 53.239433 1.368533 \n", - "59 1.378767 DAG_L3 53.234917 1.378250 \n", - "60 1.378767 DAH_L4 53.230400 1.388000 \n", - "61 1.378767 DAJ_L5 53.225883 1.397750 \n", - "\n", - " string order cable_length bury_speed \n", - "0 0 0 0.0 0.0 \n", - "1 0 1 0.0 0.0 \n", - "2 0 2 0.0 0.0 \n", - "3 0 3 0.0 0.0 \n", - "4 0 4 0.0 0.0 \n", - ".. ... ... ... ... \n", - "57 11 0 0.0 0.0 \n", - "58 11 1 0.0 0.0 \n", - "59 11 2 0.0 0.0 \n", - "60 11 3 0.0 0.0 \n", - "61 11 4 0.0 0.0 \n", - "\n", - "[67 rows x 12 columns]" + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_no_data\")\n", + "pprint(config)\n", + "print()\n", + "\n", + "array = CustomArraySystemDesign(config)\n", + "save_path = array.config[\"array_system_design\"][\"location_data\"]\n", + "array.create_project_csv(save_path)" ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "array.location_data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Now let's look at the cost for this cabling setup by each type of cable as well as the total cost" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", - "for cable, cost in array.cost_by_type.items():\n", - " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", - " \n", - "print(f\"{'Total':<16}| ${array.total_cable_cost:>15,.2f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Case 3: Distance-based \"coordinate\" system\n", - "\n", - "In this case, we will consider each turbine and substation on a distance-based \"coordinate\" system where the longitude and latitude are the longitudinal (x direction) and latitudinal (y direction) **distances**, in kilometers, from a common reference point. We are still using the Dudgeon data, but the distances were computed outside of this example and the details are not be included.\n", - "\n", - "Below, we can see that the input file is still encoded in the exact same manner as [Case 2](#case_2), but latitude and longitude are relative distances and not proper coordinates." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Let's take a look at the data to see what it output\n", + "\n", + "**NOTE**:\n", + " 1. The offshore substation (row 0) is indicated via the `id` and `substation_id` columns being equal\n", + " 2. For substaions only the `id`, `substation_id`, `name`, `latitued`, and `longitude` are required\n", + " 3. `cable_length` and `bury_speed` are optional columns for turbines\n", + " 4. `string` and `order` are filled out to maximize the length of a string given the cable(s) provided so in this case we can have up to 6 turbines in a string. **These are also, very importantly, starting their numbering with 0.**" + ] + }, { - "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", - "
idsubstation_idnamelongitudelatitudestringordercable_lengthbury_speed
0DOW_OSSDOW_OSSDOW_OSS16.22990935.769173
1DAE_A1DOW_OSSDAE_A114.89084533.4507590000
2DAD_A2DOW_OSSDAD_A214.23752833.9530260100
3DAC_A3DOW_OSSDAC_A313.58421134.4551820200
4DAB_A4DOW_OSSDAB_A412.93203434.9574500300
..............................
63DCE_L1DOW_OSSDCE_L115.56426334.32174911000
64DAF_L2DOW_OSSDAF_L215.54416132.94849111100
65DAG_L3DOW_OSSDAG_L316.19526632.44633511200
66DAH_L4DOW_OSSDAH_L416.84858331.94406711300
67DAJ_L5DOW_OSSDAJ_L517.50189931.44180011400
\n", - "

68 rows × 9 columns

\n", - "
" + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "dudgeon_array_no_data = pd.read_csv(\"../library/cables/dudgeon_array_no_data.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
idsubstation_idnamelatitudelongitudestringordercable_lengthbury_speed
0oss1oss1offshore_substation0.00.0NaNNaNNaNNaN
1t0oss1turbine-00.00.00.00.00.00.0
2t1oss1turbine-10.00.00.01.00.00.0
3t2oss1turbine-20.00.00.02.00.00.0
4t3oss1turbine-30.00.00.03.00.00.0
..............................
63t62oss1turbine-620.00.010.02.00.00.0
64t63oss1turbine-630.00.010.03.00.00.0
65t64oss1turbine-640.00.010.04.00.00.0
66t65oss1turbine-650.00.010.05.00.00.0
67t66oss1turbine-660.00.011.00.00.00.0
\n", + "

68 rows \u00d7 9 columns

\n", + "
" + ], + "text/plain": [ + " id substation_id name latitude longitude string \\\n", + "0 oss1 oss1 offshore_substation 0.0 0.0 NaN \n", + "1 t0 oss1 turbine-0 0.0 0.0 0.0 \n", + "2 t1 oss1 turbine-1 0.0 0.0 0.0 \n", + "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", + "\n", + " order cable_length bury_speed \n", + "0 NaN NaN NaN \n", + "1 0.0 0.0 0.0 \n", + "2 1.0 0.0 0.0 \n", + "3 2.0 0.0 0.0 \n", + "4 3.0 0.0 0.0 \n", + ".. ... ... ... \n", + "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", + "\n", + "[68 rows x 9 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } ], - "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", - ".. ... ... ... ... ... ... ... \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", - "\n", - " cable_length bury_speed \n", - "0 \n", - "1 0 0 \n", - "2 0 0 \n", - "3 0 0 \n", - "4 0 0 \n", - ".. ... ... \n", - "63 0 0 \n", - "64 0 0 \n", - "65 0 0 \n", - "66 0 0 \n", - "67 0 0 \n", - "\n", - "[68 rows x 9 columns]" + "source": [ + "dudgeon_array_no_data" ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = pd.read_csv(\"../library/cables/dudgeon_distance_based.csv\", index_col=False).fillna(\"\")\n", - "df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### For this case we also add the `distance` argument to the `array_system_design` and set it to `True` to indicate we are dealing with distances." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'distance': True,\n", - " 'location_data': 'dudgeon_distance_based'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}\n" - ] - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_simple_distance_based\")\n", - "pprint(config)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### OR we can create the flag in the function call.\n", - "\n", - "**Note:** the configuration dictionary will always override this setting." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "array_distance = CustomArraySystemDesign(config, distance=True)\n", - "array_distance.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Let's take a look at the data to see what it output\n", - "\n", - "While some of the cable lengths may be slightly different, the spacing is still maintained, and we can see that this is the Dudgeon windfarm." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Case 2: Standard straight-line distance for cable lengths\n", + "\n", + "Here we have the turbine and offshore substation locations that were extracted from the data source in the header but nothing specific regarding the actual cable lengths or the cable burial speeds for each section." ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "array_distance.plot_array_system(show=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Now let's look at the cost for this cabling setup by each type of cable as well as the total cost and compare it to the previous case\n", - "\n", - "While there is a minor difference, this difference is small in comparison to the total project cost and errs in a more conservative direction." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "print(f\"{'Cable Type':<16} | {'Cost in USD (lat,lon)':>20} | {'Cost in USD (dist_lat,dist_lon)':>15}\")\n", - "for (cable1, cost1), (cable2, cost2) in zip(array.cost_by_type.items(), array_distance.cost_by_type.items()):\n", - " print(f\"{cable1:<16} | ${cost1:>20,.2f} | ${cost2:>15,.2f}\")\n", - " \n", - "print(f\"{'Total':<16} | ${array.total_cable_cost:>20,.2f} | ${array_distance.total_cable_cost:>15,.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Case 4: We want to account for some additions to the cable lengths due to exclusion zones\n", - "\n", - "This can be done with the `\"average_exclusion_percent\"` keyword in the configuration that can be seen below.\n", - "\n", - "**Note:**\n", - " 1. There is an average exclusion and is applied to each of the cable sections\n", - " 2. The plot won't change because it will not have details on the new paths so we'll only demonstrate the cost changes (a 4.8% increase, which is in line with the exclusion and the accounting for the site depth." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'location_data': 'dudgeon_array'},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}\n" + ] + } + ], + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_simple\")\n", + "pprint(config)" + ] + }, { - "data": { - "text/plain": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_array',\n", - " 'average_exclusion_percent': 0.05},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}" + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "array = CustomArraySystemDesign(config)\n", + "array.run()" ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_exclusions\")\n", - "config" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "array_exclusion = CustomArraySystemDesign(config)\n", - "array_exclusion.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", - "for cable, cost in array_exclusion.cost_by_type.items():\n", - " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", - " \n", - "print(f\"{'Total':<16}| ${array_exclusion.total_cable_cost:>15,.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Case 5: Customize the distances \n", - "\n", - "If we look at the map in the [Call to Mariners](http://dudgeonoffshorewind.co.uk/news/notices/Dudgeon%20-%20Notice%20to%20Mariners%20wk25.pdf) there are different sized exclusions in the cables, so for this example we'll change the distances from [Case 4](#case_4) where we used an average exclusion to be a bit different in each case by using the `cable_length` column. In addition, we will utilize the `bury_speed` column to demonstrate how these columns will be used.\n", - "\n", - "**Note:** this work was done outside the notebook, but can be uploaded as show in the example below.\n", - "\n", - "For this example, half of the windfarm will have different soil condition, so we will use our proxy: `bury_speed` by modifying the burial speed to be fast (0.5 km/h) and slow (0.05 km/hr), respectively, to account for sandy soil and rocky soil. The purpose of this is for passing through customized parameters in the design phase to be utilized in the installation phase as will be seen in the final two examples." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Let's take a look at the data to see what it output\n", + "\n", + "**NOTE**: Here the cable length and bury speed are still set to 0 to indicate that they are unknown" + ] + }, { - "data": { - "text/plain": [ - "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", - " 'location_data': 'dudgeon_custom'},\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " 'site': {'depth': 20},\n", - " 'turbine': 'SWT_6MW_154m_110m'}" + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "array.plot_array_system(show=True)" ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_custom\")\n", - "\n", - "# Note location_data the same one that was saved because I updated it!\n", - "config" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "array_custom = CustomArraySystemDesign(config)\n", - "array_custom.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Note that there are now cable lengths defined as well as burial speeds for installation" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "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", - "
idsubstation_idsubstation_namesubstation_latitudesubstation_longitudeturbine_nameturbine_latitudeturbine_longitudestringordercable_lengthbury_speed
0DAE_A1DOW_OSSDOW_OSS53.26481.378767DAE_A153.2439501.358783003.1352790.50
1DAD_A2DOW_OSSDOW_OSS53.26481.378767DAD_A253.2484671.349033010.9938600.50
2DAC_A3DOW_OSSDOW_OSS53.26481.378767DAC_A353.2529831.339283020.9937190.50
3DAB_A4DOW_OSSDOW_OSS53.26481.378767DAB_A453.2575001.329550030.9926990.50
4DAA_A5DOW_OSSDOW_OSS53.26481.378767DAA_A553.2620171.319800040.9936730.50
.......................................
62DCE_L1DOW_OSSDOW_OSS53.26481.378767DCE_L153.2517831.3688331101.7128220.05
63DAF_L2DOW_OSSDOW_OSS53.26481.378767DAF_L253.2394331.3685331111.4833180.05
64DAG_L3DOW_OSSDOW_OSS53.26481.378767DAG_L353.2349171.3782501120.9017210.05
65DAH_L4DOW_OSSDOW_OSS53.26481.378767DAH_L453.2304001.3880001130.9036790.05
66DAJ_L5DOW_OSSDOW_OSS53.26481.378767DAJ_L553.2258831.3977501140.9037360.05
\n", - "

67 rows × 12 columns

\n", - "
" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### It should be noted here that the the latitude and longitude here are WGS-84 decimal coordinates" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "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", + "
idsubstation_idsubstation_namesubstation_latitudesubstation_longitudeturbine_nameturbine_latitudeturbine_longitudestringordercable_lengthbury_speed
0DAE_A1DOW_OSSDOW_OSS53.26481.378767DAE_A153.2439501.358783000.00.0
1DAD_A2DOW_OSSDOW_OSS53.26481.378767DAD_A253.2484671.349033010.00.0
2DAC_A3DOW_OSSDOW_OSS53.26481.378767DAC_A353.2529831.339283020.00.0
3DAB_A4DOW_OSSDOW_OSS53.26481.378767DAB_A453.2575001.329550030.00.0
4DAA_A5DOW_OSSDOW_OSS53.26481.378767DAA_A553.2620171.319800040.00.0
.......................................
57DCE_L1DOW_OSSDOW_OSS53.26481.378767DCE_L153.2517831.3688331100.00.0
58DAF_L2DOW_OSSDOW_OSS53.26481.378767DAF_L253.2394331.3685331110.00.0
59DAG_L3DOW_OSSDOW_OSS53.26481.378767DAG_L353.2349171.3782501120.00.0
60DAH_L4DOW_OSSDOW_OSS53.26481.378767DAH_L453.2304001.3880001130.00.0
61DAJ_L5DOW_OSSDOW_OSS53.26481.378767DAJ_L553.2258831.3977501140.00.0
\n", + "

67 rows \u00d7 12 columns

\n", + "
" + ], + "text/plain": [ + " id substation_id substation_name substation_latitude \\\n", + "0 DAE_A1 DOW_OSS DOW_OSS 53.2648 \n", + "1 DAD_A2 DOW_OSS DOW_OSS 53.2648 \n", + "2 DAC_A3 DOW_OSS DOW_OSS 53.2648 \n", + "3 DAB_A4 DOW_OSS DOW_OSS 53.2648 \n", + "4 DAA_A5 DOW_OSS DOW_OSS 53.2648 \n", + ".. ... ... ... ... \n", + "57 DCE_L1 DOW_OSS DOW_OSS 53.2648 \n", + "58 DAF_L2 DOW_OSS DOW_OSS 53.2648 \n", + "59 DAG_L3 DOW_OSS DOW_OSS 53.2648 \n", + "60 DAH_L4 DOW_OSS DOW_OSS 53.2648 \n", + "61 DAJ_L5 DOW_OSS DOW_OSS 53.2648 \n", + "\n", + " substation_longitude turbine_name turbine_latitude turbine_longitude \\\n", + "0 1.378767 DAE_A1 53.243950 1.358783 \n", + "1 1.378767 DAD_A2 53.248467 1.349033 \n", + "2 1.378767 DAC_A3 53.252983 1.339283 \n", + "3 1.378767 DAB_A4 53.257500 1.329550 \n", + "4 1.378767 DAA_A5 53.262017 1.319800 \n", + ".. ... ... ... ... \n", + "57 1.378767 DCE_L1 53.251783 1.368833 \n", + "58 1.378767 DAF_L2 53.239433 1.368533 \n", + "59 1.378767 DAG_L3 53.234917 1.378250 \n", + "60 1.378767 DAH_L4 53.230400 1.388000 \n", + "61 1.378767 DAJ_L5 53.225883 1.397750 \n", + "\n", + " string order cable_length bury_speed \n", + "0 0 0 0.0 0.0 \n", + "1 0 1 0.0 0.0 \n", + "2 0 2 0.0 0.0 \n", + "3 0 3 0.0 0.0 \n", + "4 0 4 0.0 0.0 \n", + ".. ... ... ... ... \n", + "57 11 0 0.0 0.0 \n", + "58 11 1 0.0 0.0 \n", + "59 11 2 0.0 0.0 \n", + "60 11 3 0.0 0.0 \n", + "61 11 4 0.0 0.0 \n", + "\n", + "[67 rows x 12 columns]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " id substation_id substation_name substation_latitude \\\n", - "0 DAE_A1 DOW_OSS DOW_OSS 53.2648 \n", - "1 DAD_A2 DOW_OSS DOW_OSS 53.2648 \n", - "2 DAC_A3 DOW_OSS DOW_OSS 53.2648 \n", - "3 DAB_A4 DOW_OSS DOW_OSS 53.2648 \n", - "4 DAA_A5 DOW_OSS DOW_OSS 53.2648 \n", - ".. ... ... ... ... \n", - "62 DCE_L1 DOW_OSS DOW_OSS 53.2648 \n", - "63 DAF_L2 DOW_OSS DOW_OSS 53.2648 \n", - "64 DAG_L3 DOW_OSS DOW_OSS 53.2648 \n", - "65 DAH_L4 DOW_OSS DOW_OSS 53.2648 \n", - "66 DAJ_L5 DOW_OSS DOW_OSS 53.2648 \n", - "\n", - " substation_longitude turbine_name turbine_latitude turbine_longitude \\\n", - "0 1.378767 DAE_A1 53.243950 1.358783 \n", - "1 1.378767 DAD_A2 53.248467 1.349033 \n", - "2 1.378767 DAC_A3 53.252983 1.339283 \n", - "3 1.378767 DAB_A4 53.257500 1.329550 \n", - "4 1.378767 DAA_A5 53.262017 1.319800 \n", - ".. ... ... ... ... \n", - "62 1.378767 DCE_L1 53.251783 1.368833 \n", - "63 1.378767 DAF_L2 53.239433 1.368533 \n", - "64 1.378767 DAG_L3 53.234917 1.378250 \n", - "65 1.378767 DAH_L4 53.230400 1.388000 \n", - "66 1.378767 DAJ_L5 53.225883 1.397750 \n", - "\n", - " string order cable_length bury_speed \n", - "0 0 0 3.135279 0.50 \n", - "1 0 1 0.993860 0.50 \n", - "2 0 2 0.993719 0.50 \n", - "3 0 3 0.992699 0.50 \n", - "4 0 4 0.993673 0.50 \n", - ".. ... ... ... ... \n", - "62 11 0 1.712822 0.05 \n", - "63 11 1 1.483318 0.05 \n", - "64 11 2 0.901721 0.05 \n", - "65 11 3 0.903679 0.05 \n", - "66 11 4 0.903736 0.05 \n", - "\n", - "[67 rows x 12 columns]" + "source": [ + "array.location_data" ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "array_custom.location_data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### See also that the costs have increased again!" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", - "for cable, cost in array_custom.cost_by_type.items():\n", - " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", - " \n", - "print(f\"{'Total':<16}| ${array_custom.total_cable_cost:>15,.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# Let's run some simulations!\n", - "We can now compare cases 2-4 to see how the installation cost will vary." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### First, we have to create a configuration dictionary for each of the 3 main cases we'll be simulating for installations, corresponding to the configuration file from the tests library. Then, we'll update eeach with the `design_result` of each of the 3 cases that we defined above." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "base_config = library.extract_library_specs(\"config\", \"example_array_cable_install\")\n", - "\n", - "#Case 2\n", - "array_case2 = deepcopy(base_config)\n", - "array_case2[\"array_system\"] = array.design_result[\"array_system\"]\n", - "\n", - "# Case 3\n", - "array_case3 = deepcopy(base_config)\n", - "array_case3[\"array_system\"] = array_distance.design_result[\"array_system\"]\n", - "\n", - "# Case 4\n", - "array_case4 = deepcopy(base_config)\n", - "array_case4[\"array_system\"] = array_exclusion.design_result[\"array_system\"]\n", - "\n", - "# Case 5\n", - "array_case5 = deepcopy(base_config)\n", - "array_case5[\"array_system\"] = array_custom.design_result[\"array_system\"]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Instantiate the simulations" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "sim2 = ArrayCableInstallation(array_case2)\n", - "sim3 = ArrayCableInstallation(array_case3)\n", - "sim4 = ArrayCableInstallation(array_case4)\n", - "sim5 = ArrayCableInstallation(array_case5)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Run the simulations\n", - "\n", - "We can see that both the installation cost and the time required to complete the simulation have all increased here, which corresponds to the increased cable lengths and changes to the burial speeds defined above." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now let's look at the cost for this cabling setup by each type of cable as well as the total cost" + ] + }, { - "name": "stdout", - "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" - ] - } - ], - "source": [ - "names = (\"straight-line distance\", \"distance-based coordinates\", \"with exclusions\", \"custom\")\n", - "simulations = (sim2, sim3, sim4, sim5)\n", - "\n", - "print(f\"{'Simulation':<26} | {'Cost (in USD)':>14} | {'Time (in hours)':>16}\")\n", - "for name, simulation in zip(names, simulations):\n", - " simulation.run()\n", - " cost = simulation.installation_capex\n", - " time = simulation.total_phase_time\n", - " print(f\"{name:<26} | ${cost:>13,.2f} | {time:>16,.0f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "## Let's put this all together\n", - "\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." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", + "for cable, cost in array.cost_by_type.items():\n", + " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", + " \n", + "print(f\"{'Total':<16}| ${array.total_cable_cost:>15,.2f}\")" + ] + }, { - "data": { - "text/plain": [ - "{'design_phases': ['CustomArraySystemDesign'],\n", - " 'install_phases': ['ArrayCableInstallation'],\n", - " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", - " '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", - " 'distance': False},\n", - " 'array_cable_install_vessel': 'example_cable_lay_vessel',\n", - " 'array_cable_bury_vessel': 'example_cable_lay_vessel'}" + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Case 3: Distance-based \"coordinate\" system\n", + "\n", + "In this case, we will consider each turbine and substation on a distance-based \"coordinate\" system where the longitude and latitude are the longitudinal (x direction) and latitudinal (y direction) **distances**, in kilometers, from a common reference point. We are still using the Dudgeon data, but the distances were computed outside of this example and the details are not be included.\n", + "\n", + "Below, we can see that the input file is still encoded in the exact same manner as [Case 2](#case_2), but latitude and longitude are relative distances and not proper coordinates." ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "config = library.extract_library_specs(\"config\", \"example_custom_array_project_manager\")\n", - "config" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "project = ProjectManager(config)\n", - "project.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ + }, + { + "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", + "
idsubstation_idnamelongitudelatitudestringordercable_lengthbury_speed
0DOW_OSSDOW_OSSDOW_OSS16.22990935.769173
1DAE_A1DOW_OSSDAE_A114.89084533.4507590000
2DAD_A2DOW_OSSDAD_A214.23752833.9530260100
3DAC_A3DOW_OSSDAC_A313.58421134.4551820200
4DAB_A4DOW_OSSDAB_A412.93203434.9574500300
..............................
63DCE_L1DOW_OSSDCE_L115.56426334.32174911000
64DAF_L2DOW_OSSDAF_L215.54416132.94849111100
65DAG_L3DOW_OSSDAG_L316.19526632.44633511200
66DAH_L4DOW_OSSDAH_L416.84858331.94406711300
67DAJ_L5DOW_OSSDAJ_L517.50189931.44180011400
\n", + "

68 rows \u00d7 9 columns

\n", + "
" + ], + "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", + ".. ... ... ... ... ... ... ... \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", + "\n", + " cable_length bury_speed \n", + "0 \n", + "1 0 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 0 0 \n", + ".. ... ... \n", + "63 0 0 \n", + "64 0 0 \n", + "65 0 0 \n", + "66 0 0 \n", + "67 0 0 \n", + "\n", + "[68 rows x 9 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv(\"../library/cables/dudgeon_distance_based.csv\", index_col=False).fillna(\"\")\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### For this case we also add the `distance` argument to the `array_system_design` and set it to `True` to indicate we are dealing with distances." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'distance': True,\n", + " 'location_data': 'dudgeon_distance_based'},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}\n" + ] + } + ], + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_simple_distance_based\")\n", + "pprint(config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### OR we can create the flag in the function call.\n", + "\n", + "**Note:** the configuration dictionary will always override this setting." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "array_distance = CustomArraySystemDesign(config, distance=True)\n", + "array_distance.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Let's take a look at the data to see what it output\n", + "\n", + "While some of the cable lengths may be slightly different, the spacing is still maintained, and we can see that this is the Dudgeon windfarm." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "array_distance.plot_array_system(show=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Now let's look at the cost for this cabling setup by each type of cable as well as the total cost and compare it to the previous case\n", + "\n", + "While there is a minor difference, this difference is small in comparison to the total project cost and errs in a more conservative direction." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "print(f\"{'Cable Type':<16} | {'Cost in USD (lat,lon)':>20} | {'Cost in USD (dist_lat,dist_lon)':>15}\")\n", + "for (cable1, cost1), (cable2, cost2) in zip(array.cost_by_type.items(), array_distance.cost_by_type.items()):\n", + " print(f\"{cable1:<16} | ${cost1:>20,.2f} | ${cost2:>15,.2f}\")\n", + " \n", + "print(f\"{'Total':<16} | ${array.total_cable_cost:>20,.2f} | ${array_distance.total_cable_cost:>15,.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Case 4: We want to account for some additions to the cable lengths due to exclusion zones\n", + "\n", + "This can be done with the `\"average_exclusion_percent\"` keyword in the configuration that can be seen below.\n", + "\n", + "**Note:**\n", + " 1. There is an average exclusion and is applied to each of the cable sections\n", + " 2. The plot won't change because it will not have details on the new paths so we'll only demonstrate the cost changes (a 4.8% increase, which is in line with the exclusion and the accounting for the site depth." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'location_data': 'dudgeon_array',\n", + " 'average_exclusion_percent': 0.05},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_exclusions\")\n", + "config" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "array_exclusion = CustomArraySystemDesign(config)\n", + "array_exclusion.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", + "for cable, cost in array_exclusion.cost_by_type.items():\n", + " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", + " \n", + "print(f\"{'Total':<16}| ${array_exclusion.total_cable_cost:>15,.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Case 5: Customize the distances \n", + "\n", + "If we look at the map in the [Call to Mariners](http://dudgeonoffshorewind.co.uk/news/notices/Dudgeon%20-%20Notice%20to%20Mariners%20wk25.pdf) there are different sized exclusions in the cables, so for this example we'll change the distances from [Case 4](#case_4) where we used an average exclusion to be a bit different in each case by using the `cable_length` column. In addition, we will utilize the `bury_speed` column to demonstrate how these columns will be used.\n", + "\n", + "**Note:** this work was done outside the notebook, but can be uploaded as show in the example below.\n", + "\n", + "For this example, half of the windfarm will have different soil condition, so we will use our proxy: `bury_speed` by modifying the burial speed to be fast (0.5 km/h) and slow (0.05 km/hr), respectively, to account for sandy soil and rocky soil. The purpose of this is for passing through customized parameters in the design phase to be utilized in the installation phase as will be seen in the final two examples." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'array_system_design': {'cables': ['XLPE_400mm_33kV', 'XLPE_630mm_33kV'],\n", + " 'location_data': 'dudgeon_custom'},\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " 'site': {'depth': 20},\n", + " 'turbine': 'SWT_6MW_154m_110m'}" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_custom\")\n", + "\n", + "# Note location_data the same one that was saved because I updated it!\n", + "config" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "array_custom = CustomArraySystemDesign(config)\n", + "array_custom.run()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Note that there are now cable lengths defined as well as burial speeds for installation" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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", + "
idsubstation_idsubstation_namesubstation_latitudesubstation_longitudeturbine_nameturbine_latitudeturbine_longitudestringordercable_lengthbury_speed
0DAE_A1DOW_OSSDOW_OSS53.26481.378767DAE_A153.2439501.358783003.1352790.50
1DAD_A2DOW_OSSDOW_OSS53.26481.378767DAD_A253.2484671.349033010.9938600.50
2DAC_A3DOW_OSSDOW_OSS53.26481.378767DAC_A353.2529831.339283020.9937190.50
3DAB_A4DOW_OSSDOW_OSS53.26481.378767DAB_A453.2575001.329550030.9926990.50
4DAA_A5DOW_OSSDOW_OSS53.26481.378767DAA_A553.2620171.319800040.9936730.50
.......................................
62DCE_L1DOW_OSSDOW_OSS53.26481.378767DCE_L153.2517831.3688331101.7128220.05
63DAF_L2DOW_OSSDOW_OSS53.26481.378767DAF_L253.2394331.3685331111.4833180.05
64DAG_L3DOW_OSSDOW_OSS53.26481.378767DAG_L353.2349171.3782501120.9017210.05
65DAH_L4DOW_OSSDOW_OSS53.26481.378767DAH_L453.2304001.3880001130.9036790.05
66DAJ_L5DOW_OSSDOW_OSS53.26481.378767DAJ_L553.2258831.3977501140.9037360.05
\n", + "

67 rows \u00d7 12 columns

\n", + "
" + ], + "text/plain": [ + " id substation_id substation_name substation_latitude \\\n", + "0 DAE_A1 DOW_OSS DOW_OSS 53.2648 \n", + "1 DAD_A2 DOW_OSS DOW_OSS 53.2648 \n", + "2 DAC_A3 DOW_OSS DOW_OSS 53.2648 \n", + "3 DAB_A4 DOW_OSS DOW_OSS 53.2648 \n", + "4 DAA_A5 DOW_OSS DOW_OSS 53.2648 \n", + ".. ... ... ... ... \n", + "62 DCE_L1 DOW_OSS DOW_OSS 53.2648 \n", + "63 DAF_L2 DOW_OSS DOW_OSS 53.2648 \n", + "64 DAG_L3 DOW_OSS DOW_OSS 53.2648 \n", + "65 DAH_L4 DOW_OSS DOW_OSS 53.2648 \n", + "66 DAJ_L5 DOW_OSS DOW_OSS 53.2648 \n", + "\n", + " substation_longitude turbine_name turbine_latitude turbine_longitude \\\n", + "0 1.378767 DAE_A1 53.243950 1.358783 \n", + "1 1.378767 DAD_A2 53.248467 1.349033 \n", + "2 1.378767 DAC_A3 53.252983 1.339283 \n", + "3 1.378767 DAB_A4 53.257500 1.329550 \n", + "4 1.378767 DAA_A5 53.262017 1.319800 \n", + ".. ... ... ... ... \n", + "62 1.378767 DCE_L1 53.251783 1.368833 \n", + "63 1.378767 DAF_L2 53.239433 1.368533 \n", + "64 1.378767 DAG_L3 53.234917 1.378250 \n", + "65 1.378767 DAH_L4 53.230400 1.388000 \n", + "66 1.378767 DAJ_L5 53.225883 1.397750 \n", + "\n", + " string order cable_length bury_speed \n", + "0 0 0 3.135279 0.50 \n", + "1 0 1 0.993860 0.50 \n", + "2 0 2 0.993719 0.50 \n", + "3 0 3 0.992699 0.50 \n", + "4 0 4 0.993673 0.50 \n", + ".. ... ... ... ... \n", + "62 11 0 1.712822 0.05 \n", + "63 11 1 1.483318 0.05 \n", + "64 11 2 0.901721 0.05 \n", + "65 11 3 0.903679 0.05 \n", + "66 11 4 0.903736 0.05 \n", + "\n", + "[67 rows x 12 columns]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_custom.location_data" + ] + }, { - "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" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### See also that the costs have increased again!" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "print(f\"{'Cable Type':<16}| {'Cost in USD':>15}\")\n", + "for cable, cost in array_custom.cost_by_type.items():\n", + " print(f\"{cable:<16}| ${cost:>15,.2f}\")\n", + " \n", + "print(f\"{'Total':<16}| ${array_custom.total_cable_cost:>15,.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Let's run some simulations!\n", + "We can now compare cases 2-4 to see how the installation cost will vary." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### First, we have to create a configuration dictionary for each of the 3 main cases we'll be simulating for installations, corresponding to the configuration file from the tests library. Then, we'll update eeach with the `design_result` of each of the 3 cases that we defined above." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "base_config = library.extract_library_specs(\"config\", \"example_array_cable_install\")\n", + "\n", + "#Case 2\n", + "array_case2 = deepcopy(base_config)\n", + "array_case2[\"array_system\"] = array.design_result[\"array_system\"]\n", + "\n", + "# Case 3\n", + "array_case3 = deepcopy(base_config)\n", + "array_case3[\"array_system\"] = array_distance.design_result[\"array_system\"]\n", + "\n", + "# Case 4\n", + "array_case4 = deepcopy(base_config)\n", + "array_case4[\"array_system\"] = array_exclusion.design_result[\"array_system\"]\n", + "\n", + "# Case 5\n", + "array_case5 = deepcopy(base_config)\n", + "array_case5[\"array_system\"] = array_custom.design_result[\"array_system\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Instantiate the simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "sim2 = ArrayCableInstallation(array_case2)\n", + "sim3 = ArrayCableInstallation(array_case3)\n", + "sim4 = ArrayCableInstallation(array_case4)\n", + "sim5 = ArrayCableInstallation(array_case5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Run the simulations\n", + "\n", + "We can see that both the installation cost and the time required to complete the simulation have all increased here, which corresponds to the increased cable lengths and changes to the burial speeds defined above." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "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" + ] + } + ], + "source": [ + "names = (\"straight-line distance\", \"distance-based coordinates\", \"with exclusions\", \"custom\")\n", + "simulations = (sim2, sim3, sim4, sim5)\n", + "\n", + "print(f\"{'Simulation':<26} | {'Cost (in USD)':>14} | {'Time (in hours)':>16}\")\n", + "for name, simulation in zip(names, simulations):\n", + " simulation.run()\n", + " cost = simulation.installation_capex\n", + " time = simulation.total_phase_time\n", + " print(f\"{name:<26} | ${cost:>13,.2f} | {time:>16,.0f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Let's put this all together\n", + "\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." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'design_phases': ['CustomArraySystemDesign'],\n", + " 'install_phases': ['ArrayCableInstallation'],\n", + " 'plant': {'layout': 'custom', 'num_turbines': 67},\n", + " '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", + " 'distance': False},\n", + " 'array_cable_install_vessel': 'example_cable_lay_vessel',\n", + " 'array_cable_bury_vessel': 'example_cable_lay_vessel'}" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "config = library.extract_library_specs(\"config\", \"example_custom_array_project_manager\")\n", + "config" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "project = ProjectManager(config)\n", + "project.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "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" + ] + } + ], + "source": [ + "total = array_custom.total_cable_cost + sim5.installation_capex\n", + "\n", + "print(f\"Custom Design | ${array_custom.total_cable_cost:>13,.2f}\")\n", + "print(f\"Custom Installation | ${sim5.installation_capex:>13,.2f}\")\n", + "print(f\"Total Cost. | ${total:>13,.2f}\")\n", + "print(f\"Project Manager Cost | ${project.bos_capex:>13,.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "total = array_custom.total_cable_cost + sim5.installation_capex\n", - "\n", - "print(f\"Custom Design | ${array_custom.total_cable_cost:>13,.2f}\")\n", - "print(f\"Custom Installation | ${sim5.installation_capex:>13,.2f}\")\n", - "print(f\"Total Cost. | ${total:>13,.2f}\")\n", - "print(f\"Project Manager Cost | ${project.bos_capex:>13,.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/Example - Dependent Phases.ipynb b/examples/Example - Dependent Phases.ipynb index 8e2c2a74..8b5ae593 100644 --- a/examples/Example - Dependent Phases.ipynb +++ b/examples/Example - Dependent Phases.ipynb @@ -1,908 +1,908 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### ORBIT Example - Dependent Phases\n", - "\n", - "Last Updated: 07/28/2020\n", - "\n", - "The start times for phases in ORBIT can be defined relative to other phases. This is often used to simulate an installation phase that is dependent on an earlier installation phase. For example, the turbine installation for fixed bottom substructures can't happen until the substructures are installed. The phases can be scheduled such that the turbine installation starts when 50% of the monopiles have been installed." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "from ORBIT import ProjectManager" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Simple Configuration" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# For this example we will start with a simple project with only two phases:\n", - "# - MonopileInstallation\n", - "# - TurbineInstallation\n", - "\n", - "# In the config below, the installation phases are defined in a list. They will run\n", - "# in the code sequentially. ie, TurbineInstallation will start at the timestep that\n", - "# MonopileInstallation ends.\n", - "\n", - "config = {\n", - " \"site\": {\n", - " \"depth\": 20,\n", - " \"distance\": 40\n", - " },\n", - " \n", - " \"plant\": {\"num_turbines\": 50},\n", - " \"turbine\": \"SWT_6MW_154m_110m\",\n", - " \"port\": {\"num_cranes\": 1},\n", - " \n", - " \"monopile\": {\n", - " \"unit_cost\": 5e6,\n", - " \"length\": 80,\n", - " \"diameter\": 8,\n", - " \"deck_space\": 1000,\n", - " \"mass\": 1000,\n", - " },\n", - " \n", - " \"transition_piece\": {\n", - " \"unit_cost\": 3e6,\n", - " \"deck_space\": 300,\n", - " \"mass\": 500,\n", - " },\n", - " \n", - " \"MonopileInstallation\": {\"wtiv\": \"example_wtiv\"},\n", - " \"TurbineInstallation\": {\"wtiv\": \"example_wtiv\"},\n", - " \n", - " 'install_phases': ['MonopileInstallation', 'TurbineInstallation']\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### ORBIT Example - Dependent Phases\n", + "\n", + "Last Updated: 07/28/2020\n", + "\n", + "The start times for phases in ORBIT can be defined relative to other phases. This is often used to simulate an installation phase that is dependent on an earlier installation phase. For example, the turbine installation for fixed bottom substructures can't happen until the substructures are installed. The phases can be scheduled such that the turbine installation starts when 50% of the monopiles have been installed." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from ORBIT import ProjectManager" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simple Configuration" + ] + }, { - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \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_name
780NaNWTIVCrane Reequip1.07500.0ACTION2021.85MonopileInstallation20.0110.0MonopileInstallation
781NaNWTIVLower TP1.07500.0ACTION2022.85MonopileInstallation20.0110.0MonopileInstallation
782NaNWTIVBolt TP4.030000.0ACTION2026.85MonopileInstallation20.0110.0MonopileInstallation
783NaNWTIVJackdown0.32250.0ACTION2027.15MonopileInstallation20.0110.0MonopileInstallation
7841.0WTIVMobilize168.01260000.0ACTION2028.00TurbineInstallationNaNNaNNaN
785NaNWTIVFasten Tower Section4.030000.0ACTION2032.00TurbineInstallation20.0110.0TurbineInstallation
786NaNWTIVFasten Tower Section4.030000.0ACTION2036.00TurbineInstallation20.0110.0TurbineInstallation
787NaNWTIVFasten Nacelle4.030000.0ACTION2040.00TurbineInstallation20.0110.0TurbineInstallation
788NaNWTIVFasten Blade1.511250.0ACTION2041.50TurbineInstallation20.0110.0TurbineInstallation
789NaNWTIVFasten Blade1.511250.0ACTION2043.00TurbineInstallation20.0110.0TurbineInstallation
790NaNWTIVFasten Blade1.511250.0ACTION2044.50TurbineInstallation20.0110.0TurbineInstallation
791NaNWTIVFasten Tower Section4.030000.0ACTION2048.50TurbineInstallation20.0110.0TurbineInstallation
792NaNWTIVFasten Tower Section4.030000.0ACTION2052.50TurbineInstallation20.0110.0TurbineInstallation
793NaNWTIVFasten Nacelle4.030000.0ACTION2056.50TurbineInstallation20.0110.0TurbineInstallation
794NaNWTIVFasten Blade1.511250.0ACTION2058.00TurbineInstallation20.0110.0TurbineInstallation
795NaNWTIVFasten Blade1.511250.0ACTION2059.50TurbineInstallation20.0110.0TurbineInstallation
796NaNWTIVFasten Blade1.511250.0ACTION2061.00TurbineInstallation20.0110.0TurbineInstallation
797NaNWTIVFasten Tower Section4.030000.0ACTION2065.00TurbineInstallation20.0110.0TurbineInstallation
798NaNWTIVFasten Tower Section4.030000.0ACTION2069.00TurbineInstallation20.0110.0TurbineInstallation
799NaNWTIVFasten Nacelle4.030000.0ACTION2073.00TurbineInstallation20.0110.0TurbineInstallation
\n", - "
" + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# For this example we will start with a simple project with only two phases:\n", + "# - MonopileInstallation\n", + "# - TurbineInstallation\n", + "\n", + "# In the config below, the installation phases are defined in a list. They will run\n", + "# in the code sequentially. ie, TurbineInstallation will start at the timestep that\n", + "# MonopileInstallation ends.\n", + "\n", + "config = {\n", + " \"site\": {\n", + " \"depth\": 20,\n", + " \"distance\": 40\n", + " },\n", + " \n", + " \"plant\": {\"num_turbines\": 50},\n", + " \"turbine\": \"SWT_6MW_154m_110m\",\n", + " \"port\": {\"num_cranes\": 1},\n", + " \n", + " \"monopile\": {\n", + " \"unit_cost\": 5e6,\n", + " \"length\": 80,\n", + " \"diameter\": 8,\n", + " \"deck_space\": 1000,\n", + " \"mass\": 1000,\n", + " },\n", + " \n", + " \"transition_piece\": {\n", + " \"unit_cost\": 3e6,\n", + " \"deck_space\": 300,\n", + " \"mass\": 500,\n", + " },\n", + " \n", + " \"MonopileInstallation\": {\"wtiv\": \"example_wtiv\"},\n", + " \"TurbineInstallation\": {\"wtiv\": \"example_wtiv\"},\n", + " \n", + " 'install_phases': ['MonopileInstallation', 'TurbineInstallation']\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \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_name
780NaNWTIVCrane Reequip1.07500.0ACTION2021.85MonopileInstallation20.0110.0MonopileInstallation
781NaNWTIVLower TP1.07500.0ACTION2022.85MonopileInstallation20.0110.0MonopileInstallation
782NaNWTIVBolt TP4.030000.0ACTION2026.85MonopileInstallation20.0110.0MonopileInstallation
783NaNWTIVJackdown0.32250.0ACTION2027.15MonopileInstallation20.0110.0MonopileInstallation
7841.0WTIVMobilize168.01260000.0ACTION2028.00TurbineInstallationNaNNaNNaN
785NaNWTIVFasten Tower Section4.030000.0ACTION2032.00TurbineInstallation20.0110.0TurbineInstallation
786NaNWTIVFasten Tower Section4.030000.0ACTION2036.00TurbineInstallation20.0110.0TurbineInstallation
787NaNWTIVFasten Nacelle4.030000.0ACTION2040.00TurbineInstallation20.0110.0TurbineInstallation
788NaNWTIVFasten Blade1.511250.0ACTION2041.50TurbineInstallation20.0110.0TurbineInstallation
789NaNWTIVFasten Blade1.511250.0ACTION2043.00TurbineInstallation20.0110.0TurbineInstallation
790NaNWTIVFasten Blade1.511250.0ACTION2044.50TurbineInstallation20.0110.0TurbineInstallation
791NaNWTIVFasten Tower Section4.030000.0ACTION2048.50TurbineInstallation20.0110.0TurbineInstallation
792NaNWTIVFasten Tower Section4.030000.0ACTION2052.50TurbineInstallation20.0110.0TurbineInstallation
793NaNWTIVFasten Nacelle4.030000.0ACTION2056.50TurbineInstallation20.0110.0TurbineInstallation
794NaNWTIVFasten Blade1.511250.0ACTION2058.00TurbineInstallation20.0110.0TurbineInstallation
795NaNWTIVFasten Blade1.511250.0ACTION2059.50TurbineInstallation20.0110.0TurbineInstallation
796NaNWTIVFasten Blade1.511250.0ACTION2061.00TurbineInstallation20.0110.0TurbineInstallation
797NaNWTIVFasten Tower Section4.030000.0ACTION2065.00TurbineInstallation20.0110.0TurbineInstallation
798NaNWTIVFasten Tower Section4.030000.0ACTION2069.00TurbineInstallation20.0110.0TurbineInstallation
799NaNWTIVFasten Nacelle4.030000.0ACTION2073.00TurbineInstallation20.0110.0TurbineInstallation
\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration cost level \\\n", + "780 NaN WTIV Crane Reequip 1.0 7500.0 ACTION \n", + "781 NaN WTIV Lower TP 1.0 7500.0 ACTION \n", + "782 NaN WTIV Bolt TP 4.0 30000.0 ACTION \n", + "783 NaN WTIV Jackdown 0.3 2250.0 ACTION \n", + "784 1.0 WTIV Mobilize 168.0 1260000.0 ACTION \n", + "785 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "786 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "787 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", + "788 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "789 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "790 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "791 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "792 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "793 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", + "794 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "795 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "796 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", + "797 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "798 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", + "799 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", + "\n", + " time phase site_depth hub_height \\\n", + "780 2021.85 MonopileInstallation 20.0 110.0 \n", + "781 2022.85 MonopileInstallation 20.0 110.0 \n", + "782 2026.85 MonopileInstallation 20.0 110.0 \n", + "783 2027.15 MonopileInstallation 20.0 110.0 \n", + "784 2028.00 TurbineInstallation NaN NaN \n", + "785 2032.00 TurbineInstallation 20.0 110.0 \n", + "786 2036.00 TurbineInstallation 20.0 110.0 \n", + "787 2040.00 TurbineInstallation 20.0 110.0 \n", + "788 2041.50 TurbineInstallation 20.0 110.0 \n", + "789 2043.00 TurbineInstallation 20.0 110.0 \n", + "790 2044.50 TurbineInstallation 20.0 110.0 \n", + "791 2048.50 TurbineInstallation 20.0 110.0 \n", + "792 2052.50 TurbineInstallation 20.0 110.0 \n", + "793 2056.50 TurbineInstallation 20.0 110.0 \n", + "794 2058.00 TurbineInstallation 20.0 110.0 \n", + "795 2059.50 TurbineInstallation 20.0 110.0 \n", + "796 2061.00 TurbineInstallation 20.0 110.0 \n", + "797 2065.00 TurbineInstallation 20.0 110.0 \n", + "798 2069.00 TurbineInstallation 20.0 110.0 \n", + "799 2073.00 TurbineInstallation 20.0 110.0 \n", + "\n", + " phase_name \n", + "780 MonopileInstallation \n", + "781 MonopileInstallation \n", + "782 MonopileInstallation \n", + "783 MonopileInstallation \n", + "784 NaN \n", + "785 TurbineInstallation \n", + "786 TurbineInstallation \n", + "787 TurbineInstallation \n", + "788 TurbineInstallation \n", + "789 TurbineInstallation \n", + "790 TurbineInstallation \n", + "791 TurbineInstallation \n", + "792 TurbineInstallation \n", + "793 TurbineInstallation \n", + "794 TurbineInstallation \n", + "795 TurbineInstallation \n", + "796 TurbineInstallation \n", + "797 TurbineInstallation \n", + "798 TurbineInstallation \n", + "799 TurbineInstallation " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action duration cost level \\\n", - "780 NaN WTIV Crane Reequip 1.0 7500.0 ACTION \n", - "781 NaN WTIV Lower TP 1.0 7500.0 ACTION \n", - "782 NaN WTIV Bolt TP 4.0 30000.0 ACTION \n", - "783 NaN WTIV Jackdown 0.3 2250.0 ACTION \n", - "784 1.0 WTIV Mobilize 168.0 1260000.0 ACTION \n", - "785 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "786 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "787 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", - "788 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "789 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "790 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "791 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "792 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "793 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", - "794 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "795 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "796 NaN WTIV Fasten Blade 1.5 11250.0 ACTION \n", - "797 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "798 NaN WTIV Fasten Tower Section 4.0 30000.0 ACTION \n", - "799 NaN WTIV Fasten Nacelle 4.0 30000.0 ACTION \n", - "\n", - " time phase site_depth hub_height \\\n", - "780 2021.85 MonopileInstallation 20.0 110.0 \n", - "781 2022.85 MonopileInstallation 20.0 110.0 \n", - "782 2026.85 MonopileInstallation 20.0 110.0 \n", - "783 2027.15 MonopileInstallation 20.0 110.0 \n", - "784 2028.00 TurbineInstallation NaN NaN \n", - "785 2032.00 TurbineInstallation 20.0 110.0 \n", - "786 2036.00 TurbineInstallation 20.0 110.0 \n", - "787 2040.00 TurbineInstallation 20.0 110.0 \n", - "788 2041.50 TurbineInstallation 20.0 110.0 \n", - "789 2043.00 TurbineInstallation 20.0 110.0 \n", - "790 2044.50 TurbineInstallation 20.0 110.0 \n", - "791 2048.50 TurbineInstallation 20.0 110.0 \n", - "792 2052.50 TurbineInstallation 20.0 110.0 \n", - "793 2056.50 TurbineInstallation 20.0 110.0 \n", - "794 2058.00 TurbineInstallation 20.0 110.0 \n", - "795 2059.50 TurbineInstallation 20.0 110.0 \n", - "796 2061.00 TurbineInstallation 20.0 110.0 \n", - "797 2065.00 TurbineInstallation 20.0 110.0 \n", - "798 2069.00 TurbineInstallation 20.0 110.0 \n", - "799 2073.00 TurbineInstallation 20.0 110.0 \n", - "\n", - " phase_name \n", - "780 MonopileInstallation \n", - "781 MonopileInstallation \n", - "782 MonopileInstallation \n", - "783 MonopileInstallation \n", - "784 NaN \n", - "785 TurbineInstallation \n", - "786 TurbineInstallation \n", - "787 TurbineInstallation \n", - "788 TurbineInstallation \n", - "789 TurbineInstallation \n", - "790 TurbineInstallation \n", - "791 TurbineInstallation \n", - "792 TurbineInstallation \n", - "793 TurbineInstallation \n", - "794 TurbineInstallation \n", - "795 TurbineInstallation \n", - "796 TurbineInstallation \n", - "797 TurbineInstallation \n", - "798 TurbineInstallation \n", - "799 TurbineInstallation " + "source": [ + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "df = pd.DataFrame(project.actions) # Return a table of all of the vessel actions that were performed throughout the project.\n", + "df.iloc[780:800] # Filter to rows 780-790 where the TurbineInstallation phase begins." ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "df = pd.DataFrame(project.actions) # Return a table of all of the vessel actions that were performed throughout the project.\n", - "df.iloc[780:800] # Filter to rows 780-790 where the TurbineInstallation phase begins." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Defining Dependent Phases" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# In the new config below, the installation phases are defined in a dict.\n", - "# MonopileInstallation is set to begin at timestep 0, and TurbineInstallation\n", - "# will begin when MonopileInstallation is 50% complete.\n", - "\n", - "config = {\n", - " \"site\": {\n", - " \"depth\": 20,\n", - " \"distance\": 40\n", - " },\n", - " \n", - " \"plant\": {\"num_turbines\": 50},\n", - " \"turbine\": \"SWT_6MW_154m_110m\",\n", - " \"port\": {\"num_cranes\": 1},\n", - " \n", - " \"monopile\": {\n", - " \"unit_cost\": 5e6,\n", - " \"length\": 80,\n", - " \"diameter\": 8,\n", - " \"deck_space\": 1000,\n", - " \"mass\": 1000,\n", - " },\n", - " \n", - " \"transition_piece\": {\n", - " \"unit_cost\": 3e6,\n", - " \"deck_space\": 300,\n", - " \"mass\": 500,\n", - " },\n", - " \n", - " \"MonopileInstallation\": {\"wtiv\": \"example_wtiv\"},\n", - " \"TurbineInstallation\": {\"wtiv\": \"example_wtiv\"},\n", - " \n", - " 'install_phases': { # <--- 'install_phases' changed to a dict\n", - " \"MonopileInstallation\": 0, # <--- MonopileInstallation will start at timestep 0\n", - " \"TurbineInstallation\": (\"MonopileInstallation\", 0.25) # <--- TurbineInstallation will start when MonopileInstallation is 50% complete.\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Defining Dependent Phases" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# In the new config below, the installation phases are defined in a dict.\n", + "# MonopileInstallation is set to begin at timestep 0, and TurbineInstallation\n", + "# will begin when MonopileInstallation is 50% complete.\n", + "\n", + "config = {\n", + " \"site\": {\n", + " \"depth\": 20,\n", + " \"distance\": 40\n", + " },\n", + " \n", + " \"plant\": {\"num_turbines\": 50},\n", + " \"turbine\": \"SWT_6MW_154m_110m\",\n", + " \"port\": {\"num_cranes\": 1},\n", + " \n", + " \"monopile\": {\n", + " \"unit_cost\": 5e6,\n", + " \"length\": 80,\n", + " \"diameter\": 8,\n", + " \"deck_space\": 1000,\n", + " \"mass\": 1000,\n", + " },\n", + " \n", + " \"transition_piece\": {\n", + " \"unit_cost\": 3e6,\n", + " \"deck_space\": 300,\n", + " \"mass\": 500,\n", + " },\n", + " \n", + " \"MonopileInstallation\": {\"wtiv\": \"example_wtiv\"},\n", + " \"TurbineInstallation\": {\"wtiv\": \"example_wtiv\"},\n", + " \n", + " 'install_phases': { # <--- 'install_phases' changed to a dict\n", + " \"MonopileInstallation\": 0, # <--- MonopileInstallation will start at timestep 0\n", + " \"TurbineInstallation\": (\"MonopileInstallation\", 0.25) # <--- TurbineInstallation will start when MonopileInstallation is 50% complete.\n", + " }\n", + "}" + ] + }, { - "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", - "
cost_multiplieragentactiondurationcostleveltimephasesite_depthhub_heightphase_name
189NaNWTIVFasten Monopile12.090000.0ACTION498.8360MonopileInstallation20.0110.0MonopileInstallation
1901.0WTIVMobilize168.01260000.0ACTION506.7875TurbineInstallationNaNNaNNaN
191NaNWTIVFasten Transition Piece8.060000.0ACTION506.8360MonopileInstallation20.0110.0MonopileInstallation
192NaNWTIVFasten Tower Section4.030000.0ACTION510.7875TurbineInstallation20.0110.0TurbineInstallation
193NaNWTIVFasten Tower Section4.030000.0ACTION514.7875TurbineInstallation20.0110.0TurbineInstallation
....................................
2245NaNWTIVAttach Blade3.526250.0ACTION3943.3875TurbineInstallation20.0110.0TurbineInstallation
2246NaNWTIVRelease Blade1.07500.0ACTION3944.3875TurbineInstallationNaNNaNNaN
2247NaNWTIVLift Blade1.18250.0ACTION3945.4875TurbineInstallation20.0110.0TurbineInstallation
2248NaNWTIVAttach Blade3.526250.0ACTION3948.9875TurbineInstallation20.0110.0TurbineInstallation
2249NaNWTIVJackdown0.32250.0ACTION3949.2875TurbineInstallation20.0110.0TurbineInstallation
\n", - "

2061 rows × 11 columns

\n", - "
" + "cell_type": "code", + "execution_count": 8, + "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", + "
cost_multiplieragentactiondurationcostleveltimephasesite_depthhub_heightphase_name
189NaNWTIVFasten Monopile12.090000.0ACTION498.8360MonopileInstallation20.0110.0MonopileInstallation
1901.0WTIVMobilize168.01260000.0ACTION506.7875TurbineInstallationNaNNaNNaN
191NaNWTIVFasten Transition Piece8.060000.0ACTION506.8360MonopileInstallation20.0110.0MonopileInstallation
192NaNWTIVFasten Tower Section4.030000.0ACTION510.7875TurbineInstallation20.0110.0TurbineInstallation
193NaNWTIVFasten Tower Section4.030000.0ACTION514.7875TurbineInstallation20.0110.0TurbineInstallation
....................................
2245NaNWTIVAttach Blade3.526250.0ACTION3943.3875TurbineInstallation20.0110.0TurbineInstallation
2246NaNWTIVRelease Blade1.07500.0ACTION3944.3875TurbineInstallationNaNNaNNaN
2247NaNWTIVLift Blade1.18250.0ACTION3945.4875TurbineInstallation20.0110.0TurbineInstallation
2248NaNWTIVAttach Blade3.526250.0ACTION3948.9875TurbineInstallation20.0110.0TurbineInstallation
2249NaNWTIVJackdown0.32250.0ACTION3949.2875TurbineInstallation20.0110.0TurbineInstallation
\n", + "

2061 rows \u00d7 11 columns

\n", + "
" + ], + "text/plain": [ + " cost_multiplier agent action duration cost \\\n", + "189 NaN WTIV Fasten Monopile 12.0 90000.0 \n", + "190 1.0 WTIV Mobilize 168.0 1260000.0 \n", + "191 NaN WTIV Fasten Transition Piece 8.0 60000.0 \n", + "192 NaN WTIV Fasten Tower Section 4.0 30000.0 \n", + "193 NaN WTIV Fasten Tower Section 4.0 30000.0 \n", + "... ... ... ... ... ... \n", + "2245 NaN WTIV Attach Blade 3.5 26250.0 \n", + "2246 NaN WTIV Release Blade 1.0 7500.0 \n", + "2247 NaN WTIV Lift Blade 1.1 8250.0 \n", + "2248 NaN WTIV Attach Blade 3.5 26250.0 \n", + "2249 NaN WTIV Jackdown 0.3 2250.0 \n", + "\n", + " level time phase site_depth hub_height \\\n", + "189 ACTION 498.8360 MonopileInstallation 20.0 110.0 \n", + "190 ACTION 506.7875 TurbineInstallation NaN NaN \n", + "191 ACTION 506.8360 MonopileInstallation 20.0 110.0 \n", + "192 ACTION 510.7875 TurbineInstallation 20.0 110.0 \n", + "193 ACTION 514.7875 TurbineInstallation 20.0 110.0 \n", + "... ... ... ... ... ... \n", + "2245 ACTION 3943.3875 TurbineInstallation 20.0 110.0 \n", + "2246 ACTION 3944.3875 TurbineInstallation NaN NaN \n", + "2247 ACTION 3945.4875 TurbineInstallation 20.0 110.0 \n", + "2248 ACTION 3948.9875 TurbineInstallation 20.0 110.0 \n", + "2249 ACTION 3949.2875 TurbineInstallation 20.0 110.0 \n", + "\n", + " phase_name \n", + "189 MonopileInstallation \n", + "190 NaN \n", + "191 MonopileInstallation \n", + "192 TurbineInstallation \n", + "193 TurbineInstallation \n", + "... ... \n", + "2245 TurbineInstallation \n", + "2246 NaN \n", + "2247 TurbineInstallation \n", + "2248 TurbineInstallation \n", + "2249 TurbineInstallation \n", + "\n", + "[2061 rows x 11 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } ], - "text/plain": [ - " cost_multiplier agent action duration cost \\\n", - "189 NaN WTIV Fasten Monopile 12.0 90000.0 \n", - "190 1.0 WTIV Mobilize 168.0 1260000.0 \n", - "191 NaN WTIV Fasten Transition Piece 8.0 60000.0 \n", - "192 NaN WTIV Fasten Tower Section 4.0 30000.0 \n", - "193 NaN WTIV Fasten Tower Section 4.0 30000.0 \n", - "... ... ... ... ... ... \n", - "2245 NaN WTIV Attach Blade 3.5 26250.0 \n", - "2246 NaN WTIV Release Blade 1.0 7500.0 \n", - "2247 NaN WTIV Lift Blade 1.1 8250.0 \n", - "2248 NaN WTIV Attach Blade 3.5 26250.0 \n", - "2249 NaN WTIV Jackdown 0.3 2250.0 \n", - "\n", - " level time phase site_depth hub_height \\\n", - "189 ACTION 498.8360 MonopileInstallation 20.0 110.0 \n", - "190 ACTION 506.7875 TurbineInstallation NaN NaN \n", - "191 ACTION 506.8360 MonopileInstallation 20.0 110.0 \n", - "192 ACTION 510.7875 TurbineInstallation 20.0 110.0 \n", - "193 ACTION 514.7875 TurbineInstallation 20.0 110.0 \n", - "... ... ... ... ... ... \n", - "2245 ACTION 3943.3875 TurbineInstallation 20.0 110.0 \n", - "2246 ACTION 3944.3875 TurbineInstallation NaN NaN \n", - "2247 ACTION 3945.4875 TurbineInstallation 20.0 110.0 \n", - "2248 ACTION 3948.9875 TurbineInstallation 20.0 110.0 \n", - "2249 ACTION 3949.2875 TurbineInstallation 20.0 110.0 \n", - "\n", - " phase_name \n", - "189 MonopileInstallation \n", - "190 NaN \n", - "191 MonopileInstallation \n", - "192 TurbineInstallation \n", - "193 TurbineInstallation \n", - "... ... \n", - "2245 TurbineInstallation \n", - "2246 NaN \n", - "2247 TurbineInstallation \n", - "2248 TurbineInstallation \n", - "2249 TurbineInstallation \n", - "\n", - "[2061 rows x 11 columns]" + "source": [ + "project = ProjectManager(config)\n", + "project.run()\n", + "\n", + "df = pd.DataFrame(project.actions)\n", + "\n", + "monopiles = df.loc[df[\"phase\"]==\"MonopileInstallation\"] # Filter actions table to the MonopileInstallation phase.\n", + "halfway_point = max(monopiles[\"time\"]) / 4 # Find the halway point of the MonopileInstallation phase.\n", + "\n", + "df.loc[df[\"time\"] > halfway_point - 10] # Display the total actions table starting from 10 hours prior to the halfway point.\n", + " # Notice the \"Mobilize\" action for the TurbineInstallation phase. This marks the beginning of\n", + " # the TurbineInstallation phase." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Other Examples\n", + "\n", + "The examples below are not complete configurations but showcase the flexibility of dependent phases." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Multiple dependent phases\n", + "config = {\n", + " \n", + " # ...\n", + " \n", + " 'install_phases': {\n", + " 'MonopileInstallation': 0, # MonopileInstallation will start at timestep 0\n", + " 'ScourProtectionInstallation': (\"MonopileInstallation\", 0.8), # ScourProtectionInstallation will start when MonopileInstallation is 80% complete\n", + " 'TurbineInstallation': (\"MonopileInstallation\", 0.5) # TurbineInstallation will start when MonopileInstallation is 50% complete\n", + " }\n", + "}" ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Multiple dependent phases with start dates\n", + "config = {\n", + " \n", + " # ...\n", + " \n", + " 'install_phases': {\n", + " 'MonopileInstallation': \"04/01/2010\", # MonopileInstallation will start on April 1st, 2010\n", + " 'ScourProtectionInstallation': (\"MonopileInstallation\", 0.8), # ScourProtectionInstallation will start when MonopileInstallation is 80% complete\n", + " 'TurbineInstallation': (\"MonopileInstallation\", 0.5) # TurbineInstallation will start when MonopileInstallation is 50% complete\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Chained dependent phases\n", + "config = {\n", + " \n", + " # ...\n", + "\n", + " \"install_phases\": {\n", + " \"ScourProtectionInstallation\": 0, # ScourProtectionInstallation will start at timestep 0\n", + " \"MonopileInstallation\": (\"ScourProtectionInstallation\", 0.1), # MonopileInstallation will start when the above is 10% complete\n", + " \"TurbineInstallation\": (\"MonopileInstallation\", 0.5) # TurbineInstallation will start whent he above is 50% complete\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Multiple chains\n", + "config = {\n", + " \n", + " # ...\n", + "\n", + " \"install_phases\": {\n", + " \"ScourProtectionInstallation\": 0, # ScourProtectionInstallation will start at timestep 0\n", + " \"MonopileInstallation\": (\"ScourProtectionInstallation\", 0.1), # MonopileInstallation will start when the above phase is 10% complete\n", + " \"TurbineInstallation\": (\"MonopileInstallation\", 0.5), # TurbineInstallation will start when the above phase is 50% complete\n", + " \"ArrayCableInstallation\": (\"MonopileInstallation\", 0.25), # ArrayCableInstallation will start when the Monopiles are 25% complete\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "project = ProjectManager(config)\n", - "project.run()\n", - "\n", - "df = pd.DataFrame(project.actions)\n", - "\n", - "monopiles = df.loc[df[\"phase\"]==\"MonopileInstallation\"] # Filter actions table to the MonopileInstallation phase.\n", - "halfway_point = max(monopiles[\"time\"]) / 4 # Find the halway point of the MonopileInstallation phase.\n", - "\n", - "df.loc[df[\"time\"] > halfway_point - 10] # Display the total actions table starting from 10 hours prior to the halfway point.\n", - " # Notice the \"Mobilize\" action for the TurbineInstallation phase. This marks the beginning of\n", - " # the TurbineInstallation phase." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Other Examples\n", - "\n", - "The examples below are not complete configurations but showcase the flexibility of dependent phases." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Multiple dependent phases\n", - "config = {\n", - " \n", - " # ...\n", - " \n", - " 'install_phases': {\n", - " 'MonopileInstallation': 0, # MonopileInstallation will start at timestep 0\n", - " 'ScourProtectionInstallation': (\"MonopileInstallation\", 0.8), # ScourProtectionInstallation will start when MonopileInstallation is 80% complete\n", - " 'TurbineInstallation': (\"MonopileInstallation\", 0.5) # TurbineInstallation will start when MonopileInstallation is 50% complete\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Multiple dependent phases with start dates\n", - "config = {\n", - " \n", - " # ...\n", - " \n", - " 'install_phases': {\n", - " 'MonopileInstallation': \"04/01/2010\", # MonopileInstallation will start on April 1st, 2010\n", - " 'ScourProtectionInstallation': (\"MonopileInstallation\", 0.8), # ScourProtectionInstallation will start when MonopileInstallation is 80% complete\n", - " 'TurbineInstallation': (\"MonopileInstallation\", 0.5) # TurbineInstallation will start when MonopileInstallation is 50% complete\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# Chained dependent phases\n", - "config = {\n", - " \n", - " # ...\n", - "\n", - " \"install_phases\": {\n", - " \"ScourProtectionInstallation\": 0, # ScourProtectionInstallation will start at timestep 0\n", - " \"MonopileInstallation\": (\"ScourProtectionInstallation\", 0.1), # MonopileInstallation will start when the above is 10% complete\n", - " \"TurbineInstallation\": (\"MonopileInstallation\", 0.5) # TurbineInstallation will start whent he above is 50% complete\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# Multiple chains\n", - "config = {\n", - " \n", - " # ...\n", - "\n", - " \"install_phases\": {\n", - " \"ScourProtectionInstallation\": 0, # ScourProtectionInstallation will start at timestep 0\n", - " \"MonopileInstallation\": (\"ScourProtectionInstallation\", 0.1), # MonopileInstallation will start when the above phase is 10% complete\n", - " \"TurbineInstallation\": (\"MonopileInstallation\", 0.5), # TurbineInstallation will start when the above phase is 50% complete\n", - " \"ArrayCableInstallation\": (\"MonopileInstallation\", 0.25), # ArrayCableInstallation will start when the Monopiles are 25% complete\n", - " }\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/Example - Modifying Library Assets.ipynb b/examples/Example - Modifying Library Assets.ipynb index e40cdd89..91d23c50 100644 --- a/examples/Example - Modifying Library Assets.ipynb +++ b/examples/Example - Modifying Library Assets.ipynb @@ -1,216 +1,216 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Example - Library Assets\n", - "\n", - "ORBIT stores the inputs associated with vessels, cables and turbines in a library in order to allow for modeling of discrete options of these inputs as well as to keep the input configurations cleaner. For example, all of the inputs related to the WTIV that we have been using to this point, are stored in the 'example_wtiv.yaml' file in the ORBIT library." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Configuring the library" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example - Library Assets\n", + "\n", + "ORBIT stores the inputs associated with vessels, cables and turbines in a library in order to allow for modeling of discrete options of these inputs as well as to keep the input configurations cleaner. For example, all of the inputs related to the WTIV that we have been using to this point, are stored in the 'example_wtiv.yaml' file in the ORBIT library." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Configuring the library" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/examples/library'\n" + ] + } + ], + "source": [ + "# By default, ORBIT initializes the library at '~/ORBIT/library/'\n", + "# The library location can also be changed by using the following:\n", + "\n", + "import os\n", + "from ORBIT.core.library import initialize_library\n", + "initialize_library(os.path.join(os.getcwd(), \"library\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# This allows for proprietary vessel/cable/turbine information to be stored outside of the model repo.\n", + "\n", + "# Note: The library functions will search for library assets at an external library first, but will\n", + "# search the internal ORBIT library if it is not found. This means that the example library files\n", + "# don't need to be copied to an external library to be used." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Vessels" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Navigate to '~/ORBIT/library/vessels/example_wtiv.yaml':" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "crane_specs:\n", + " max_hook_height: 100 # m\n", + " max_lift: 1200 # t\n", + " max_windspeed: 15 # m/s\n", + "jacksys_specs:\n", + " leg_length: 110 # m\n", + " max_depth: 75 # m\n", + " max_extension: 85 # m\n", + " speed_above_depth: 1 # m/min\n", + " speed_below_depth: 2.5 # m/min\n", + "storage_specs:\n", + " max_cargo: 8000 # t\n", + " max_deck_load: 15 # t/m^2\n", + " max_deck_space: 4000 # m^2\n", + "transport_specs:\n", + " max_waveheight: 3 # m\n", + " max_windspeed: 20 # m/s\n", + " transit_speed: 10 # km/h\n", + "vessel_specs:\n", + " day_rate: 180000 # USD/day\n", + " mobilization_days: 7 # days\n", + " mobilization_mult: 1 # Mobilization multiplier applied to 'day_rate'\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# This vessel file defines a generic WTIV that could be used for installation of turbines, substructures, etc.\n", + "# The vessel file is organized by different subcomponents, eg. crane, jacking system, storage.\n", + "\n", + "# The weather constraints for the vessel are also defined in 'transport_specs' and 'crane_specs'\n", + "# These constraints are applied to underlying processes that the vessel performs in the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Navigate to '~/ORBIT/library/vessels/example_feeder.yaml':" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "crane_specs:\n", + " max_lift: 500 # t\n", + "jacksys_specs:\n", + " leg_length: 85 # m\n", + " max_depth: 40 # m\n", + " max_extension: 60 # m\n", + " speed_above_depth: 0.5 # m/min\n", + " speed_below_depth: 0.5 # m/min\n", + "storage_specs:\n", + " max_cargo: 1200 # t\n", + " max_deck_load: 8 # t/m^2\n", + " max_deck_space: 1000 # m^2\n", + "transport_specs:\n", + " max_waveheight: 2.5 # m\n", + " max_windspeed: 20 # m/s\n", + " transit_speed: 6 # km/h\n", + "vessel_specs:\n", + " day_rate: 75000 # USD/day\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Turbines" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Turbine files contain information on a given turbine and the associated subcomponents.\n", + "# See below for an example 6MW turbine" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/Fun/repos/ORBIT/examples/library'\n" - ] + "cell_type": "raw", + "metadata": {}, + "source": [ + "blade:\n", + " deck_space: 100 # m^2\n", + " length: 75 # m\n", + " mass: 100 # t\n", + "hub_height: 110 # m\n", + "nacelle:\n", + " deck_space: 200 # m^2\n", + " mass: 360 # t\n", + "name: SWT-6MW-154\n", + "rotor_diameter: 154 # m\n", + "tower:\n", + " deck_space: 36 # m^2\n", + " sections: 2 # n\n", + " length: 110 # m\n", + " mass: 150 # t\n", + "turbine_rating: 6 # MW\n", + "rated_windspeed: 13 # m/s\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# These inputs will affect which vessels are able to install the turbine as well as the underyling process times.\n", + "# Deck space is a measure of the area that the component would take up on a transportation vessel." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" } - ], - "source": [ - "# By default, ORBIT initializes the library at '~/ORBIT/library/'\n", - "# The library location can also be changed by using the following:\n", - "\n", - "import os\n", - "from ORBIT.core.library import initialize_library\n", - "initialize_library(os.path.join(os.getcwd(), \"library\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# This allows for proprietary vessel/cable/turbine information to be stored outside of the model repo.\n", - "\n", - "# Note: The library functions will search for library assets at an external library first, but will\n", - "# search the internal ORBIT library if it is not found. This means that the example library files\n", - "# don't need to be copied to an external library to be used." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Vessels" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# Navigate to '~/ORBIT/library/vessels/example_wtiv.yaml':" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "crane_specs:\n", - " max_hook_height: 100 # m\n", - " max_lift: 1200 # t\n", - " max_windspeed: 15 # m/s\n", - "jacksys_specs:\n", - " leg_length: 110 # m\n", - " max_depth: 75 # m\n", - " max_extension: 85 # m\n", - " speed_above_depth: 1 # m/min\n", - " speed_below_depth: 2.5 # m/min\n", - "storage_specs:\n", - " max_cargo: 8000 # t\n", - " max_deck_load: 15 # t/m^2\n", - " max_deck_space: 4000 # m^2\n", - "transport_specs:\n", - " max_waveheight: 3 # m\n", - " max_windspeed: 20 # m/s\n", - " transit_speed: 10 # km/h\n", - "vessel_specs:\n", - " day_rate: 180000 # USD/day\n", - " mobilization_days: 7 # days\n", - " mobilization_mult: 1 # Mobilization multiplier applied to 'day_rate'\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# This vessel file defines a generic WTIV that could be used for installation of turbines, substructures, etc.\n", - "# The vessel file is organized by different subcomponents, eg. crane, jacking system, storage.\n", - "\n", - "# The weather constraints for the vessel are also defined in 'transport_specs' and 'crane_specs'\n", - "# These constraints are applied to underlying processes that the vessel performs in the simulation." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# Navigate to '~/ORBIT/library/vessels/example_feeder.yaml':" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "crane_specs:\n", - " max_lift: 500 # t\n", - "jacksys_specs:\n", - " leg_length: 85 # m\n", - " max_depth: 40 # m\n", - " max_extension: 60 # m\n", - " speed_above_depth: 0.5 # m/min\n", - " speed_below_depth: 0.5 # m/min\n", - "storage_specs:\n", - " max_cargo: 1200 # t\n", - " max_deck_load: 8 # t/m^2\n", - " max_deck_space: 1000 # m^2\n", - "transport_specs:\n", - " max_waveheight: 2.5 # m\n", - " max_windspeed: 20 # m/s\n", - " transit_speed: 6 # km/h\n", - "vessel_specs:\n", - " day_rate: 75000 # USD/day\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Turbines" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Turbine files contain information on a given turbine and the associated subcomponents.\n", - "# See below for an example 6MW turbine" - ] - }, - { - "cell_type": "raw", - "metadata": {}, - "source": [ - "blade:\n", - " deck_space: 100 # m^2\n", - " length: 75 # m\n", - " mass: 100 # t\n", - "hub_height: 110 # m\n", - "nacelle:\n", - " deck_space: 200 # m^2\n", - " mass: 360 # t\n", - "name: SWT-6MW-154\n", - "rotor_diameter: 154 # m\n", - "tower:\n", - " deck_space: 36 # m^2\n", - " sections: 2 # n\n", - " length: 110 # m\n", - " mass: 150 # t\n", - "turbine_rating: 6 # MW\n", - "rated_windspeed: 13 # m/s\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# These inputs will affect which vessels are able to install the turbine as well as the underyling process times.\n", - "# Deck space is a measure of the area that the component would take up on a transportation vessel." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.7.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/examples/supply_chain_dev.ipynb b/examples/supply_chain_dev.ipynb index 8c41411f..040e9664 100644 --- a/examples/supply_chain_dev.ipynb +++ b/examples/supply_chain_dev.ipynb @@ -1,441 +1,441 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 34, - "id": "ad19946b-c043-4e6a-a62c-c5ba4c94389d", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import pandas as pd\n", - "from copy import deepcopy\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from ORBIT import ProjectManager, load_config\n", - "from ORBIT.phases.install import MonopileInstallation, JacketInstallation\n", - "\n", - "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", - " .set_index(\"datetime\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "718a655b-1104-4c5d-a8e4-1e74f6353c3c", - "metadata": {}, - "outputs": [], - "source": [ - "fixed_config = load_config(\"configs/example_fixed_project.yaml\")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "bc5d3a88-d57d-4d1a-b394-726991a9d07b", - "metadata": {}, - "outputs": [], - "source": [ - "fixed_config[\"jacket\"] = {\n", - " \"diameter\": 10,\n", - " \"height\": 100,\n", - " \"length\": 100,\n", - " \"mass\": 100,\n", - " \"deck_space\": 100,\n", - " \"unit_cost\": 1e6\n", - "}\n", - "\n", - "# fixed_config[\"feeder\"] = \"example_feeder\"\n", - "# fixed_config[\"num_feeders\"] = 2\n", - "\n", - "# fixed_config[\"transition_piece\"] = {\n", - "# \"mass\": 1000,\n", - "# \"deck_space\": 1000,\n", - "# \"unit_cost\": 1e6\n", - "# }\n", - "\n", - "# fixed_config[\"jacket_supply_chain\"] = {\n", - "# \"enabled\": True,\n", - "# \"substructure_delivery_time\": 100,\n", - "# \"num_substructures_delivered\": 2,\n", - "# }" - ] - }, - { - "cell_type": "markdown", - "id": "1bc285b7-68a6-4498-b026-59f9d1b33c5c", - "metadata": {}, - "source": [ - "### Jacket Installation w/ Unlimited Storage at Port" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8f86edb1-74fb-43b5-97b5-0a815a1a0693", - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation Time: 7720h\n" - ] - } - ], - "source": [ - "project = JacketInstallation(fixed_config, weather=weather)\n", - "project.run()\n", - "\n", - "df = pd.DataFrame(project.env.actions)\n", - "\n", - "print(f\"Installation Time: {project.total_phase_time:.0f}h\")" - ] - }, - { - "cell_type": "markdown", - "id": "a78686b8-3cc9-4ab2-a732-45afb3167017", - "metadata": {}, - "source": [ - "### Insufficient Substructure Fabrication" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "e03c5be5-8636-4b11-a731-70dd19b0797c", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 34, + "id": "ad19946b-c043-4e6a-a62c-c5ba4c94389d", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "from copy import deepcopy\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from ORBIT import ProjectManager, load_config\n", + "from ORBIT.phases.install import MonopileInstallation, JacketInstallation\n", + "\n", + "weather = pd.read_csv(\"data/example_weather.csv\", parse_dates=[\"datetime\"])\\\n", + " .set_index(\"datetime\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation Time: 12981h\n" - ] - } - ], - "source": [ - "config = deepcopy(fixed_config)\n", - "\n", - "config[\"jacket_supply_chain\"] = {\n", - " \"enabled\": True,\n", - " \"substructure_delivery_time\": 500,\n", - " \"num_substructures_delivered\": 2,\n", - "}\n", - "\n", - "project = JacketInstallation(config, weather=weather)\n", - "project.run()\n", - "\n", - "df = pd.DataFrame(project.env.actions)\n", - "print(f\"Installation Time: {project.total_phase_time:.0f}h\")\n", - "\n", - "# Insufficient fabrication caused a ~5k hour delay" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "e7cab6f9-cddd-4eb6-a613-4e42728799c2", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "718a655b-1104-4c5d-a8e4-1e74f6353c3c", + "metadata": {}, + "outputs": [], + "source": [ + "fixed_config = load_config(\"configs/example_fixed_project.yaml\")" + ] + }, { - "data": { - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 24, + "id": "bc5d3a88-d57d-4d1a-b394-726991a9d07b", + "metadata": {}, + "outputs": [], + "source": [ + "fixed_config[\"jacket\"] = {\n", + " \"diameter\": 10,\n", + " \"height\": 100,\n", + " \"length\": 100,\n", + " \"mass\": 100,\n", + " \"deck_space\": 100,\n", + " \"unit_cost\": 1e6\n", + "}\n", + "\n", + "# fixed_config[\"feeder\"] = \"example_feeder\"\n", + "# fixed_config[\"num_feeders\"] = 2\n", + "\n", + "# fixed_config[\"transition_piece\"] = {\n", + "# \"mass\": 1000,\n", + "# \"deck_space\": 1000,\n", + "# \"unit_cost\": 1e6\n", + "# }\n", + "\n", + "# fixed_config[\"jacket_supply_chain\"] = {\n", + "# \"enabled\": True,\n", + "# \"substructure_delivery_time\": 100,\n", + "# \"num_substructures_delivered\": 2,\n", + "# }" ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "1bc285b7-68a6-4498-b026-59f9d1b33c5c", + "metadata": {}, + "source": [ + "### Jacket Installation w/ Unlimited Storage at Port" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n", - "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n", - "# deliveries\n", - "\n", - "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n", - "installs['number'] = 1\n", - "\n", - "fig = plt.figure(figsize=(6,3), dpi=200)\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n", - "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n", - "\n", - "ax.set_xlim(0, ax.get_xlim()[1])\n", - "ax.set_ylim(0, 5)\n", - "\n", - "ax.set_xlabel(\"Simulation Time\")\n", - "ax.set_ylabel(\"Substructures\")\n", - "\n", - "ax.legend()\n", - "\n", - "# Note period of bad weather at ~10k hours" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "fe12d4b3-1c9a-420a-b3fb-d6fba538822d", - "metadata": {}, - "outputs": [], - "source": [ - "installs_neg = installs.copy()\n", - "installs_neg[\"number\"] *= -1\n", - "\n", - "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n", - "total['storage'] = total['number'].cumsum()\n", - "# total" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "ea3f0a81-5894-42a5-b2f4-f6dcea1b5465", - "metadata": {}, - "outputs": [ + }, { - "data": { - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 32, + "id": "8f86edb1-74fb-43b5-97b5-0a815a1a0693", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation Time: 7720h\n" + ] + } + ], + "source": [ + "project = JacketInstallation(fixed_config, weather=weather)\n", + "project.run()\n", + "\n", + "df = pd.DataFrame(project.env.actions)\n", + "\n", + "print(f\"Installation Time: {project.total_phase_time:.0f}h\")" ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "markdown", + "id": "a78686b8-3cc9-4ab2-a732-45afb3167017", + "metadata": {}, + "source": [ + "### Insufficient Substructure Fabrication" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(6,3), dpi=200)\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n", - "\n", - "ax.set_xlim(0, ax.get_xlim()[1])\n", - "# ax.set_ylim(0, 5)\n", - "\n", - "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n", - "\n", - "ax.set_xlabel(\"Simulation Time (h)\")\n", - "ax.set_ylabel(\"Substructures\")\n", - "\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "2fe95e59-8405-4493-a117-bf147eb2af99", - "metadata": {}, - "source": [ - "### Increased Substructure Fabrication" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "685864c6-b73d-4344-9700-8c9f7daecddd", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation Time: 7850h\n" - ] - } - ], - "source": [ - "config = deepcopy(fixed_config)\n", - "\n", - "config[\"jacket_supply_chain\"] = {\n", - " \"enabled\": True,\n", - " \"substructure_delivery_time\": 250,\n", - " \"num_substructures_delivered\": 2,\n", - "}\n", - "\n", - "project = JacketInstallation(config, weather=weather)\n", - "project.run()\n", - "\n", - "df = pd.DataFrame(project.env.actions)\n", - "print(f\"Installation Time: {project.total_phase_time:.0f}h\")" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "e01ca9cc-9603-4d89-b781-4e646246263d", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 54, + "id": "e03c5be5-8636-4b11-a731-70dd19b0797c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation Time: 12981h\n" + ] + } + ], + "source": [ + "config = deepcopy(fixed_config)\n", + "\n", + "config[\"jacket_supply_chain\"] = {\n", + " \"enabled\": True,\n", + " \"substructure_delivery_time\": 500,\n", + " \"num_substructures_delivered\": 2,\n", + "}\n", + "\n", + "project = JacketInstallation(config, weather=weather)\n", + "project.run()\n", + "\n", + "df = pd.DataFrame(project.env.actions)\n", + "print(f\"Installation Time: {project.total_phase_time:.0f}h\")\n", + "\n", + "# Insufficient fabrication caused a ~5k hour delay" + ] + }, { - "data": { - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 40, + "id": "e7cab6f9-cddd-4eb6-a613-4e42728799c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n", + "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n", + "# deliveries\n", + "\n", + "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n", + "installs['number'] = 1\n", + "\n", + "fig = plt.figure(figsize=(6,3), dpi=200)\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n", + "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n", + "\n", + "ax.set_xlim(0, ax.get_xlim()[1])\n", + "ax.set_ylim(0, 5)\n", + "\n", + "ax.set_xlabel(\"Simulation Time\")\n", + "ax.set_ylabel(\"Substructures\")\n", + "\n", + "ax.legend()\n", + "\n", + "# Note period of bad weather at ~10k hours" ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 41, + "id": "fe12d4b3-1c9a-420a-b3fb-d6fba538822d", + "metadata": {}, + "outputs": [], + "source": [ + "installs_neg = installs.copy()\n", + "installs_neg[\"number\"] *= -1\n", + "\n", + "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n", + "total['storage'] = total['number'].cumsum()\n", + "# total" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n", - "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n", - "# deliveries\n", - "\n", - "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n", - "installs['number'] = 1\n", - "\n", - "fig = plt.figure(figsize=(6,3), dpi=200)\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n", - "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n", - "\n", - "ax.set_xlim(0, ax.get_xlim()[1])\n", - "ax.set_ylim(0, 5)\n", - "\n", - "ax.set_xlabel(\"Simulation Time\")\n", - "ax.set_ylabel(\"Substructures\")\n", - "\n", - "ax.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "cd4e31d9-bbda-4f7d-8df8-33f447231a78", - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "ea3f0a81-5894-42a5-b2f4-f6dcea1b5465", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(6,3), dpi=200)\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n", + "\n", + "ax.set_xlim(0, ax.get_xlim()[1])\n", + "# ax.set_ylim(0, 5)\n", + "\n", + "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n", + "\n", + "ax.set_xlabel(\"Simulation Time (h)\")\n", + "ax.set_ylabel(\"Substructures\")\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "2fe95e59-8405-4493-a117-bf147eb2af99", + "metadata": {}, + "source": [ + "### Increased Substructure Fabrication" + ] + }, { - "data": { - "text/plain": [ - "" + "cell_type": "code", + "execution_count": 50, + "id": "685864c6-b73d-4344-9700-8c9f7daecddd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Installation Time: 7850h\n" + ] + } + ], + "source": [ + "config = deepcopy(fixed_config)\n", + "\n", + "config[\"jacket_supply_chain\"] = {\n", + " \"enabled\": True,\n", + " \"substructure_delivery_time\": 250,\n", + " \"num_substructures_delivered\": 2,\n", + "}\n", + "\n", + "project = JacketInstallation(config, weather=weather)\n", + "project.run()\n", + "\n", + "df = pd.DataFrame(project.env.actions)\n", + "print(f\"Installation Time: {project.total_phase_time:.0f}h\")" ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 51, + "id": "e01ca9cc-9603-4d89-b781-4e646246263d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "deliveries = df.loc[df['action'].str.contains('Delivered')][['action', 'time']]\n", + "deliveries['number'] = deliveries['action'].apply(lambda x: int(x.split(\" \")[1]))\n", + "# deliveries\n", + "\n", + "installs = df.loc[df['action'].str.contains('Grout Jacket')][['action', 'time']]\n", + "installs['number'] = 1\n", + "\n", + "fig = plt.figure(figsize=(6,3), dpi=200)\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.scatter(deliveries['time'], deliveries['number'], s=10, label=\"Substructure(s) Delivered\")\n", + "ax.scatter(installs['time'], installs['number'], s=10, label=\"Completed Installation\")\n", + "\n", + "ax.set_xlim(0, ax.get_xlim()[1])\n", + "ax.set_ylim(0, 5)\n", + "\n", + "ax.set_xlabel(\"Simulation Time\")\n", + "ax.set_ylabel(\"Substructures\")\n", + "\n", + "ax.legend()" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "cd4e31d9-bbda-4f7d-8df8-33f447231a78", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "installs_neg = installs.copy()\n", + "installs_neg[\"number\"] *= -1\n", + "\n", + "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n", + "total['storage'] = total['number'].cumsum()\n", + "\n", + "fig = plt.figure(figsize=(6,3), dpi=200)\n", + "ax = fig.add_subplot(111)\n", + "\n", + "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n", + "\n", + "ax.set_xlim(0, ax.get_xlim()[1])\n", + "# ax.set_ylim(0, 5)\n", + "\n", + "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n", + "\n", + "ax.set_xlabel(\"Simulation Time (h)\")\n", + "ax.set_ylabel(\"Substructures\")\n", + "\n", + "ax.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "ea782cce-81ae-426f-ba5c-8d375e6f0abb", + "metadata": {}, + "source": [ + "### Questions\n", + "\n", + "- Is this approach and the results valuable to Equinor?\n", + "- How to quantify the project cost associated with increased storage required?\n", + " - $/substructure/day\n", + "\n", + " - $/laydown space/day\n", + "\n", + "- How to quantify the delivery costs associated with substructure delivery?\n", + " - $/substructure\n", + "\n", + " - $/substructure/km\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee9c8a0b-2003-4424-a551-8cff89241249", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.9" } - ], - "source": [ - "installs_neg = installs.copy()\n", - "installs_neg[\"number\"] *= -1\n", - "\n", - "total = pd.concat([deliveries, installs_neg]).sort_values('time')\n", - "total['storage'] = total['number'].cumsum()\n", - "\n", - "fig = plt.figure(figsize=(6,3), dpi=200)\n", - "ax = fig.add_subplot(111)\n", - "\n", - "ax.plot(total['time'], total['storage'], label=\"Storage Required\")\n", - "\n", - "ax.set_xlim(0, ax.get_xlim()[1])\n", - "# ax.set_ylim(0, 5)\n", - "\n", - "ax.axhline(4, ls=\"--\", lw=0.5, c='k')\n", - "\n", - "ax.set_xlabel(\"Simulation Time (h)\")\n", - "ax.set_ylabel(\"Substructures\")\n", - "\n", - "ax.legend()" - ] - }, - { - "cell_type": "markdown", - "id": "ea782cce-81ae-426f-ba5c-8d375e6f0abb", - "metadata": {}, - "source": [ - "### Questions\n", - "\n", - "- Is this approach and the results valuable to Equinor?\n", - "- How to quantify the project cost associated with increased storage required?\n", - " - $/substructure/day\n", - "\n", - " - $/laydown space/day\n", - "\n", - "- How to quantify the delivery costs associated with substructure delivery?\n", - " - $/substructure\n", - "\n", - " - $/substructure/km\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ee9c8a0b-2003-4424-a551-8cff89241249", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.9.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/library/turbines/22MW_generic.yaml b/library/turbines/22MW_generic.yaml index 7e6639e5..2723dd0c 100644 --- a/library/turbines/22MW_generic.yaml +++ b/library/turbines/22MW_generic.yaml @@ -18,5 +18,4 @@ tower: type: Tower length: 164.4 # m [IEA-22MW-RWT Value] Hub height - Vertical distance between tower top and hub center mass: 1574 # tonnes [IEA-22MW-RWT Value] -turbine_rating: 22 # MW - +turbine_rating: 22 # MW diff --git a/misc/supply_chain.ipynb b/misc/supply_chain.ipynb index e6d2faa8..4fbe71c3 100644 --- a/misc/supply_chain.ipynb +++ b/misc/supply_chain.ipynb @@ -1,624 +1,624 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "4936af57-5491-46f1-9718-3d31026e017e", - "metadata": {}, - "outputs": [], - "source": [ - "import pprint\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib as mpl\n", - "import matplotlib.pyplot as plt\n", - "from ORBIT import ProjectManager, SupplyChainManager, load_config\n", - "from ORBIT.supply_chain import DEFAULT_MULTIPLIERS, LABOR_SPLIT, TURBINE_CAPEX_SPLIT\n", - "from supply_chain_plots import waterfall_plot, area_time_plot\n", - "\n", - "pp = pprint.PrettyPrinter(indent=4)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "942d274e-07f6-4775-86c4-3dca4d15da94", - "metadata": {}, - "outputs": [ + "cells": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "{ 'array_cable': {'domestic': 0.19, 'imported': 0.0},\n", - " 'blades': {'domestic': 0.026, 'imported': 0.3},\n", - " 'export_cable': {'domestic': 0.231, 'imported': 0.0},\n", - " 'monopile': {'domestic': 0.085, 'imported': 0.28, 'tariffs': 0.25},\n", - " 'nacelle': {'domestic': 0.025, 'imported': 0.1},\n", - " 'oss_substructure': {'domestic': 0.0, 'imported': 0.0},\n", - " 'oss_topside': {'domestic': 0.0, 'imported': 0.0},\n", - " 'tower': {'domestic': 0.04, 'imported': 0.2, 'tariffs': 0.25},\n", - " 'transition_piece': {'domestic': 0.169, 'imported': 0.17, 'tariffs': 0.25}}\n" - ] - } - ], - "source": [ - "# These are from the spreadsheet on teams\n", - "# They can be overridden in ORBIT/supply_chain.py or passed as a new dict\n", - "# into the manager class like SupplyChainManager(supply_chain, multipliers={different multipliers})\n", - "pp.pprint(DEFAULT_MULTIPLIERS)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "2af71bf7-6656-4119-95b1-47fd02378533", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "id": "4936af57-5491-46f1-9718-3d31026e017e", + "metadata": {}, + "outputs": [], + "source": [ + "import pprint\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt\n", + "from ORBIT import ProjectManager, SupplyChainManager, load_config\n", + "from ORBIT.supply_chain import DEFAULT_MULTIPLIERS, LABOR_SPLIT, TURBINE_CAPEX_SPLIT\n", + "from supply_chain_plots import waterfall_plot, area_time_plot\n", + "\n", + "pp = pprint.PrettyPrinter(indent=4)\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'monopile': 0.5, 'oss_topside': 0.5, 'tower': 0.5, 'transition_piece': 0.5}\n" - ] - } - ], - "source": [ - "# These are used for the tariff calculations: tariffs = (1 - labor_split) * total_cost * tariff_rate\n", - "# % of cost that is labor vs material\n", - "pp.pprint(LABOR_SPLIT)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "be736b6d-6be0-4cb2-8645-8e5b6d4af668", - "metadata": {}, - "outputs": [], - "source": [ - "# Load Sample Config\n", - "config = load_config(\"supply_chain_project.yaml\") \n", - "capacity = config['plant']['num_turbines'] * int(config['turbine'].split('M')[0]) * 1000\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "b1831455-d242-457f-b9f9-9b6f831bf0bc", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "id": "942d274e-07f6-4775-86c4-3dca4d15da94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{ 'array_cable': {'domestic': 0.19, 'imported': 0.0},\n", + " 'blades': {'domestic': 0.026, 'imported': 0.3},\n", + " 'export_cable': {'domestic': 0.231, 'imported': 0.0},\n", + " 'monopile': {'domestic': 0.085, 'imported': 0.28, 'tariffs': 0.25},\n", + " 'nacelle': {'domestic': 0.025, 'imported': 0.1},\n", + " 'oss_substructure': {'domestic': 0.0, 'imported': 0.0},\n", + " 'oss_topside': {'domestic': 0.0, 'imported': 0.0},\n", + " 'tower': {'domestic': 0.04, 'imported': 0.2, 'tariffs': 0.25},\n", + " 'transition_piece': {'domestic': 0.169, 'imported': 0.17, 'tariffs': 0.25}}\n" + ] + } + ], + "source": [ + "# These are from the spreadsheet on teams\n", + "# They can be overridden in ORBIT/supply_chain.py or passed as a new dict\n", + "# into the manager class like SupplyChainManager(supply_chain, multipliers={different multipliers})\n", + "pp.pprint(DEFAULT_MULTIPLIERS)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/jnunemak/repos/external/ORBIT/library'\n" - ] - } - ], - "source": [ - "# Define supply chain scenario to use\n", - "# Options are imported, domestic or domestic, imported steel\n", - "supply_chain_scenarios = {\n", - " 2023: {\n", - " \"blades\": \"imported\",\n", - " \"nacelle\": \"imported\",\n", - " \"tower\": \"imported\",\n", - " \"monopile\": \"imported\",\n", - " \"transition_piece\": \"imported\",\n", - " \"array_cable\": \"imported\",\n", - " \"export_cable\": \"imported\",\n", - " \"oss_topside\": \"imported\"\n", - "},\n", - " 2025: {\n", - " \"blades\": \"domestic\",\n", - " \"nacelle\": \"imported\",\n", - " \"tower\": \"domestic, imported steel\",\n", - " \"monopile\": \"domestic, imported steel\",\n", - " \"transition_piece\": \"domestic, imported steel\",\n", - " \"array_cable\": \"imported\",\n", - " \"export_cable\": \"imported\",\n", - " \"oss_topside\": \"domestic\" \n", - " },\n", - " 2027: {\n", - " \"blades\": \"domestic\",\n", - " \"nacelle\": \"domestic\",\n", - " \"tower\": \"domestic, imported steel\",\n", - " \"monopile\": \"domestic\",\n", - " \"transition_piece\": \"domestic, imported steel\",\n", - " \"array_cable\": \"domestic\",\n", - " \"export_cable\": \"domestic\",\n", - " \"oss_topside\": \"domestic\" \n", - " },\n", - " 2030: {\n", - " \"blades\": \"domestic\",\n", - " \"nacelle\": \"domestic\",\n", - " \"tower\": \"domestic\",\n", - " \"monopile\": \"domestic\",\n", - " \"transition_piece\": \"domestic\",\n", - " \"array_cable\": \"domestic\",\n", - " \"export_cable\": \"domestic\",\n", - " \"oss_topside\": \"domestic\" \n", - " },\n", - "}\n", - "\n", - "a = 'test'\n", - "years = []\n", - "scenarios = []\n", - "cost_breakdown = {\n", - " 'Wind turbine': [],\n", - " 'Substructure': [],\n", - " 'Electrical infrastructure': [],\n", - "}\n", - "total_capex = []\n", - "\n", - "opex = 110\n", - "fcr = .058\n", - "ncf = .489\n", - "lcoe = []\n", - "\n", - "for k,v in supply_chain_scenarios.items():\n", - " years.append(k) # list of ints\n", - " _v = SupplyChainManager(v)\n", - " _sc_project= _v.run_project(config)\n", - " cost_breakdown['Wind turbine'].append(_sc_project.capex_breakdown['Turbine'] / capacity) # Nacelle, blades, tower\n", - " cost_breakdown['Substructure'].append(_sc_project.capex_breakdown['Substructure']/ capacity) # Monopile, TP\n", - " cost_breakdown['Electrical infrastructure'].append(_sc_project.capex_breakdown['Array System'] / capacity +\n", - " _sc_project.capex_breakdown['Export System'] / capacity +\n", - " _sc_project.capex_breakdown['Offshore Substation'] / capacity\n", - " ) # Array cables, export cables, OSS\n", - " total_capex.append(_sc_project.total_capex / capacity)\n", - " lcoe.append(1000* (fcr * _sc_project.total_capex_per_kw + opex) / (8760 * ncf) )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "22c5257d", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 3, + "id": "2af71bf7-6656-4119-95b1-47fd02378533", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'monopile': 0.5, 'oss_topside': 0.5, 'tower': 0.5, 'transition_piece': 0.5}\n" + ] + } + ], + "source": [ + "# These are used for the tariff calculations: tariffs = (1 - labor_split) * total_cost * tariff_rate\n", + "# % of cost that is labor vs material\n", + "pp.pprint(LABOR_SPLIT)" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'Wind turbine': [0.0, -5.71753158229571, -7.585204035263082, -7.585204035263082], 'Substructure': [0.0, 0.22892079711949176, -6.073632329891055, -9.862292156751318], 'Electrical infrastructure': [0.0, 0.0, 11.239304468294996, 11.239304468294996]}\n", - "[3525.171189529579, 3444.7533606745355, 3419.073942596618, 3395.439070922778]\n", - "[0.0, -1.4832522822647354, -1.9568917228414917, -2.3928208924097305]\n" - ] - } - ], - "source": [ - "# Create some summary statistics\n", - "cost_breakdown_perc = {\n", - " 'Wind turbine': [],\n", - " 'Substructure': [],\n", - " 'Electrical infrastructure': [],\n", - "}\n", - "for k, v in cost_breakdown.items():\n", - " perc = [100*(i/v[0] -1) for n,i in enumerate(v)]\n", - " cost_breakdown_perc[k] = perc \n", - "print(cost_breakdown_perc)\n", - "\n", - "total_capex_perc = [100*(i/total_capex[0] - 1) for n,i in enumerate(total_capex)] \n", - "print(total_capex)\n", - "\n", - "lcoe_perc = [100*(i/lcoe[0] - 1) for n,i in enumerate(lcoe)] \n", - "print(lcoe_perc)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1646cfef", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 4, + "id": "be736b6d-6be0-4cb2-8645-8e5b6d4af668", + "metadata": {}, + "outputs": [], + "source": [ + "# Load Sample Config\n", + "config = load_config(\"supply_chain_project.yaml\") \n", + "capacity = config['plant']['num_turbines'] * int(config['turbine'].split('M')[0]) * 1000\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2163.834546663371\n" - ] - } - ], - "source": [ - "#Calculte baseline costs with no premiums\n", - "base_project = ProjectManager(config)\n", - "base_project.run()\n", - "base_capex = (base_project.capex_breakdown['Turbine'] + \n", - " base_project.capex_breakdown['Substructure'] + \n", - " base_project.capex_breakdown['Array System'] + \n", - " base_project.capex_breakdown['Export System']+\n", - " base_project.capex_breakdown['Offshore Substation'] ) / capacity\n", - "print(base_capex)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "600b1ed7", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 5, + "id": "b1831455-d242-457f-b9f9-9b6f831bf0bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/jnunemak/repos/external/ORBIT/library'\n" + ] + } + ], + "source": [ + "# Define supply chain scenario to use\n", + "# Options are imported, domestic or domestic, imported steel\n", + "supply_chain_scenarios = {\n", + " 2023: {\n", + " \"blades\": \"imported\",\n", + " \"nacelle\": \"imported\",\n", + " \"tower\": \"imported\",\n", + " \"monopile\": \"imported\",\n", + " \"transition_piece\": \"imported\",\n", + " \"array_cable\": \"imported\",\n", + " \"export_cable\": \"imported\",\n", + " \"oss_topside\": \"imported\"\n", + "},\n", + " 2025: {\n", + " \"blades\": \"domestic\",\n", + " \"nacelle\": \"imported\",\n", + " \"tower\": \"domestic, imported steel\",\n", + " \"monopile\": \"domestic, imported steel\",\n", + " \"transition_piece\": \"domestic, imported steel\",\n", + " \"array_cable\": \"imported\",\n", + " \"export_cable\": \"imported\",\n", + " \"oss_topside\": \"domestic\" \n", + " },\n", + " 2027: {\n", + " \"blades\": \"domestic\",\n", + " \"nacelle\": \"domestic\",\n", + " \"tower\": \"domestic, imported steel\",\n", + " \"monopile\": \"domestic\",\n", + " \"transition_piece\": \"domestic, imported steel\",\n", + " \"array_cable\": \"domestic\",\n", + " \"export_cable\": \"domestic\",\n", + " \"oss_topside\": \"domestic\" \n", + " },\n", + " 2030: {\n", + " \"blades\": \"domestic\",\n", + " \"nacelle\": \"domestic\",\n", + " \"tower\": \"domestic\",\n", + " \"monopile\": \"domestic\",\n", + " \"transition_piece\": \"domestic\",\n", + " \"array_cable\": \"domestic\",\n", + " \"export_cable\": \"domestic\",\n", + " \"oss_topside\": \"domestic\" \n", + " },\n", + "}\n", + "\n", + "a = 'test'\n", + "years = []\n", + "scenarios = []\n", + "cost_breakdown = {\n", + " 'Wind turbine': [],\n", + " 'Substructure': [],\n", + " 'Electrical infrastructure': [],\n", + "}\n", + "total_capex = []\n", + "\n", + "opex = 110\n", + "fcr = .058\n", + "ncf = .489\n", + "lcoe = []\n", + "\n", + "for k,v in supply_chain_scenarios.items():\n", + " years.append(k) # list of ints\n", + " _v = SupplyChainManager(v)\n", + " _sc_project= _v.run_project(config)\n", + " cost_breakdown['Wind turbine'].append(_sc_project.capex_breakdown['Turbine'] / capacity) # Nacelle, blades, tower\n", + " cost_breakdown['Substructure'].append(_sc_project.capex_breakdown['Substructure']/ capacity) # Monopile, TP\n", + " cost_breakdown['Electrical infrastructure'].append(_sc_project.capex_breakdown['Array System'] / capacity +\n", + " _sc_project.capex_breakdown['Export System'] / capacity +\n", + " _sc_project.capex_breakdown['Offshore Substation'] / capacity\n", + " ) # Array cables, export cables, OSS\n", + " total_capex.append(_sc_project.total_capex / capacity)\n", + " lcoe.append(1000* (fcr * _sc_project.total_capex_per_kw + opex) / (8760 * ncf) )\n" + ] + }, { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 20\u001b[0m fig_dir \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 21\u001b[0m fname_bar \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m/capex_barchart.png\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 22\u001b[0m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msavefig\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfig_dir\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mfname_bar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbbox_inches\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtight\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/figure.py:3046\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m 3042\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxes:\n\u001b[1;32m 3043\u001b[0m stack\u001b[38;5;241m.\u001b[39menter_context(\n\u001b[1;32m 3044\u001b[0m ax\u001b[38;5;241m.\u001b[39mpatch\u001b[38;5;241m.\u001b[39m_cm_set(facecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m, edgecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m-> 3046\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprint_figure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:2319\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m 2315\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 2316\u001b[0m \u001b[38;5;66;03m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[1;32m 2317\u001b[0m \u001b[38;5;66;03m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[1;32m 2318\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m cbook\u001b[38;5;241m.\u001b[39m_setattr_cm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure, dpi\u001b[38;5;241m=\u001b[39mdpi):\n\u001b[0;32m-> 2319\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mprint_method\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2320\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2321\u001b[0m \u001b[43m \u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfacecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2322\u001b[0m \u001b[43m \u001b[49m\u001b[43medgecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medgecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2323\u001b[0m \u001b[43m \u001b[49m\u001b[43morientation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morientation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2324\u001b[0m \u001b[43m \u001b[49m\u001b[43mbbox_inches_restore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_bbox_inches_restore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2325\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2326\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 2327\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m bbox_inches \u001b[38;5;129;01mand\u001b[39;00m restore_bbox:\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:1648\u001b[0m, in \u001b[0;36m_check_savefig_extra_args..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1640\u001b[0m _api\u001b[38;5;241m.\u001b[39mwarn_deprecated(\n\u001b[1;32m 1641\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.3\u001b[39m\u001b[38;5;124m'\u001b[39m, name\u001b[38;5;241m=\u001b[39mname, removal\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.6\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 1642\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(name)s\u001b[39;00m\u001b[38;5;124m() got unexpected keyword argument \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1643\u001b[0m \u001b[38;5;241m+\u001b[39m arg \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m which is no longer supported as of \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1644\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(since)s\u001b[39;00m\u001b[38;5;124m and will become an error \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1645\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(removal)s\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1646\u001b[0m kwargs\u001b[38;5;241m.\u001b[39mpop(arg)\n\u001b[0;32m-> 1648\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/_api/deprecation.py:415\u001b[0m, in \u001b[0;36mdelete_parameter..wrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m 405\u001b[0m deprecation_addendum \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 406\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIf any parameter follows \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m, they should be passed as \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 407\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mkeyword, not positionally.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 408\u001b[0m warn_deprecated(\n\u001b[1;32m 409\u001b[0m since,\n\u001b[1;32m 410\u001b[0m name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mrepr\u001b[39m(name),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m deprecation_addendum,\n\u001b[1;32m 414\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 415\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backends/backend_agg.py:541\u001b[0m, in \u001b[0;36mFigureCanvasAgg.print_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args)\u001b[0m\n\u001b[1;32m 494\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 495\u001b[0m \u001b[38;5;124;03mWrite the figure to a PNG file.\u001b[39;00m\n\u001b[1;32m 496\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[38;5;124;03m *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[1;32m 539\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 540\u001b[0m FigureCanvasAgg\u001b[38;5;241m.\u001b[39mdraw(\u001b[38;5;28mself\u001b[39m)\n\u001b[0;32m--> 541\u001b[0m \u001b[43mmpl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimsave\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 542\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuffer_rgba\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mformat\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpng\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mupper\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 543\u001b[0m \u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdpi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetadata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/image.py:1675\u001b[0m, in \u001b[0;36mimsave\u001b[0;34m(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m 1673\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mformat\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mformat\u001b[39m)\n\u001b[1;32m 1674\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdpi\u001b[39m\u001b[38;5;124m\"\u001b[39m, (dpi, dpi))\n\u001b[0;32m-> 1675\u001b[0m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/PIL/Image.py:2297\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2295\u001b[0m fp \u001b[38;5;241m=\u001b[39m builtins\u001b[38;5;241m.\u001b[39mopen(filename, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr+b\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2296\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 2297\u001b[0m fp \u001b[38;5;241m=\u001b[39m \u001b[43mbuiltins\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mw+b\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2299\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 2300\u001b[0m save_handler(\u001b[38;5;28mself\u001b[39m, fp, filename)\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'" - ] + "cell_type": "code", + "execution_count": 6, + "id": "22c5257d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'Wind turbine': [0.0, -5.71753158229571, -7.585204035263082, -7.585204035263082], 'Substructure': [0.0, 0.22892079711949176, -6.073632329891055, -9.862292156751318], 'Electrical infrastructure': [0.0, 0.0, 11.239304468294996, 11.239304468294996]}\n", + "[3525.171189529579, 3444.7533606745355, 3419.073942596618, 3395.439070922778]\n", + "[0.0, -1.4832522822647354, -1.9568917228414917, -2.3928208924097305]\n" + ] + } + ], + "source": [ + "# Create some summary statistics\n", + "cost_breakdown_perc = {\n", + " 'Wind turbine': [],\n", + " 'Substructure': [],\n", + " 'Electrical infrastructure': [],\n", + "}\n", + "for k, v in cost_breakdown.items():\n", + " perc = [100*(i/v[0] -1) for n,i in enumerate(v)]\n", + " cost_breakdown_perc[k] = perc \n", + "print(cost_breakdown_perc)\n", + "\n", + "total_capex_perc = [100*(i/total_capex[0] - 1) for n,i in enumerate(total_capex)] \n", + "print(total_capex)\n", + "\n", + "lcoe_perc = [100*(i/lcoe[0] - 1) for n,i in enumerate(lcoe)] \n", + "print(lcoe_perc)" + ] }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 7, + "id": "1646cfef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2163.834546663371\n" + ] + } + ], + "source": [ + "#Calculte baseline costs with no premiums\n", + "base_project = ProjectManager(config)\n", + "base_project.run()\n", + "base_capex = (base_project.capex_breakdown['Turbine'] + \n", + " base_project.capex_breakdown['Substructure'] + \n", + " base_project.capex_breakdown['Array System'] + \n", + " base_project.capex_breakdown['Export System']+\n", + " base_project.capex_breakdown['Offshore Substation'] ) / capacity\n", + "print(base_capex)" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "years[0] = str(years[0]) + ' \\n(Fully imported)'\n", - "years[-1] = str(years[-1]) + '\\n(Fully domestic)'\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot()\n", - "df = pd.DataFrame(cost_breakdown, index=years)\n", - "df.plot.bar(stacked=True, rot=45, ax=ax)\n", - "\n", - "ax.plot([-5,5], [base_capex, base_capex], 'k--', label='Baseline (wind turbine + substructure + electrical)')\n", - "\n", - "# Formatting\n", - "ax.set_ylim([0,4000])\n", - "ax.set_ylabel('Component capex, $/kW')\n", - "# ax.set_xlabel('Commercial operation date')\n", - "ax.get_yaxis().set_major_formatter(\n", - " mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n", - "ax.legend(loc='upper left')\n", - "\n", - "# SAve fig\n", - "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n", - "fname_bar = '/capex_barchart.png'\n", - "fig.savefig(fig_dir+fname_bar, dpi=300, bbox_inches='tight')\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6143f120", - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 8, + "id": "600b1ed7", + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 20\u001b[0m fig_dir \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mC:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 21\u001b[0m fname_bar \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m/capex_barchart.png\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 22\u001b[0m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msavefig\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfig_dir\u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43mfname_bar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m300\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbbox_inches\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mtight\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/figure.py:3046\u001b[0m, in \u001b[0;36mFigure.savefig\u001b[0;34m(self, fname, transparent, **kwargs)\u001b[0m\n\u001b[1;32m 3042\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxes:\n\u001b[1;32m 3043\u001b[0m stack\u001b[38;5;241m.\u001b[39menter_context(\n\u001b[1;32m 3044\u001b[0m ax\u001b[38;5;241m.\u001b[39mpatch\u001b[38;5;241m.\u001b[39m_cm_set(facecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m, edgecolor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mnone\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m-> 3046\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprint_figure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:2319\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m 2315\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 2316\u001b[0m \u001b[38;5;66;03m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[1;32m 2317\u001b[0m \u001b[38;5;66;03m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[1;32m 2318\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m cbook\u001b[38;5;241m.\u001b[39m_setattr_cm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure, dpi\u001b[38;5;241m=\u001b[39mdpi):\n\u001b[0;32m-> 2319\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43mprint_method\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2320\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2321\u001b[0m \u001b[43m \u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfacecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2322\u001b[0m \u001b[43m \u001b[49m\u001b[43medgecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medgecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2323\u001b[0m \u001b[43m \u001b[49m\u001b[43morientation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morientation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2324\u001b[0m \u001b[43m \u001b[49m\u001b[43mbbox_inches_restore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_bbox_inches_restore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2325\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2326\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 2327\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m bbox_inches \u001b[38;5;129;01mand\u001b[39;00m restore_bbox:\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backend_bases.py:1648\u001b[0m, in \u001b[0;36m_check_savefig_extra_args..wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1640\u001b[0m _api\u001b[38;5;241m.\u001b[39mwarn_deprecated(\n\u001b[1;32m 1641\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.3\u001b[39m\u001b[38;5;124m'\u001b[39m, name\u001b[38;5;241m=\u001b[39mname, removal\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m3.6\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 1642\u001b[0m message\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(name)s\u001b[39;00m\u001b[38;5;124m() got unexpected keyword argument \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1643\u001b[0m \u001b[38;5;241m+\u001b[39m arg \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m which is no longer supported as of \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1644\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(since)s\u001b[39;00m\u001b[38;5;124m and will become an error \u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 1645\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%(removal)s\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 1646\u001b[0m kwargs\u001b[38;5;241m.\u001b[39mpop(arg)\n\u001b[0;32m-> 1648\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/_api/deprecation.py:415\u001b[0m, in \u001b[0;36mdelete_parameter..wrapper\u001b[0;34m(*inner_args, **inner_kwargs)\u001b[0m\n\u001b[1;32m 405\u001b[0m deprecation_addendum \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m 406\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIf any parameter follows \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m, they should be passed as \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 407\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mkeyword, not positionally.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 408\u001b[0m warn_deprecated(\n\u001b[1;32m 409\u001b[0m since,\n\u001b[1;32m 410\u001b[0m name\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mrepr\u001b[39m(name),\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 413\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m deprecation_addendum,\n\u001b[1;32m 414\u001b[0m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m--> 415\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minner_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/backends/backend_agg.py:541\u001b[0m, in \u001b[0;36mFigureCanvasAgg.print_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args)\u001b[0m\n\u001b[1;32m 494\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 495\u001b[0m \u001b[38;5;124;03mWrite the figure to a PNG file.\u001b[39;00m\n\u001b[1;32m 496\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[38;5;124;03m *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[1;32m 539\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 540\u001b[0m FigureCanvasAgg\u001b[38;5;241m.\u001b[39mdraw(\u001b[38;5;28mself\u001b[39m)\n\u001b[0;32m--> 541\u001b[0m \u001b[43mmpl\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mimsave\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 542\u001b[0m \u001b[43m \u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuffer_rgba\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mformat\u001b[39;49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpng\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43morigin\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mupper\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 543\u001b[0m \u001b[43m \u001b[49m\u001b[43mdpi\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdpi\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmetadata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/matplotlib/image.py:1675\u001b[0m, in \u001b[0;36mimsave\u001b[0;34m(fname, arr, vmin, vmax, cmap, format, origin, dpi, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m 1673\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mformat\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28mformat\u001b[39m)\n\u001b[1;32m 1674\u001b[0m pil_kwargs\u001b[38;5;241m.\u001b[39msetdefault(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdpi\u001b[39m\u001b[38;5;124m\"\u001b[39m, (dpi, dpi))\n\u001b[0;32m-> 1675\u001b[0m \u001b[43mimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfname\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/opt/miniconda3/envs/orbit-dev/lib/python3.9/site-packages/PIL/Image.py:2297\u001b[0m, in \u001b[0;36mImage.save\u001b[0;34m(self, fp, format, **params)\u001b[0m\n\u001b[1;32m 2295\u001b[0m fp \u001b[38;5;241m=\u001b[39m builtins\u001b[38;5;241m.\u001b[39mopen(filename, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr+b\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 2296\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 2297\u001b[0m fp \u001b[38;5;241m=\u001b[39m \u001b[43mbuiltins\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mw+b\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m 2299\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 2300\u001b[0m save_handler(\u001b[38;5;28mself\u001b[39m, fp, filename)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/capex_barchart.png'" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "years[0] = str(years[0]) + ' \\n(Fully imported)'\n", + "years[-1] = str(years[-1]) + '\\n(Fully domestic)'\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "df = pd.DataFrame(cost_breakdown, index=years)\n", + "df.plot.bar(stacked=True, rot=45, ax=ax)\n", + "\n", + "ax.plot([-5,5], [base_capex, base_capex], 'k--', label='Baseline (wind turbine + substructure + electrical)')\n", + "\n", + "# Formatting\n", + "ax.set_ylim([0,4000])\n", + "ax.set_ylabel('Component capex, $/kW')\n", + "# ax.set_xlabel('Commercial operation date')\n", + "ax.get_yaxis().set_major_formatter(\n", + " mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n", + "ax.legend(loc='upper left')\n", + "\n", + "# SAve fig\n", + "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n", + "fname_bar = '/capex_barchart.png'\n", + "fig.savefig(fig_dir+fname_bar, dpi=300, bbox_inches='tight')\n" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "dict_lcoe = {'LCOE': lcoe}\n", - "# for y, l in zip(years, lcoe):\n", - "# print(y,l)\n", - "# dict_lcoe[y] = l\n", - "\n", - "df_lcoe = pd.DataFrame(dict_lcoe, index=years)\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot()\n", - "df_lcoe.plot.bar(rot=45, ax=ax)\n", - "\n", - "# Formatting\n", - "ax.get_legend().remove()\n", - "ax.set_ylabel('Levelized cost of energy, $/MWh')\n", - "\n", - "# SAve fig\n", - "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n", - "fname_lcoe = '/lcoe_barchart.png'\n", - "fig.savefig(fig_dir+fname_lcoe, dpi=300, bbox_inches='tight')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d2c0f18e", - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAH4CAYAAAB5UPiRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAACRRUlEQVR4nOzdd3zM9x/A8ddl70UiQUhir9h7RIyiKNWh2lpVGqsobVGU2h1+rdasmtXSgdauFXvvPRLECEFkz7v7/v44OYKQI5e7JO/n45EH9/mu993n5PP2+X6+n49KURQFIYQQQgiRoyxMHYAQQgghRH4kSZYQQgghhBFIkiWEEEIIYQSSZAkhhBBCGIEkWUIIIYQQRiBJlhBCCCGEEUiSJYQQQghhBJJkCSGEEEIYgSRZQgghhBBGIEmWEEIIIYQR5Kkka8eOHbRv356iRYuiUqlYtWpVpu09evRApVJl+mndurVpghVCCCFEgZankqzExESqVq3KjBkzstyndevWREZG6n9+//33XIxQCCGEEELHytQBGKJNmza0adPmmfvY2tri7e2dSxEJIYQQQjxdnkqysiM0NBQvLy/c3d1p1qwZEyZMoFChQlnun5qaSmpqqv61VqslOjqaQoUKoVKpciNkIYQQQrwkRVGIj4+naNGiWFiYx426fJVktW7dmk6dOuHv709YWBgjR46kTZs27N27F0tLy6ceM3nyZMaNG5fLkQohhBDCGK5du0bx4sVNHQYAKkVRFFMH8SJUKhUrV66kY8eOWe4THh5OqVKl2Lx5M82bN3/qPo/3ZMXGxlKiRAmuXbuGi4tLTocthBBCCCOIi4vD19eXmJgYXF1dTR0OkM96sh4XEBBA4cKFuXTpUpZJlq2tLba2tk+Uu7i4SJIlhBBC5DHmNNTHPG5aGsn169e5d+8ePj4+pg5FCCGEEAVMnurJSkhI4NKlS/rXly9f5tixY3h4eODh4cG4ceN444038Pb2JiwsjM8++4zSpUvTqlUrE0YthBBCiIIoTyVZhw4dIjg4WP/6k08+AaB79+7MmjWLEydOsGjRImJiYihatCivvPIK48ePf+rtQCGEEEIIY8qzA9+NJS4uDldXV2JjY7Mck6XRaEhPT8/lyITIX6ytrbN86lcIIQyVnfY7t+WpnixTUxSFW7duERMTY+pQhMgX3Nzc8Pb2NquBqkIIkVMkyTJARoLl5eWFg4ODNAxCvCBFUUhKSiIqKgpAHk4RQuRLkmRlk0aj0SdYz5pBXgiRPfb29gBERUXh5eUltw6FEPlOvp7CISdljMFycHAwcSRC5B8Z/55kjKMQIj+SJMtAcotQiJwj/56EEPmZJFlCCCGEEEYgSZZ4qtDQUFQq1Us/SdmjR49nri+Z0xYuXIibm9sz9xk7dizVqlXLlXiEEEIUXJJk5XOzZ8/G2dkZtVqtL0tISMDa2pqmTZtm2jcjsQoLC6NBgwZERkYafZHN7CRFOW3YsGFs2bIlV68phBCi4JEkK58LDg4mISGBQ4cO6ct27tyJt7c3+/fvJyUlRV++bds2SpQoQalSpbCxsclz8xdld/C0k5OTPCEqhBDC6CTJyufKlSuHj48PoaGh+rLQ0FA6dOiAv78/+/bty1SesWzR47cLM3qcNm7cSIUKFXBycqJ169ZERkbqj9doNHzyySe4ublRqFAhPvvsM561oEBoaCg9e/YkNjYWlUqFSqVi7NixgG5A9KpVqzLt7+bmxsKFCwG4cuUKKpWK5cuXExQUhJ2dHUuXLtXvu2rVKsqUKYOdnR2tWrXi2rVr+m2P3y7MuKX57bff4uPjQ6FChejfv3+mpC01NZVhw4ZRrFgxHB0dqVu3bqbPVAghhHicJFkvQVEUktLUJvkxZDWk4OBgtm3bpn+9bds2mjZtSlBQkL48OTmZ/fv3Z1ob8nFJSUl8++23LFmyhB07dhAREcGwYcP027/77jsWLlzI/Pnz2bVrF9HR0axcuTLL8zVo0IDvv/8eFxcXIiMjiYyMzHS+7Bg+fDiDBg3i7Nmz+oXAk5KSmDhxIosXL2b37t3ExMTwzjvvPPM827ZtIywsjG3btrFo0SIWLlyoT+gABgwYwN69e1m2bBknTpzgrbfeonXr1ly8eNGgeIUQQhQcMhnpS0hO11BxzEaTXPvMV61wsMle9QUHBzN48GDUajXJyckcPXqUoKAg0tPTmT17NgB79+4lNTX1mUlWxv6lSpUCdInHV199pd/+/fffM2LECDp16gToxoNt3Jj152NjY4OrqysqlQpvb+9svZfHDR48WH+9R+P86aefqFu3LgCLFi2iQoUKHDhwgDp16jz1PO7u7vz0009YWlpSvnx52rZty5YtW+jduzcREREsWLCAiIgIihYtCujGdW3YsIEFCxYwadKkF4pdCCFE/iZJVgHQtGlTEhMTOXjwIPfv36ds2bJ4enoSFBREz549SUlJITQ0lICAAEqUKJHleRwcHPQJFuiWQslYFiU2NpbIyEh9YgNgZWVFrVq1DOp1M1StWrWeKLOysqJ27dr61+XLl8fNzY2zZ89mmWRVqlQp04zjPj4+nDx5EoCTJ0+i0WgoW7ZspmNSU1NlbJcQQogsSZL1EuytLTnzVSuTXTu7SpcuTfHixdm2bRv3798nKCgIgKJFi+Lr68uePXvYtm0bzZo1e+Z5rK2tM71WqVRGS6Cedu6nDWx3dHTMkes97b1ptVpA9zSmpaUlhw8ffmLpFycnpxy5vhBCiPxHkqyXoFKpsn3LztSCg4MJDQ3l/v37fPrpp/ryJk2asH79eg4cOEDfvn1f+Pyurq74+Piwf/9+mjRpAoBarebw4cPUqFEjy+NsbGzQaDRPlHt6emYaVH/x4kWSkpKyFYtarebQoUP6Xqvz588TExNDhQoVDHlLetWrV0ej0RAVFUXjxo1f6BxCCCEKHhn4XkAEBweza9cujh07pu/JAggKCmLOnDmkpaU9czxWdgwaNIgpU6awatUqzp07R79+/Z47mamfnx8JCQls2bKFu3fv6hOpZs2a8dNPP3H06FEOHTpESEjIE71NWbG2tmbgwIHs37+fw4cP06NHD+rVq5flrcLnKVu2LO+99x7dunVjxYoVXL58mQMHDjB58mTWrl37QucUQgiR/0mSVUAEBweTnJxM6dKlKVKkiL48KCiI+Ph4/VQPL2Po0KF07dqV7t27U79+fZydnXn99defeUyDBg0ICQmhc+fOeHp68vXXXwO6JxV9fX1p3Lgx7777LsOGDcv24twODg58/vnnvPvuuzRs2BAnJyeWL1/+Uu9twYIFdOvWjaFDh1KuXDk6duzIwYMHnzmGTQghRMGmUow5KjkPiouLw9XVldjYWFxcXPTlKSkpXL58GX9/f+zs7EwYoRD5h/y7EkLklKzab1OSniwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLZEtoaCgqleq5axEKIYQQQkeSrALizp079O3blxIlSmBra4u3tzetWrVi9+7duXL93E7SevToQceOHXPlWkIIIcTTWJk6AJE73njjDdLS0li0aBEBAQHcvn2bLVu2cO/ePVOHlklaWho2NjamDkNPo9GgUqmwsJD/jwghhDCMtBwFQExMDDt37mTq1KkEBwdTsmRJ6tSpw4gRI3jttde4cuUKKpWKY8eOZTpGpVIRGhqa6Vy7d+8mMDAQOzs76tWrx6lTp/Tbrl69Svv27XF3d8fR0ZFKlSqxbt06rly5QnBwMADu7u6oVCp69OgBQNOmTRkwYACDBw+mcOHCtGrVKtvxnD59mnbt2uHi4oKzszONGzcmLCyMsWPHsmjRIv755x9UKpX+uKf1ph07dgyVSsWVK1cAWLhwIW5ubvz7779UrFgRW1tbIiIiSE1NZdiwYRQrVgxHR0fq1q37xGcjhBBCPEp6sl6GokB6kmmube0AKlW2dnVycsLJyYlVq1ZRr149bG1tX/iyn376KT/88APe3t6MHDmS9u3bc+HCBaytrenfvz9paWns2LEDR0dHzpw5g5OTE76+vvz999+88cYbnD9/HhcXF+zt7fXnXLRoEX379jXo1uWNGzdo0qQJTZs2ZevWrbi4uLB7927UajXDhg3j7NmzxMXFsWDBAgA8PDzYs2dPts6dlJTE1KlTmTdvHoUKFcLLy4sBAwZw5swZli1bRtGiRVm5ciWtW7fm5MmTlClTxrAPUQghRIEgSdbLSE+CSUVNc+2RN8HGMVu7WllZsXDhQnr37s3s2bOpUaMGQUFBvPPOOwQGBhp02S+//JKWLVsCuuSoePHirFy5krfffpuIiAjeeOMNqlSpAkBAQID+OA8PDwC8vLxwc3PLdM4yZcrw9ddf619n9Co9y4wZM3B1dWXZsmVYW1sDULZsWf12e3t7UlNT8fb2Nuj9AaSnpzNz5kyqVq0KQEREBAsWLCAiIoKiRXX1PWzYMDZs2MCCBQuYNGmSwdcQQgiR/8ntwgLijTfe4ObNm/z777+0bt2a0NBQatSowcKFCw06T/369fV/9/DwoFy5cpw9exaAjz/+mAkTJtCwYUO+/PJLTpw4ka1z1qxZ06AYQHebr3HjxvoEKyfZ2NhkSj5PnjyJRqOhbNmy+l5BJycntm/fTlhYWI5fXwghRP4gPVkvw9pB16NkqmsbyM7OjpYtW9KyZUtGjx7Nhx9+yJdffsnOnTsBUBRFv296errB5//www9p1aoVa9eu5b///mPy5Ml89913DBw48JnHOTpm7pHLGGT+rHgevd2YXdk5b8a5VY/cik1ISMDS0pLDhw9jaWmZaV8nJyeD4xBCCFEwSE/Wy1CpdLfsTPGTzfFYz1KxYkUSExPx9PQEIDIyUr/t0UHnj9q3b5/+7/fv3+fChQtUqFBBX+br60tISAgrVqxg6NCh/PzzzwD6JwY1Gs1z48pOPIGBgezcuTPLZNDGxuaJaxnyPh9VvXp1NBoNUVFRlC5dOtPPi9yOFEIIUTBIklUA3Lt3j2bNmvHrr79y4sQJLl++zJ9//snXX39Nhw4dsLe3p169ekyZMoWzZ8+yfft2Ro0a9dRzffXVV2zZsoVTp07Ro0cPChcurJ+PavDgwWzcuJHLly9z5MgRtm3bpk/ASpYsiUqlYs2aNdy5c4eEhIQs481OPAMGDCAuLo533nmHQ4cOcfHiRZYsWcL58+cB8PPz48SJE5w/f567d++Snp5O6dKl8fX1ZezYsVy8eJG1a9fy3XffPffzK1u2LO+99x7dunVjxYoVXL58mQMHDjB58mTWrl2bnSoQQghRECkik9jYWAVQYmNjM5UnJycrZ86cUZKTk00U2YtLSUlRhg8frtSoUUNxdXVVHBwclHLlyimjRo1SkpKSFEVRlDNnzij169dX7O3tlWrVqin//fefAijbtm1TFEVRtm3bpgDK6tWrlUqVKik2NjZKnTp1lOPHj+uvM2DAAKVUqVKKra2t4unpqXTt2lW5e/eufvtXX32leHt7KyqVSunevbuiKIoSFBSkDBo06ImYnxePoijK8ePHlVdeeUVxcHBQnJ2dlcaNGythYWGKoihKVFSU0rJlS8XJySnTcbt27VKqVKmi2NnZKY0bN1b+/PNPBVAuX76sKIqiLFiwQHF1dX0inrS0NGXMmDGKn5+fYm1trfj4+Civv/66cuLEiRerFKEoSt7+dyWEMC9Ztd+mpFKURwaoCOLi4nB1dSU2NhYXFxd9eUpKCpcvX8bf3x87OzsTRihE/iH/rszTrcRbzDo+i3vJ5jVZscg//hf8P6wtcvbBpazab1OSge9CCCH0wmPD+WjTR9xKvGXqUER+VkC6dyTJEkIIAcDpu6fpu7kv91Pv4+fiR8/KPVHx8g/ZCPE4C1XBGBIuSZYQQggORB5g4NaBJKmTqFSoEjNbzMTDzsPUYQmRpxWMVFIIIUSWNl/dTMjmEJLUSdT1rssvrX6RBEuIHCBJlhBCFGArLq5g6PahpGvTaVGiBTNbzMTROntLdgkhnk1uFwohRAE1/9R8/nf4fwC8UeYNRtcbjaWF5XOOEkJklyRZQghRwCiKwrTD01h4eiEAvSr3YlCNQZmWkxJCvDxJsoQQogBRa9WM2zuOVZdWATCs1jC6V+pu2qCEyKckyRJCiAIiVZPKp9s/Zdu1bViqLBnbYCwdS3c0dVhC5Fsy8F0AoFKpWLVqlUmu3bRpUwYPHpxj5+vRo4d+PcWnWbhwIW5ubgadU1EU+vTpg4eHByqVKlsLSwthTuLT4gnZFMK2a9uwsbBhWtNpkmAJYWSSZBUAPXr0QKVSPfHTunVro13TkKRtxYoVjB8/3mixPK5z585cuHDBoGM2bNjAwoULWbNmDZGRkVSuXNkosYWGhqJSqYiJiTHK+R/3vIRU5A/3ku/Ra2MvDt0+hKO1I7NbzqZZiWamDkuIfE9uFxYQrVu3ZsGCBZnKbG1tTRSNTlpaGjY2Nnh45O58PPb29tjb2xt0TFhYGD4+PjRo0CDLfTLeT27IzWtlh0ajQaVSYWEh/28zNzcTbtJnUx+uxl3Fw86D2S1mU6FQBVOHJUSBkKd+I+7YsYP27dtTtGjRp/aUKIrCmDFj8PHxwd7enhYtWnDx4kXTBGtmbG1t8fb2zvTj7u6e5f7Xrl3j7bffxs3NDQ8PDzp06MCVK1cy7TN//nwqVaqEra0tPj4+DBgwAAA/Pz8AXn/9dVQqlf712LFjqVatGvPmzcu0IPDjtwtTU1P5/PPP8fX1xdbWltKlS/PLL78Ausa8V69e+Pv7Y29vT7ly5fjhhx8M+iwev12YEdeSJUvw8/PD1dWVd955h/j4eEDX2zNw4EAiIiIyvZ+mTZsyYMAABg8eTOHChWnVqhUA06ZNo0qVKjg6OuLr60u/fv1ISEjQX+/q1au0b98ed3d3HB0dqVSpEuvWrePKlSsEBwcD4O7ujkqlokePHlle68qVK0/cuoyJiUGlUhEaGqovO336NO3atcPFxQVnZ2caN25MWFgYY8eOZdGiRfzzzz/63s3Q0NCn9qYdO3YMlUql/w5kfIb//vsvFStWxNbWloiICFJTUxk2bBjFihXD0dGRunXrZopF5K5L9y/RdX1XrsZdpahjURa3WSwJlhC5KE/1ZCUmJlK1alU++OADOnXq9MT2r7/+munTp7No0SL8/f0ZPXo0rVq14syZM/oGPScpikKyOjnHz5sd9lb2RnvcOj09nVatWlG/fn127tyJlZUVEyZMoHXr1pw4cQIbGxtmzZrFJ598wpQpU2jTpg2xsbHs3r0bgIMHD+Ll5cWCBQto3bo1lpYP5925dOkSf//9NytWrMhU/qhu3bqxd+9epk+fTtWqVbl8+TJ3794FQKvVUrx4cf78808KFSrEnj176NOnDz4+Prz99tsv/J7DwsJYtWoVa9as4f79+7z99ttMmTKFiRMn8sMPP1CqVCnmzp3LwYMHM8W9aNEi+vbtq3/vABYWFkyfPh1/f3/Cw8Pp168fn332GTNnzgSgf//+pKWlsWPHDhwdHTlz5gxOTk74+vry999/88Ybb3D+/HlcXFwy9bg97VrPc+PGDZo0aULTpk3ZunUrLi4u7N69G7VazbBhwzh79ixxcXH6Xk4PDw/27NmTrXMnJSUxdepU5s2bR6FChfDy8mLAgAGcOXOGZcuWUbRoUVauXEnr1q05efIkZcqUyXbc4uUdv3Ocfpv7EZcWR2m30sxuMZsijkVMHZYQBUqeSrLatGlDmzZtnrpNURS+//57Ro0aRYcOHQBYvHgxRYoUYdWqVbzzzjs5Hk+yOpm6v9XN8fNmx/539+Ng7ZDt/desWYOTk1OmspEjRzJy5Mgn9l2+fDlarZZ58+bpE7kFCxbg5uZGaGgor7zyChMmTGDo0KEMGjRIf1zt2rUB8PT0BMDNzQ1vb+9M505LS2Px4sX6fR534cIF/vjjDzZt2kSLFi0ACAgI0G+3trZm3Lhx+tf+/v7s3buXP/7446WSLK1Wy8KFC3F2dgaga9eubNmyhYkTJ+Lq6oqzszOWlpZPvJ8yZcrw9ddfZyp7tFfOz8+PCRMmEBISok+yIiIieOONN6hSpcoT7y/j1qmXl9cTg/Mfv9bjPYtPM2PGDFxdXVm2bBnW1tYAlC1bVr/d3t6e1NTUJ95XdqSnpzNz5kyqVq2qf18LFiwgIiKCokWLAjBs2DA2bNjAggULmDRpksHXEC9m943dDAkdQrI6mUDPQGY2n4mrraupwxKiwMlTSdazXL58mVu3bukbZgBXV1fq1q3L3r17s0yyUlNTSU1N1b+Oi4szeqymEBwczKxZszKVZTUW6vjx41y6dEmfcGRISUkhLCyMqKgobt68SfPmzQ2Oo2TJklkmWKC7LWVpaUlQUFCW+8yYMYP58+cTERFBcnIyaWlpVKtWzeBYHuXn55fp/fr4+BAVFfXc42rWrPlE2ebNm5k8eTLnzp0jLi4OtVpNSkoKSUlJODg48PHHH9O3b1/+++8/WrRowRtvvEFgYOALXet5jh07RuPGjfUJVk6ysbHJFPfJkyfRaDSZkjjQ/RsrVKhQjl9fPN2GyxsYsWsEaq2ahkUbMq3pNIP+QyaEyDn5Jsm6desWAEWKZO4OL1KkiH7b00yePDlTz4gh7K3s2f/u/hc69mXZWxk2cNvR0ZHSpUtna9+EhARq1qzJ0qVLn9jm6en5UoObHR2fvSba8wakL1u2jGHDhvHdd99Rv359nJ2d+eabb9i//+Xq4fEkRKVSodVqn3vc4+/nypUrtGvXjr59+zJx4kQ8PDzYtWsXvXr1Ii0tDQcHBz788ENatWrF2rVr+e+//5g8eTLfffcdAwcONOhaGfWgKIq+LD09PdM+hg7wz+55M8796C3rhIQELC0tOXz48BO3gh/vRRXGsfzccibun4iCQmu/1kxqNAlry5xPsIUQ2ZNvkqwXNWLECD755BP967i4OHx9fbN1rEqlypf/Q6xRowbLly/Hy8sLFxeXp+7j5+fHli1b9AO1H2dtbY1GozH42lWqVEGr1bJ9+/ZMvZIZdu/eTYMGDejXr5++LCwszODrGMvhw4fRarV89913+mTljz/+eGI/X19fQkJCCAkJYcSIEfz8888MHDhQ/8Rgdj67jB7ByMhIqlevDvDE/F2BgYEsWrSI9PT0p/Zm2djYPHGtR8+b8XBEduYFq169OhqNhqioKBo3bvzc/UXOURSFOSfmMOPYDAA6l+vMiDojZB1CIUwsTz1d+CwZY0pu376dqfz27dvPHG9ia2uLi4tLpp/8KDU1lVu3bmX6yRhM/rj33nuPwoUL06FDB3bu3Mnly5cJDQ3l448/5vr164DuibzvvvuO6dOnc/HiRY4cOcKPP/6oP0dGEnbr1i3u37+f7Tj9/Pzo3r07H3zwAatWrdJfOyNRKVOmDIcOHWLjxo1cuHCB0aNHc/DgwZf4ZHJW6dKlSU9P58cffyQ8PJwlS5Ywe/bsTPsMHjyYjRs3cvnyZY4cOcK2bduoUEH3xFfJkiVRqVSsWbOGO3fuZHoq8XH29vbUq1ePKVOmcPbsWbZv386oUaMy7TNgwADi4uJ45513OHToEBcvXmTJkiWcP38e0H3eJ06c4Pz589y9e5f09HRKly6Nr68vY8eO5eLFi6xdu5bvvvvuue+9bNmyvPfee3Tr1o0VK1Zw+fJlDhw4wOTJk1m7dq2hH6XIJq2iZerBqfoEK6RqCF/U/UISLCHMQL5Jsvz9/fH29mbLli36sri4OPbv30/9+vVNGJl52LBhAz4+Ppl+GjVq9NR9HRwc2LFjByVKlKBTp05UqFCBXr16kZKSok9Cu3fvzvfff8/MmTOpVKkS7dq1yzRdxnfffcemTZvw9fXV97Jk16xZs3jzzTfp168f5cuXp3fv3iQmJgLw0Ucf0alTJzp37kzdunW5d+9epl4tU6tatSrTpk1j6tSpVK5cmaVLlzJ58uRM+2g0Gvr370+FChVo3bo1ZcuW1Q+KL1asGOPGjWP48OEUKVJEPy1GVubPn49araZmzZoMHjyYCRMmZNpeqFAhtm7dSkJCAkFBQdSsWZOff/5Z36vVu3dvypUrR61atfD09GT37t1YW1vz+++/c+7cOQIDA5k6deoT583KggUL6NatG0OHDqVcuXJ07NiRgwcPUqJEiex+hMIA6dp0Ru4aydKzulv7w+sMp3+1/rLQsxBmQqU8OvDCzCUkJHDp0iVAd2ti2rRpBAcH4+HhQYkSJZg6dSpTpkzJNIXDiRMnDJrCIS4uDldXV2JjYzP1aqWkpHD58uVM8zsJIV6O/Lt6ccnqZIZtH8aO6zuwUlkxvtF42gW0M3VYQphMVu23KeWpMVmHDh3KNAYoYyxV9+7dWbhwIZ999hmJiYn06dOHmJgYGjVqxIYNG+SXtxAiX4lLi2PAlgEcjTqKnaUd3zX9jibFm5g6LCHEY/JUT1ZukJ4sIXKP/Lsy3J2kO4RsDuHC/Qs42zgzo/kMqnsZdkteiPxIerKEEEK8sGtx1+izqQ/XE65T2L4ws1vMppxHOVOHJYTIgiRZQgiRB5yPPs9Hmz7iXso9ijsVZ+4rc/F1zt50M0II05Aky0Byd1WInCP/nrLnyO0jDNgygPj0eMq5l2N2y9kUti9s6rCEEM+Rb6ZwMLaMR96TkpJMHIkQ+UfGvydjLPuTX+y4voM+m/oQnx5PDa8azG89XxIsIfII6cnKJktLS9zc3PTr2Tk4OMhcNEK8IEVRSEpKIioqCjc3tyeW4RE6q8NWM3r3aDSKhqDiQXwT9I3BS2oJIUxHkiwDZMwcn52Fg4UQz+fm5vbMFRkKsqVnlzLlwBQA2ge0Z1zDcVhbSI+fEHmJJFkGUKlU+Pj44OXl9dQFc4UQ2WdtbS09WE+hKAozjs1gzok5ALxf4X0+rf0pFioZ3SFEXiNJ1guwtLSUxkEIkeM0Wg2T9k/ijwu6tToHVh9I7yq9ZWiCEHmUJFlCCGEG0jXpjNg1go1XNqJCxah6o3i73NumDksI8RIkyRJCCBNLSk9iSOgQ9tzcg5WFFZMbT6a1X2tThyWEeEmSZAkhhAnFpMTQf0t/Ttw9gb2VPd8Hf0+Dog1MHZYQIgdIkiWEECZyK/EWH236iPDYcFxtXZnZfCaBnoGmDksIkUMkyRJCCBO4EnuFPpv6EJkYiZeDF3NbzqWUWylThyWEyEGSZAkhRC47c+8MfTf3JTolGj8XP+a0nENRp6KmDksIkcMkyRJCiFx08NZBBm4dSGJ6IhU8KjC75Ww87DxMHZYQwghkdjshhMglWyK2ELIphMT0RGp712Z+q/mSYAmRj0mSJYQQuWDlxZV8EvoJado0mvk2Y1aLWTjZOJk6LCGEEcntQiGEMLIFpxYw7fA0AF4v/Tpj6o/BykJ+/QqR38m/ciGEMBJFUfjfkf+x4NQCAHpW7smQGkNkmRwhCghJsoQQwgjUWjXj941nxcUVAHxS8xN6Vu5p4qiEELlJkiwhhMhhqZpUPt/xOVsitmChsmBs/bG8XuZ1U4clhMhlkmQJIUQOSkhLYNC2QRy4dQAbCxu+Dvqa5iWamzosIYQJSJIlhBA5JDolmr6b+3Lm3hkcrR2ZHjydOj51TB2WEMJEJMkSQogcEJkQSZ9NfbgSdwV3W3dmtZxFpUKVTB2WEMKEJMkSQoiXFBYTRp9NfYhKisLH0Yc5Lefg7+pv6rCEECYmSZYQQryEE3dO0G9LP2JTYwlwDWBOyzl4O3qbOiwhhBmQGd+FEOIF7bm5hw//+5DY1FgCCweyqPUiSbCEEHqSZAkhxAvYeGUj/bf0J1mdTH2f+vz8ys+42bmZOiwhhBmRJEsIIQz0x/k/+HT7p6i1alr5teKn5j/hYO1g6rCEEGZGxmQJIUQ2KYrCzyd/5sejPwLwdtm3GVl3JJYWliaOTAhhjiTJEkKIbNAqWr45+A2/nv0VgD6BfRhQbYCsQyiEyJLBtwtTUlKy3BYZGflSwQghhDlK16YzatcofYL1We3PGFh9oCRYQohnMjjJqlGjBseOHXui/O+//yYwMDAnYhJCCLORok5hyLYhrA5fjaXKkkmNJtG1YldThyWEyAMMTrKaNm1KvXr1mDp1KgCJiYn06NGDrl27MnLkyBwPUAghTCUuLY6PNn3E9uvbsbW05YfgH2hfqr2pwxJC5BEGj8maOXMmbdu25cMPP2TNmjVERkbi5OTEgQMHqFy5sjFiFEKIXHc3+S4hm0I4f/88ztbO/Nj8R2oWqWnqsIQQecgLDXxv06YNnTp1YtasWVhZWbF69WpJsIQQ+ca1+Gt8tOkjrsVfo5BdIea0nEM5j3KmDksIkccYfLswLCyM+vXrs2bNGjZu3Mhnn33Ga6+9xmeffUZ6eroxYhRCiFxzPvo83dZ341r8NYo5FWNJmyWSYAkhXojBSVa1atXw9/fn+PHjtGzZkgkTJrBt2zZWrFhBnTp1jBGjEELkiqNRR+m5sSd3k+9Sxr0MS9oswdfF19RhCSHyKIOTrJkzZ7Js2TLc3Nz0ZQ0aNODo0aPUqFEjJ2MTQohcs+P6Dvr814f4tHiqe1VnQasFeDp4mjosIUQeplIURXmRA9PS0rh8+TKlSpXCyir/zGkaFxeHq6srsbGxuLi4mDocIUQuWBu+llG7RqFW1DQq1ohpTadhb2Vv6rCEEAYwx/bb4J6s5ORkevXqhYODA5UqVSIiIgKAgQMH6qd1EEKIvGLp2aUM3zkctaKmbUBbpjebLgmWECJHGJxkDR8+nOPHjxMaGoqdnZ2+vEWLFixbtixHgxNCCGNRFIUZx2Yw5cAUAN4t/y6TGk3C2sLaxJEJIfILg+/zrVq1iuXLl1OvXr1MS0pUqlSJsLCwHA1OCCGMQatombR/EsvPLwegf7X+fBT4kSyTI4TIUQYnWXfu3MHLy+uJ8sTERPkFJYQwe+madL7Y9QXrr6xHhYov6n5B5/KdTR2WECIfMvh2Ya1atVi7dq3+dUZiNW/ePOrXr59zkQkhRA5LSk9i4NaBrL+yHisLK75u8rUkWEIIozG4J2vSpEm0adOGM2fOoFar+eGHHzhz5gx79uxh+/btxohRCCFeWmxqLP229OPEnRPYW9nzv6b/o2GxhqYOSwiRjxnck9WoUSOOHTuGWq2mSpUq/Pfff3h5ebF3715q1pR1vYQQ5ud24m16bOjBiTsncLFx4edXfpYESwhhdC88T1Z+ZY7zbAghXtzVuKv0+a8PNxNv4mXvxZyWcyjtXtrUYQkhcpg5tt8vNIuoRqNh5cqVnD17FoCKFSvSoUOHfDUpqRAi7zt77ywhm0OITommhHMJ5r4yl2JOxUwdlhCigDA4Kzp9+jSvvfYat27dolw53aKpU6dOxdPTk9WrV1O5cuUcD1IIIQx18NZBPt76MQnpCVTwqMDMFjMpbF/Y1GEJIQoQg8dkffjhh1SqVInr169z5MgRjhw5wrVr1wgMDKRPnz7GiDHbxo4di0qlyvRTvnx5k8YkhMh92yK2EbIphIT0BGoVqcUvrX6RBEsIkesM7sk6duwYhw4dwt3dXV/m7u7OxIkTqV27do4G9yIqVarE5s2b9a/lFqYQBcuqS6sYu2csGkVDsG8w3wR9g62lranDEkIUQAZnIGXLluX27dtUqlQpU3lUVBSlS5t+MKmVlRXe3t6mDkMIYQKLTi/i20PfAtChVAfGNhiLlYX8R0sIYRoG3y6cPHkyH3/8MX/99RfXr1/n+vXr/PXXXwwePJipU6cSFxen/zGFixcvUrRoUQICAnjvvff0C1hnJTU1NVPMpopbCPHiFEXh+8Pf6xOsHpV6ML7heEmwhBAmZfAUDhYWD/OyjNneM07x6GuVSoVGo8mpOLNl/fr1JCQkUK5cOSIjIxk3bhw3btzg1KlTODs7P/WYsWPHMm7cuCfKzekRUCFE1jRaDeP3jefvi38DMLjGYHpV6WXiqIQQuc0cp3AwOMkyZFb3oKAggwPKSTExMZQsWZJp06bRq9fTf+mmpqaSmpqqfx0XF4evr69ZVZIQ4unSNGl8vuNzNkdsxkJlweh6o3mz7JumDksIYQLmmGQZ3Jdu6sTJEG5ubpQtW5ZLly5luY+trS22tjIoVoi8JjE9kUHbBrE/cj/WFtZMbTKVliVbmjosIYTQe+EBC0lJSURERJCWlpapPDAw8KWDyikJCQmEhYXRtWtXU4cihMhB91Pu03dzX07fO42DlQPTm02nrk9dU4clhBCZGJxk3blzh549e7J+/fqnbs/tcViPGjZsGO3bt6dkyZLcvHmTL7/8EktLS7p06WKymIQQOSsyIZI+m/pwJe4K7rbuzGoxi0qFKz3/QCGEyGUGP104ePBgYmJi2L9/P/b29mzYsIFFixZRpkwZ/v33X2PEmG3Xr1+nS5culCtXjrfffptChQqxb98+PD09TRqXECJnhMeE03V9V67EXcHb0ZuFbRZKgiWEMFsG92Rt3bqVf/75h1q1amFhYUHJkiVp2bIlLi4uTJ48mbZt2xojzmxZtmyZya4thDCuU3dP0XdzX2JSY/B39Wduy7l4O8qceEII82VwT1ZiYiJeXl6Abqb3O3fuAFClShWOHDmSs9EJIQSw9+ZePtj4ATGpMVQuVJlFrRdJgiWEMHsGJ1nlypXj/PnzAFStWpU5c+Zw48YNZs+ejY+PT44HKIQo2P678h/9t/QnWZ1MXZ+6zGs1D3c79+cfKIQQJmbw7cJBgwYRGRkJwJdffknr1q1ZunQpNjY2LFy4MKfjE0IUYH9e+JPxe8ejoNCyZEumNJ6CjaWNqcMSQohsMXgy0sclJSVx7tw5SpQoQeHCeX+Ve3OczEyIgkZRFH459Qs/HPkBgDfLvsmouqOwtLA0cWRCCHNlju23QT1ZcXFxODk5ZVpax8HBgWrVqpGQkJDjwQkhCh6touW7Q9+x+MxiAHpX6c3A6gP1y3YJIUReke0xWStXrqRWrVqkpKQ8sS05OZnatWuzevXqHA1OCFGwqLVqRu8erU+whtUaxsc1PpYESwiRJ2U7yZo1axafffYZDg4OT2xzdHTk888/56effsrR4IQQBUeKOoUhoUP4N+xfLFWWTGw0ke6Vups6LCGEeGHZTrJOnTpF06ZNs9zepEkTTp48mRMxCSEKmPi0eEI2hxB6LRRbS1u+D/6e10q9ZuqwhBDipWR7TNb9+/dRq9VZbk9PT+f+/fs5EpQQouC4m3yXvpv7ci76HE7WTvzY7EdqedcydVhCCPHSst2T5efnx6FDh7LcfujQIUqWLJkjQQkhCobr8dfpvr4756LP4WHnwYLWCyTBEkLkG9lOsjp16sQXX3zB7du3n9h269YtRo0axRtvvJGjwQkh8q+L9y/SbX03IuIjKOZUjMVtFlPeo7ypwxJCiByT7Xmy4uPjqV+/PhEREbz//vuUK1cOgHPnzrF06VJ8fX3Zt28fzs7ORg3Y2Mxxng0h8ptjUcfot6Uf8WnxlHYrzZyWc/By8DJ1WEKIPMwc2+9sj8lydnZm9+7djBgxguXLl+vHX7m5ufH+++8zceLEPJ9gCSGMb9eNXXwS+gnJ6mSqelZlRvMZuNq6mjosIYTIcS8047uiKNy9exdFUfD09MxXc9iYYyYsRH6xLnwdX+z6ArWipmGxhkwLmoaD9ZPTwgghhKHMsf02eO1CAJVKhaenZ07HIoTIx34/9zuT909GQaGNfxsmNpyItaW1qcMSQgijeaEkSwghsktRFGYfn83M4zMB6FK+C8PrDMdCle3nboQQIk+SJEsIYTRaRcuUA1P4/dzvAPSr2o+QqiH5aoiBEEJkRZIsIYRRpGvS+WL3F6y/vB6AEXVG8G6Fd00clRBC5B5JsoQQOS4pPYlPtn/C7hu7sVJZMaHRBNoGtDV1WEIIkateKMnasmULW7ZsISoqCq1Wm2nb/PnzcyQwIUTeFJsaS/8t/Tl+5zh2lnZMazqNxsUbmzosIYTIdQYnWePGjeOrr76iVq1a+Pj4yNgKIYReVFIUH236iEsxl3C2cWZm85lU86pm6rCEEMIkDE6yZs+ezcKFC+natasx4hFC5FERcRH02dSHGwk38LT3ZHbL2ZR1L2vqsIQQwmQMTrLS0tJo0KCBMWIRQuRR56LPEbIphHsp9/B19mVuy7kUdy5u6rCEEMKkDJ6o5sMPP+S3334zRixCiDzo0K1D9NzQk3sp9yjnXo7FbRZLgiWEELxAT1ZKSgpz585l8+bNBAYGYm2decbmadOm5VhwQgjzFnotlGHbh5GqSaVmkZr82OxHnG1kDVMhhIAXSLJOnDhBtWrVADh16lSmbTIIXoiC49+wfxmzewwaRUPT4k35Jugb7KzsTB2WEEKYDYOTrG3bthkjDiFEHrL49GK+OfQNAK+Veo2xDcZibSHrEAohxKNkMlIhRLYpisKPR3/k55M/A9C1YleG1Rom6xAKIcRTZCvJ6tSpEwsXLsTFxYVOnTo9c98VK1bkSGBCCPOi0WqYsH8Cf134C4BBNQbRq3IvGSYghBBZyFaS5erqqv9F6urqatSAhBDmJ02TxvCdw9l0dRMqVIyuP5q3yr5l6rCEEMKsqRRFUUwdhDmJi4vD1dWV2NhYXFxcTB2OECaXlJ7EoG2D2Be5D2sLa6Y0nsIrfq+YOiwhhMjEHNtvGZMlhMjS/ZT79N/Sn5N3T2JvZc8PwT9Qv2h9U4clhBB5giRZQoinupV4iz6b+nA59jJutm7MbD6TKp5VTB2WEELkGZJkCSGeEB4bzkebPuJW4i2KOBRhbsu5BLgFmDosIYTIUyTJEkJkcvruafpu7sv91Pv4ufgxt+VcfJx8TB2WEELkOS81uU1KSkpOxSGEMAP7I/fzwcYPuJ96n4qFKrKozSJJsIQQ4gUZnGRptVrGjx9PsWLFcHJyIjw8HIDRo0fzyy+/5HiAQojcsfnqZvpu7kuSOom63nWZ32o+HnYepg5LCCHyLIOTrAkTJrBw4UK+/vprbGxs9OWVK1dm3rx5ORqcECJ3/H3hb4ZuH0q6Np0WJVowo8UMHK0dTR2WEELkaQYnWYsXL2bu3Lm89957WFpa6surVq3KuXPncjQ4IYTxzT81n7F7x6JVtLxR5g2+DfoWW0tbU4clhBB5nsED32/cuEHp0qWfKNdqtaSnp+dIUEII41MUhWmHp7Hw9EIAelXuxaAag2SZHCGEyCEG92RVrFiRnTt3PlH+119/Ub169RwJSghhXGqtmjF7xugTrGG1hjG45mBJsIQQIgcZ3JM1ZswYunfvzo0bN9BqtaxYsYLz58+zePFi1qxZY4wYhRA5KFWTyqfbP2XbtW1YqCwYW38sr5d53dRhCSFEvmNwT1aHDh1YvXo1mzdvxtHRkTFjxnD27FlWr15Ny5YtjRGjECKHxKfFE7IphG3XtmFjYcO0ptMkwRJCCCORBaIfY44LTAqRE+4l36Pv5r6cjT6Lo7UjPzb7kdretU0dlhBC5AhzbL9lxnchCoAbCTf4aNNHXI27ioedB7NazKJioYqmDksIIfI1g5Msd3f3pw6OValU2NnZUbp0aXr06EHPnj1zJEAhxMu5dP8SH236iKjkKIo6FmVOyzn4ufqZOiwhhMj3Xmjg+8SJE2nTpg116tQB4MCBA2zYsIH+/ftz+fJl+vbti1qtpnfv3jkesBAi+47fOU6/zf2IS4ujlGsp5rScQxHHIqYOSwghCgSDk6xdu3YxYcIEQkJCMpXPmTOH//77j7///pvAwECmT58uSZYQJrT7xm6GhA4hWZ1MoGcgM5vPxNXW1dRhCSFEgWHw04UbN26kRYsWT5Q3b96cjRs3AvDqq6/q1zQUQuS+DZc3MGDrAJLVyTQs2pCfW/4sCZYQQuQyg5MsDw8PVq9e/UT56tWr8fDQLSabmJiIs7Pzy0cnhDDY8nPL+WzHZ6i1alr7tebHZj/iYO1g6rCEEKLAMfh24ejRo+nbty/btm3Tj8k6ePAg69atY/bs2QBs2rSJoKCgnI1UCPGQooBWDZp0sLACKxsURWHOiTnMODYDgM7lOjOizggsLSyfczIhhBDG8ELzZO3evZuffvqJ8+fPA1CuXDkGDhxIgwYNcjzAFzFjxgy++eYbbt26RdWqVfnxxx/1CeHzmOM8G+IlabW6hESbrktKMpITfdmj2zSP/D1jW1bHqh/Z7/FjH9mmVT92jcePVWex34NzPm0/rfrh+7OwRlu1C197uLA0/F8AQqqG0K9qP1kmRwhRYJhj+53vJiNdvnw53bp1Y/bs2dStW5fvv/+eP//8k/Pnz+Pl5fXc482xknLVo426QcnB44mF5rEEJItjn5vYPO/62dhP0Zr6UzWqdGC0ZyHWOjkCMDywP+9VD3n2QUIIkc+YY/v9QkmWVqvl0qVLREVFodVmbsCaNGmSY8G9iLp161K7dm1++uknQBerr68vAwcOZPjw4c893liVtGzzHDzsVXg6WOkSAEXzILlQZ/5TUYPmwZ9ata4XRnmQ7GTa9ujxTzuf5pFy9WP7ah+e7/EYyFc5d9ZUFqCyAksrUFmChaXutpuF1YO/Wz4ot3pk24MySyvdsRnlKkuwtHzkfFZgYZH5fKqnnN/iade2yHwey8eO1V9fd5xiYcm8ozPYGX0KK0Vh/J17tEtVoG4faDgYHDxM/UkLIUSuMMcky+AxWfv27ePdd9/l6tWrPJ6fqVQqNBpNjgVnqLS0NA4fPsyIESP0ZRYWFrRo0YK9e/c+9ZjU1FRSU1P1r+Pi4nI8rpR0Dd9c+5E0i1y8dWPBMx5rUAHWD37EkzQPfp6x2czYWdrxXfkeNDm6Am4cgt0/wMH5UL8f1O8PdvJkoRBC5DaDk6yQkBBq1arF2rVr8fHxMasxH3fv3kWj0VCkSObJFosUKcK5c+eeeszkyZMZN26cUeOKS07HR6MiXa2gAAoqLFQqLC1VWKgsQP8ZqnT5D6oHf3+0/Cl/Vz3YLzt/z3TeF/m7MFeutq4MqzWM6l7VoWY/uPgfbB0Pt07C9qmwfw40HAR1PwIbR1OHK4QQBYbBtwsdHR05fvw4pUuXNlZML+zmzZsUK1aMPXv2UL9+fX35Z599xvbt29m/f/8TxzytJ8vX19co3Y0Xbscze3sY/xy7iUar+9irFHOlb9NStKrkjWVu9nSJ/E2rhbP/wrZJcFf3gAqOntDoE6j1AVjbmTY+IYTIYeZ4u9DgebLq1q3LpUuXjBHLSytcuDCWlpbcvn07U/nt27fx9vZ+6jG2tra4uLhk+jGWskWcmfZ2NbZ/2pQeDfyws7bg5I1Y+i09Qotp21l2IIJUtRneixJ5j4UFVOoI/fbC63PB3Q8S78DGETC9OhyaD+o0U0cphBD5msE9WStXrmTUqFF8+umnVKlSBWvrzON6AgMDczRAQ9WtW5c6derw448/ArqB7yVKlGDAgAEmHfj+NNGJaSzcc4VFe64Qm5wOgJezLR829qdLnRI428mYKZFDNOlwbCls/xribujK3EpC0xEQ+LZu8L0QQuRh5tiTZXCSZWHxZOeXSqVCURSTD3wH3RQO3bt3Z86cOdSpU4fvv/+eP/74g3Pnzj0xVutpTFFJialqfj8Qwbydl7kVlwKAi50V3er70aOhH4WdbHMlDlEApKfAkUWw41tIjNKVFS6rS7YqdtT1gAkhRB6UL5Ksq1evPnN7yZIlXyqgnPDTTz/pJyOtVq0a06dPp27dutk61pSVlKbWsurYDWZvDyP8TiIAtlYWdK7tS+/GAfh6yNIoIoekJcKBn2H395B8X1dWpAo0+wLKtn7kQQshhMgb8kWSld+ZQyVptQr/nbnNrNBLHL8eC4ClhYr2gT6ENC1FeW/z+PKIfCAlDvbNgr0/QeqD6UuK1YRmoyAgWJItIUSeYQ7t9+NeOMk6c+YMERERpKVlHjz72muv5UhgpmJOlaQoCnvD7zErNIydF+/qy5uV96Jv01LU9pOJJkUOSYqGPdN10z2kJ+nKSjbUJVslzWO5LCGEeBZzar8zGJxkhYeH8/rrr3Py5En9WCxAP1+WqcdkvSxzrCSAUzdimbU9jPUnI3kw+wO1SrrTt2kpgst5YSHTP4ickBAFu/4HB38BzYOpTUo1191GLFbTtLEJIcQzmGP7bXCS1b59eywtLZk3bx7+/v4cOHCAe/fuMXToUL799lsaN25srFhzhTlW0qMu301k7o5w/j58nTSNbkmjckWcCWkaQLvAolhbysBlkQNir+sGxx9d8nAx6nJtIXgkeFc2bWxCCPEU5th+G5xkFS5cmK1btxIYGIirqysHDhygXLlybN26laFDh3L06FFjxZorzLGSniYqLoVfdl9m6b4IElJ1jWAxN3v6NAng7Vq+2NvII/kiB0Rf1k37cGLZg4W2VVC5k+5pxMJlTB2dEELomWP7bXC3h0ajwdnZGdAlXDdv3gR0TxWeP38+Z6MTWfJysWNEmwrsHt6MT1uVo7CTDTdikvny39M0nLqV6VsuEpMkk02Kl+ThD6/Pgn77odLrgAKn/oYZdWBVP7h/xdQRCiGE2TK4J6tx48YMHTqUjh078u6773L//n1GjRrF3LlzOXz4MKdOnTJWrLnCHDPh7EhJ1/Dn4evM3RHGtehkABxsLHm3Tgl6NfbHx9XexBGKfOHWSd1SPefX6V5bWEONbtBkGLgUNW1sQogCzRzbb4OTrI0bN5KYmEinTp24dOkS7dq148KFCxQqVIjly5fTrFkzY8WaK8yxkgyh1mhZezKSWaFhnLsVD4C1pYrXqxfjo6BSlPJ0MnGEIl+4fli3CHX4Nt1rS1uo/SE0GgJOnqaNTQhRIJlj+50j82RFR0fj7u6uf8IwLzPHSnoRiqIQeuEOs0LDOHA5GtBNedSqojd9m5aiqq+baQMU+cOVXbB1AkTs1b22doR6IdBgINi7mzY2IUSBYo7tt0xG+hhzrKSXdfhqNLNCw9l89uHC2Q1KFaJv01I0Kl04XyTHwoQUBcK26JKtmw8efLF1hQYDoF5fsHU2bXxCiALBHNtvg5OsxMREpkyZwpYtW4iKikKr1WbaHh4enqMB5jZzrKSccvF2PLO3h/PPsRuoH0y2VbmYC32DStO6sjeWMteWeBmKohurtXUiRJ3Wldl76G4h1v4QbGRZKCGE8Zhj+21wktWlSxe2b99O165d8fHxeaIXZNCgQTkaYG4zx0rKaTdikpm3M5xlB66RnK6bPNavkAMfBZWiU41i2FrJ9A/iJWi1cHoFhE6Ge5d0ZU5FoPEwqNkdrGTBcyFEzjPH9tvgJMvNzY21a9fSsGFDY8VkUuZYScYSnZjGoj1XWLjnCrHJ6QB4OdvSq5E/79YtgbOdtYkjFHmaRg0nlsP2KRAToStz9YWgz6BqF7CU75cQIueYY/ttcJLl7+/PunXrqFChgrFiMilzrCRjS0xVs+zgNebtDCcyNgUAZzsrutUvSY8G/ng6S8+DeAnqNN3M8Tu+gfhIXZlHgG5C08pvgIX0nAohXp45tt8GJ1m//vor//zzD4sWLcLBIf+NsTDHSsotaWot/xy7weztYYTdSQTA1sqCt2v50qdJAL4e+a++RS5KT4ZD82HnNEh6sOC5ZwXdUj0V2usefxVCiBdkju13tpKs6tWrZxp7denSJRRFwc/PD2vrzF3+R44cyfkoc5E5VlJu02oVNp29zczQMI5fiwHA0kJFu0AfQoJKUcGnYH4uIoekJsCBObD7B0iJ1ZX5VIXgUVCmpSRbQogXYo7td7aSrHHjxmX7hF9++eVLBWRq5lhJpqIoCvvCo5m1PYwdF+7oy4PLedK3aWlq++WPudGEiSTHwN4ZsG8mpCXoynzrQrNR4N/EpKEJIfIec2y/ZZ6sx5hjJZmDUzdimb09jHUnI3kw+wM1S7rTN6gUzcp7YSHTP4gXlXgPdn8PB34GtW5JKPybQLPR4FvHpKEJIfIOc2y/DU6yDh48iFarpW7dupnK9+/fj6WlJbVq1crRAHObOVaSOblyN5G5O8P569B10jS6OdLKFnEiJKgU7asWxdrS4DXHhdCJvwU7v4NDC0Cre9qVMq2g2Re624lCCPEM5th+G9wi9u/fn2vXrj1RfuPGDfr3758jQQnz5VfYkUmvV2HX58GEBJXCydaKC7cT+OSP4zT9JpQFuy+TlKY2dZgiL3L2hle/gY+P6BadVlnCxY0wpwks7wpRZ00doRBCGMTgniwnJydOnDhBQEBApvLLly8TGBhIfHx8jgaY28wxEzZnscnpLN1/lfm7LnM3IQ0AdwdrejTwp3uDkrg52Jg4QpFn3QuD0Clw8k9AAVRQ5S1oOhwKlTJ1dEIIM2OO7bfBPVm2trbcvn37ifLIyEisrKxyJCiRd7jaW9OvaWl2fd6MCR0rU8LDgftJ6fxv8wUaTNnK+DVniIxNNnWYIi8qVAre+Bn67YUKrwEKnPwDfqoN/w6EmCd71IUQwpy80LI6kZGR/PPPP7i6ugIQExNDx44d8fLy4o8//jBKoLnFHDPhvESt0bLu1C1mhYZxNjIOAGtLFR2rFeOjoFKU9nIycYQiz7p5FLZNgov/6V5b2kDNHtB4qO5WoxCiQDPH9tvgJOvGjRs0adKEe/fuUb16dQCOHTtGkSJF2LRpE76+vkYJNLeYYyXlRYqisP3CHWaFhrH/cjSgm/7olYpF6Nu0NNV83UwboMi7IvbD1vFwZafutZU91OkNDQeDYyGThiaEMB1zbL9faAqHxMREli5dyvHjx7G3tycwMJAuXbo8MTFpXmSOlZTXHb56n9nbw9h05uFt5voBhejbtBSNyxSWubbEiwnfDlsnwPUDutc2zlC/H9TvD3aupo1NCJHrzLH9lnmyHmOOlZRfXLwdz+zt4fxz7AbqB5NtVSrqQt+mpWhT2QdLmWtLGEpR4OImXc/WrRO6Mjs3aPgx1PkIbOX2tBAFhTm235JkPcYcKym/uRGTzLyd4Sw7cI3kdA0AfoUc6NOkFJ1qFMPOWhYMFgbSauHcat2YrTvndGWOntDoE6j1AVjbmTY+IYTRmWP7LUnWY8yxkvKr+4lpLNxzhUV7rxCTpJt80tPZll6N/Hmvbgmc7fL+7WeRy7QaOPW3Ltm6f1lX5lwUmgyD6l3BSqYUESK/Msf2W5Ksx5hjJeV3ialqlh28xryd4UTGpgDgbGdF13ol6dnQH09nWxNHKPIcTToc+w22fw1x13VlbiV1c2xVeRssZboZIfIbc2y/Jcl6jDlWUkGRptbyz7EbzN4eRtidRABsrCx4u1Zx+jQuRYlCDiaOUOQ56lQ4vAh2fgsJDx68KFQGgkdAxdfBQpaBEiK/MMf22+AkKyAggIMHD1KoUOZHpWNiYqhRowbh4eE5GmBuM8dKKmi0WoVNZ28zKzSMY9diALBQQbvAooQElaJiUakXYaC0JDj4M+z6HpJ1U4pQpDIEfwHl2ujmFxFC5Gnm2H4bnGRZWFhw69YtvLy8MpXfvn2bEiVKkJqamqMB5jZzrKSCSlEU9l+OZlZoGNsv3NGXNy3nSd+gUtTx95DpH4RhUuJg/2zY8yOk6ibLpWgNaDYKSjWTZEuIPMwc2+9sJ1n//vsvAB07dmTRokX62d4BNBoNW7ZsYdOmTZw/f944keYSc6wkAaduxDJnRzhrT9zkwewP1CjhRt+mpWle3gsLmf5BGCIpWpdo7Z8N6Um6shINoPloKNnAtLEJIV6IObbf2U6yLB6MXVCpVDx+iLW1NX5+fnz33Xe0a9cu56PMReZYSeKhq/cSmbsjnD8PXydNrQWgjJcTIUGleK1aUawtZYyNMEDCHdj1Pzg4DzQPeuFLNYPgUVC8pmljE0IYxBzbb4NvF/r7+3Pw4EEKFy5srJhMyhwrSTwpKj6FBbuv8Oveq8SnqgEo6mrHh40DeKeOLw428vSYMEDcTdjxDRxZDFrd94lyr+rGbHlXNm1sQohsMcf2W54ufIw5VpLIWlxKOkv3RfDLrsvcTdD1RLg7WNO9gR/d6/vh7ijzIgkD3L+im/bh+O+g6HpKqdQJmo4Az7ImDU0I8Wzm2H6/UJK1ZcsWtmzZQlRUFFqtNtO2+fPn51hwpmCOlSSeLyVdw99HrjNnezgR0boxNvbWlnSpU4IPG/tT1M3exBGKPOXuRQidrJvYFEBlAYHvQNPPwd3PpKEJIZ7OHNtvg5OscePG8dVXX1GrVi18fHyeeLpr5cqVORpgbjPHShLZp9ZoWX/qFrNCwzgTqXt6zMpCRcfqxQgJCqC0l7OJIxR5yq1Tutnjz6/VvbawghrdoPEwcC1m2tiEEJmYY/ttcJLl4+PD119/TdeuXY0Vk0mZYyUJwymKwo6Ld5kVeol94dH68lcqFqFv01JUL+FuwuhEnnP9MGybCGFbdK8tbaH2h9BoCDh5mjY2IQRgnu23wUlWoUKFOHDgAKVKlTJWTCZljpUkXs6RiPvMDg3jvzO39WX1Ajzo27Q0TcoUlrm2RPZd2Q1bJ0DEHt1raweoGwINBoKDh2ljE6KAM8f22+Ak6/PPP8fJyYnRo0cbKyaTMsdKEjnjUlQ8s7eHs+roDdQPJtuq6ONC36aleLWKD5Yy15bIDkWB8G26ZOvGYV2ZrYsu0aobAnbye0MIUzDH9tvgJGvQoEEsXryYwMBAAgMDsba2zrR92rRpORpgbjPHShI562ZMMvN2Xub3AxEkp2sAKFnIgT5NAnijRnHsrC1NHKHIExQFzq/X3Ua8fUpXZu8BjQZD7d5gI2ttCpGbzLH9NjjJCg4OzvpkKhVbt2596aBMyRwrSRjH/cQ0Fu29wsI9V4hJSgegsJMtvRr58169ErjYWT/nDEIAWi2cWaUbIH/voq7MqYhucHzN7mBla9LwhCgozLH9lnmyHmOOlSSMKylNzbID15i3M5ybsSkAONta8X79kvRs6IeXs52JIxR5gkYNJ/+A0CkQc1VX5lIcgj6Dau+CpSTtQhiTObbfL5xkXbp0ibCwMJo0aYK9vT2KouSLAcTmWEkid6Sptfx7/Cazt4dxKSoBABsrC96qWZw+TQIoWcjRxBGKPEGdBsd+he3fQPxNXZlHgG5C08pvgIXcjhbCGMyx/TY4ybp37x5vv/0227ZtQ6VScfHiRQICAvjggw9wd3fnu+++M1asucIcK0nkLq1WYfPZ28wMDePYtRgALFTQNrAoIUEBVCrq+uwTCAGQngKH5sOuaZB4R1fmWR6CR0L59mAh62wKkZPMsf02+F/5kCFDsLa2JiIiAgeHhwM7O3fuzIYNG3I0OCFMwcJCxSuVvFnZrwHL+tQjqKwnWgVWH79J2+m76D7/APvC7z2xULoQmVjbQf1+8PExaP4l2LnBnXPwRzeYGwQX/tMNnhdC5FsG92R5e3uzceNGqlatirOzM8ePHycgIIDw8HACAwNJSEgwVqy5whwzYWF6p2/GMnt7OGtP3OTB7A9UL+FG36BStKhQBAuZ/kE8T0os7J0Be2dCWryurHgdaDYKAoJMG5sQ+YA5tt8G92QlJiZm6sHKEB0dja2tPEUj8qdKRV35sUt1tg1ryvv1SmBjZcHRiBj6LDnMK9/v4K/D10lTa59/IlFw2bnqbhUOOg4NB4GVPVw/AItfg0XtIWK/qSMUQuQwg3uyXn31VWrWrMn48eNxdnbmxIkTlCxZknfeeQetVstff/1lrFhzhTlmwsL8RMWnsGD3FX7de5X4VDUARV3t6NU4gHdq++Joa2XiCIXZi78FO6fB4QWgSdOVlXkFgr+AotVMGpoQeZE5tt8GJ1mnTp2iefPm1KhRg61bt/Laa69x+vRpoqOj2b17d55fbsccK0mYr7iUdJbui+CXXZe5m5AKgJuDNd3r+9GjgR/ujjYmjlCYvZhrsOMbOPorKLrJcanQXpdseVUwbWxC5CHm2H6/0BQOsbGx/PTTTxw/fpyEhARq1KhB//798fHxMUaM2ebn58fVq1czlU2ePJnhw4dn+xzmWEnC/KWka/j7yHXm7gjn6r0kAOytLXmnji+9GwdQ1M3exBEKs3cvDLZPhRN/AAqggipvQdPhUChv/+dViNxgju13vpqM1M/Pj169etG7d299mbOzM46O2Z/fyBwrSeQdGq3C+lORzAoN4/TNOACsLFR0rF6MkKAASns5mzhCYfaizkHoJDjzj+61ylI3mWnQ5+Dma9rYhDBj5th+G5xkLViwACcnJ956661M5X/++SdJSUl07949RwM0hJ+fH4MHD2bw4MEvfA5zrCSR9yiKws6Ld5kVGsbe8Hv68pYVi9C3aSlqlHA3YXQiT4g8DlsnwsWNuteWNlCzBzQeCs7eJg1NCHNkju23wUlW2bJlmTNnzhNrGG7fvp0+ffpw/vz5HA3QEH5+fqSkpJCenk6JEiV49913GTJkCFZWWQ9CTk1NJTU1Vf86Li4OX19fs6okkbcdjbjP7O1hbDx9W19W19+Dvk1LEVTWM1+slCCM6NoB2DoBLm/Xvbaygzq9oeEQcCxk2tiEMCP5Ismys7Pj3Llz+Pn5ZSq/cuUKFSpUIDk5OSfjM8i0adOoUaMGHh4e7NmzhxEjRtCzZ0+mTZuW5TFjx45l3LhxT5SbUyWJ/OFSVDxztoez8ugN1A8m26rg40LfpqV4tbI3VpYyA7h4hss7dMnWtQdTPdg4Qb1+UL8/2LuZNDQhzEG+SLJKlCjBTz/9xGuvvZap/J9//qF///5cv349RwMcPnw4U6dOfeY+Z8+epXz58k+Uz58/n48++oiEhIQs5/CSniyR227GJPPLrsv8fiCCpDTd02QlPBzo0ySAN2sWx85a1rYTWVAUuLQZto7X3U4E3fxbDT6GuiFg62Ta+IQwoXyRZH3++ecsX76cBQsW0KRJE0B3q/CDDz7gzTff5Ntvv83RAO/cucO9e/eeuU9AQAA2Nk8+Kn/69GkqV67MuXPnKFeuXLauZ46VJPKn+4lpLN57lYV7LnM/KR2Awk62fNDIj/frlcTFztrEEQqzpShwbo1uzNads7oyh8LQ+BOo9QFYy9OsouAxx/bb4CQrLS2Nrl278ueff+rHOmm1Wrp168bs2bOfmuyYytKlS+nWrRt3797F3T17A43NsZJE/paUpmb5wWv8vCOcm7EpADjbWvFevZJ80MgPL2c7E0cozJZWA6dW6J5GjA7XlTn7QJNhUL0bWJnP72MhjM0c22+DkixFUbh27Rqenp5cv36dY8eOYW9vT5UqVShZsqQx43yuvXv3sn//foKDg3F2dmbv3r0MGTKENm3asGjRomyfxxwrSRQM6Rot/x67yeztYVyM0q0BamNlwZs1i9OncQB+hbM/FYkoYDRqOP67bp6t2Gu6MrcSEDQcAjuDpaxAIPI/c2y/DUqytFotdnZ2nD59mjJlyhgzLoMdOXKEfv36ce7cOVJTU/H396dr16588sknBq2paI6VJAoWrVZhy7koZoZe4mhEDAAWKni1ig8hQaWoXMzVtAEK86VOhSOLdTPIJzx4mrVQaWg6Aip1Agt5uELkX+bYfht8u7BSpUr88ssv1KtXz1gxmZQ5VpIomBRF4cDlaGZtDyP0/B19eZOynvQNKkW9AA+Z/kE8XVoSHPoFdv0Pkh6MafWqBM2+gHKvgnxvRD5kju23wUnW6tWr+frrr5k1axaVK1c2VlwmY46VJMSZm3HM3h7GmhM3eTD7A9V83ejbtBQtKxTBwkIaTfEUqfGwbzbs+RFSY3VlRatDs1FQqrkkWyJfMcf22+Aky93dnaSkJNRqNTY2NtjbZ36KJTo6OkcDzG3mWElCZIi4l8TcnWH8ceg6aWotAH6FHKhewp2Awo4EeDpRyssRv0KOMhWEeCj5Puz5CfbNgvREXVmJBrpky6+haWMTIoeYY/ttcJL1vEHkplxWJyeYYyUJ8bg78aks2H2ZJXuvEp+qfmK7SgXF3OwJ8HQioLAjpbycKPUgCSviYiu3GQuqxLu6W4gHfgbNg/kBA4J1yVbxWqaNTYiXZI7td75aIDonmGMlCZGV+JR0dl+6S9idRMLuJBD+4M/4lCcTrwyONpb4ezpSytOJgMJOBHg66n4KO2FvI71fBULcTdj5HRxeBFrdHG2UbaMbs+VdxbSxCfGCzLH9fqEkKywsjAULFhAWFsYPP/yAl5cX69evp0SJElSqVMkYceYac6wkIQyhKAp3E9IIv5NA+N1Ewu8kEHZH9+e1+8lotFn/k9f1fjnqbz0GPEjGvF3sZNxXfnT/Kmz/Go7/Boru9jOVXoemI8GzrGljE8JA5th+G5xkbd++nTZt2tCwYUN27NjB2bNnCQgIYMqUKRw6dIi//vrLWLHmCnOsJCFySppaS0R0Yqaer4xkLObBrPNPY29tiX/hBz1enk6UepB8+Rd2xNFW5mDK8+5egtDJcOpvQAGVhW5+rbofgU81GSAv8gRzbL8NTrLq16/PW2+9xSeffIKzszPHjx8nICCAAwcO0KlTpxxfuzC3mWMlCZEbohPTHiReGbcdEwm/m0DEvST9gtZP4+1ip+/xykjCAgo7UszNXnq/8prbp2HbJN2SPRlcikO5NlC+Lfg1AktZ7kmYJ3Nsvw1OspycnDh58iT+/v6ZkqwrV65Qvnx5UlJSjBVrrjDHShLClNI1WiKikx72ej1IvsLuJBKdmJblcbZWFvgXfjT5ctSPAXOWdRnN240jsPsHuLjp4dOIALauUPYV3VxbpVuAnfyOFObDHNtvg/v53dzciIyMxN/fP1P50aNHKVasWI4FJoQwD9aWFpTydKKUpxNQJNO2mKQ0/Xiv8LuJhEXp/rx6L5FUtZZzt+I5dyv+iXN6Odtm6vXSPf3oRDF3eyyl98v0itWAtxdBegpc3q7r2Tq/HhLvwMk/dT+WNuDfRNfDVe5VcPY2ddRCmB2De7KGDRvG/v37+fPPPylbtixHjhzh9u3bdOvWjW7duvHll18aK9ZcYY6ZsBB5jVqj5fr9ZF2PV9TDnq/wO4ncTUjN8jgbKwv8CjkQUFg339fDpx+dcLWX3i+T0mrg+iE4vxbOrYV7lzJvL1YLyr8K5dtB4bIyjkvkOnNsvw1OstLS0ujfvz8LFy5Eo9FgZWWFRqPh3XffZeHChVha5u1HwM2xkoTIT2KT07ms7/XKGHyfyOV7ifoJVp+msJPNU5MvX3d7rCxlTb5cd+fCgx6udXD9YOZtHqV0PVzl20Lx2mCRt9sFkTeYY/v9wvNkXbt2jZMnT5KQkED16tXNbsHoF2WOlSREQaDRKty4n0zY3YQnxn/djsu698vaUkXJQo9PO6FLxNwdbXLxHRRg8bd0txPPrdXdXtQ8MlbP0RPKttb1cAUEgbV91ucR4iWYY/ud7SRLq9XyzTff8O+//5KWlkbz5s358ssvn1hWJ68zx0oSoqCLT9H1fmUkX2EPesIu39WN/cqKh6PNg+Qr8/ivEh4OWEvvl3GkxsOlzXBuHVzY+HDNRABrByjdHMq1hbKtwMHDdHGKfMcc2+9sJ1njx49n7NixtGjRAnt7ezZu3EiXLl2YP3++sWPMVeZYSUKIp9NqFW7GJj9Mvh70fIXfSSQyNusnna0sVJTwcMg071dGEubhaCPLDuUUTTpc3a3r4Tq3DuIemeJHZQklGzwcOO9e0nRxinzBHNvvbCdZZcqUYdiwYXz00UcAbN68mbZt25KcnIyFRf75H6E5VpIQwnCJqWrd2C/9bceHtyCT0zVZHudqb5153q/CuiSsZCFHbKzyz++6XKcoEHlcN4br3Fq4fSrz9iJVHgycbwvegTJwXhjMHNvvbCdZtra2XLp0CV9fX32ZnZ0dly5donjx4kYLMLeZYyUJIXKOoijcikvRP/UY/sjs9zdikrM8zkLFg94vpyeWHSrsJL1fBrt/Rde7dX6drrdLeeS2r6uvrner/KtQsqFMgCqyxRzb72wnWZaWlty6dQtPT099mbOzMydOnHhizqy8zBwrSQiRO5LTNLqxX3czLzkUFpVAYlrWvV/Odla6244Pxn/pesGcKFnIATtrebLuuZKideO3zq2BsK2QnvRwm50rlGml6+Eq3RxsnU0XpzBr5th+ZzvJsrCwoE2bNtja2urLVq9eTbNmzXB0dNSXrVixIuejzEXmWElCCNNSFIWo+NRH1nt80Pt1N4Hr95PJ6reoSgXF3e0f3HJ8OPN9KU8nvJxtpffradKTITxUd0vx/HpIuvtwm6UNBDTV9XKVexWci2R1FlEAmWP7ne0kq2fPntk64YIFC14qIFMzx0oSQpivlHQNV+8lPRh4/+D244PxX/Ep6iyPc7K1ejDm6+Gtx4DCukW37W2k9wt4MAHqQV0P17m1EB3+yEYVFK/1YOB8W/Asa7IwhXkwx/b7hefJyq/MsZKEEHmPoijcTUh7+NTjg1uP4XcSiIhOIqs1t1UqKOpq/+Tgey9HvF3sCm7vl6LAnfMPZ5y/cTjz9kJlHs44X6wW5KMHskT2mGP7LUnWY8yxkoQQ+UuqWkPEvaRMU05kJGOxyelZHudgY4l/4cxzfmXMA+ZgY/BStHlbXKRu0Pz5dRC+HbSPfG6OXlCuja6Xyz8IrO1MF6fINebYfkuS9RhzrCQhRMGgKArRiWmZppvI6AWLiE5CnVX3F+Djavew9+uRW5BFXe2xyO+LbqfEPZgAdS1c3PTYBKiOugHz5dtB2VfA3t10cQqjMsf2W5Ksx5hjJQkhRLpGS0R00iO9Xg/n/4pOTMvyODtrC/wK6Xq9Sj06/svTCSfbfNj7pU6Dq7seTg8Rd+PhNpUl+DXUjeEq/yq4lTBdnCLHmWP7LUnWY8yxkoQQ4lliktIIe2S+r4zxX1fvJZKuyfpXfBEX20yLbQd4OlLa04mibvZY5ofeL0WByGMPZ5yPOp15u3cVXQ9XuVd1fy+o493yCXNsvyXJeow5VpIQQrwItUbL9fvJj/R6ZQzCT+RuQtaLbttYWeBXyCHfjfMqoomkTuo+6qbtpUL6GSx5OAFqlIUX+23rsd+mPmesK6NVyROexvRnSP0cXz/UHNtvSbIeY46VJIQQOS02OV0/7uvRme+v3E0iTZP1otv5hTtxNLc8SkuLwzSxOIG96uEt1xjFkS3a6mzS1GKHNpAkZOB8TrswoU2OL1Nlju23JFmPMcdKEkKI3KLRKty4n8yVe4mkqfN/sgVgoU7G4/YevG5spnDkVmxS7+u3aSxsiC7SgDvFWnC3aDPS7AqbMNL8o1l5rxx/IMMc229Jsh5jjpUkhBAil2g1cG3/g3Fca+H+5Uc2qsC3zoN1FdtB4dImC1M8yRzbb0myHmOOlSSEEMIEFAXunHsw4/w6uHkk8/bCZR/OOF+spkyAamLm2H5LkvUYc6wkIYQQZiDupm5aiHNr4fLOzBOgOhV5MAFqO/BvAla2WZ9HGIU5tt+SZD3GHCtJCCGEmUmJ1U18en7dgwlQ4x5us3GC0i10vVxlWsoEqLnEHNtvSbIeY46VJIQQwoyp0+DKTl0P1/n1EH/z4TYLKyjZ8MF8XG3Azdd0ceZz5th+S5L1GHOsJCGEEHmEVguRR3VjuM6thTtnM2/3qfpgxvm2UKSSTICag8yx/ZYk6zHmWElCCCHyqHthD8ZxrYNr+0B5ZFoMtxIPZ5wvUR8s89fkr7nNHNtvSbIeY46VJIQQIh9IvAsXNuh6uMK2gjrl4TZ7dyjbWtfDVaoZ2DiaLs48yhzbb0myHmOOlSSEECKfSUuEsG26Xq7z6yE5+uE2KzsICNYtYl22DTh5mi7OPMQc229Jsh5jjpUkhBAiH9OoH06Aen4t3L/yyEYV+NbV9XCVbwuFSpkqSrNnju23JFmPMcdKEkIIUUAoCkSdfTDj/BqIPJZ5u2f5hzPOF60uE6A+whzbb0myHmOOlSSEEKKAir2uu514bq1umgit+uE2J2/dLcVybcG/cYGfANUc229Jsh5jjpUkhBBCkBwDlzbrerguboa0+IfbbJyhTAtdwlWmJdi7mSpKkzHH9luSrMeYYyUJIYQQmahTdUv7nF+rmx4i4dbDbRZW4Nfo4QSorsVNF2cuMsf2W5Ksx5hjJQkhhBBZ0mrh5lFdD9f5dbpFrR/lU02XcJV/Fbwq5tsJUM2x/ZYk6zHmWElCCCFEtt0LezBwfq3uqUUeaebd/R7MOP8q+NbLVxOgmmP7LUnWY8yxkoQQQogXknAHLqzX3VIM3/bYBKgeutuJ5V59MAGqg+nizAHm2H5LkvUYc6wkIYQQ4qWlJepmmj+3VjfzfPL9h9us7KFUsG4urrKtwbGw6eJ8QebYfkuS9RhzrCQhhBAiR2nUELH3wbqKayAm4uE2lYXuVmL5V3W9XHlkAlRzbL8lyXqMOVaSEEIIYTSKArdPP5xxPvJ45u2eFR7MOP8q+JjvBKjm2H5LkvUYc6wkIYQQItfEXHswAeoauLo78wSozkV147jKvwp+TcDKxnRxPsYc229Jsh5jjpUkhBBCmETyfd3Ep+fW6CZCTUt4uM3WBUq30PVylWkJdq6mixPzbL8lyXqMOVaSEEIIYXLqVLi848F8XOsh4fbDbRbWuqV9yrfVjeNyKZrr4Zlj+y1J1mPMsZKEEEIIs6LVwo3DD2acXwt3L2TeXrTGw3UVvSrkygSo5th+m+fotaeYOHEiDRo0wMHBATc3t6fuExERQdu2bXFwcMDLy4tPP/0UtVr91H2FEEII8YIsLMC3NrQYCwMOwoDD0PIr8K0LqODmEdg6AWbVh+nVYeMXcHUPaDWmjjxX5ZmpXtPS0njrrbeoX78+v/zyyxPbNRoNbdu2xdvbmz179hAZGUm3bt2wtrZm0qRJJohYCCGEKCAKl4bCg6DhIEiIejBwfi2Eh8L9y7D3J92PQyEo2waajwZnb1NHbXR57nbhwoULGTx4MDExMZnK169fT7t27bh58yZFihQBYPbs2Xz++efcuXMHG5vsPQFhjt2NQgghRJ6UmgBhW3Qzzl/YACkxYGkLn4WDrVOOXsoc2+8805P1PHv37qVKlSr6BAugVatW9O3bl9OnT1O9evWnHpeamkpqaqr+dVxcnNFjFUIIIQoEWyeo2EH3o0nXTYB671KOJ1jmKs+MyXqeW7duZUqwAP3rW7duZXnc5MmTcXV11f/4+voaNU4hhBCiQLK0Bv8mUOsDU0eSa0yaZA0fPhyVSvXMn3Pnzhk1hhEjRhAbG6v/uXbtmlGvJ4QQQoiCwaS3C4cOHUqPHj2euU9AQEC2zuXt7c2BAwcyld2+fVu/LSu2trbY2tpm6xpCCCGEENll0iTL09MTT0/PHDlX/fr1mThxIlFRUXh5eQGwadMmXFxcqFixYo5cQwghhBAiu/LMwPeIiAiio6OJiIhAo9Fw7NgxAEqXLo2TkxOvvPIKFStWpGvXrnz99dfcunWLUaNG0b9/f+mpEkIIIUSuyzNTOPTo0YNFixY9Ub5t2zaaNm0KwNWrV+nbty+hoaE4OjrSvXt3pkyZgpVV9nNJc3wEVAghhBDPZo7td55JsnKLOVaSEEIIIZ7NHNvvfDOFgxBCCCGEOZEkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhBBCCCGMQJIsIYQQQggjkCRLCCGEEMIIJMkSQgghhDACSbKEEEIIIYxAkiwhhBBCCCOQJEsIIYQQwggkyRJCCCGEMAJJsoQQQgghjECSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwgjyTZE2cOJEGDRrg4OCAm5vbU/dRqVRP/Cxbtix3AxVCCCGEAKxMHUB2paWl8dZbb1G/fn1++eWXLPdbsGABrVu31r/OKiETQgghhDCmPJNkjRs3DoCFCxc+cz83Nze8vb1zISIhhBBCiKzlmSQru/r378+HH35IQEAAISEh9OzZE5VKleX+qamppKam6l/HxsYCEBcXZ/RYhRBCCJEzMtptRVFMHMlD+SrJ+uqrr2jWrBkODg78999/9OvXj4SEBD7++OMsj5k8ebK+l+xRvr6+xgxVCCGEEEYQHx+Pq6urqcMAQKWYMOUbPnw4U6dOfeY+Z8+epXz58vrXCxcuZPDgwcTExDz3/GPGjGHBggVcu3Yty30e78nSarVER0dTqFChZ/aAGSouLg5fX1+uXbuGi4tLjp03P5LPKvvkszKMfF7ZJ59V9slnlX3G/KwURSE+Pp6iRYtiYWEez/WZtCdr6NCh9OjR45n7BAQEvPD569aty/jx40lNTcXW1vap+9ja2j6xzZiD5V1cXOQfYTbJZ5V98lkZRj6v7JPPKvvks8o+Y31W5tKDlcGkSZanpyeenp5GO/+xY8dwd3fPMsESQgghhDCWPDMmKyIigujoaCIiItBoNBw7dgyA0qVL4+TkxOrVq7l9+zb16tXDzs6OTZs2MWnSJIYNG2bawIUQQghRIOWZJGvMmDEsWrRI/7p69eoAbNu2jaZNm2Jtbc2MGTMYMmQIiqJQunRppk2bRu/evU0Vcia2trZ8+eWX0quWDfJZZZ98VoaRzyv75LPKPvmssq+gfVYmHfguhBBCCJFfmcfweyGEEEKIfEaSLCGEEEIII5AkSwghhBDCCCTJEkIIIYQwAkmyhMjn5NkWkdMeXSVDCJE1SbKEyKfCwsK4f/9+ji4PJcT58+dp2bIlly5dMnUoQpg9SbKEyIeOHz9OmTJlWLlypalDEfnIsWPHqFevHrt27eLEiROAbr1XIcTTyTxZQuQzx48fp2HDhgwYMIApU6aYOhyRTxw/fpz69evzxRdfcOLECcLCwjh06JCpwxLCrElPlhD5yLlz56hVqxaff/45U6ZMQavVsnXrVubOncuePXu4ceOGqUMUedCxY8eoU6cOgwYN4osvviAkJIS7d++yfPlyU4cmhFnLM8vqCCGeTavV8scff6DRaHjzzTcBaNmyJffu3ePKlSsULlwYPz8/pk2bRmBgoImjFXlFdHQ0vXv35pNPPmHy5MkAVKlSBQ8PD9auXUvnzp1NHKEQ5ktuFwqRj9y+fVu/zmeZMmUoW7YsY8aMoWLFiqxZs4bZs2fj6urK/PnzcXJyMnW4Io84ePAgtWvXBkCj0WBpacnKlSt599132bBhA0FBQSaOUAjzJLcLhchHihQpwoQJE+jVqxd2dnZMmDCBqlWrYm1tzeuvv06bNm3YuXMnsbGxpg5V5CG1a9fWTwViaWkJQPXq1alUqRJbtmwBZAC8EE8jtwuFyMNu3rzJkSNHSEtLo0SJEtSqVQtPT09GjRrF1atXKVWqFPCw96F06dK4u7tjY2Nj4siFOXv0e+Xn50eNGjVQqVQoiqKfEsTPz4/WrVszc+ZMBgwYgJeXl4mjFsL8yO1CIfKokydP0rFjRwoXLkx4eDh+fn589tlnvPXWWwCZGsQMgwcP5syZM6xcuRJHR0dThC3M3NO+V59//rl+nB/oeq0sLCy4fv067du3p2PHjowePRoLC7k5IsSj5F+EEHlQWFgYr776Km+++Sb//fcfGzZsoFKlSmzYsAGNRvNEghUREcGnn37KkiVL+O677yTBEk+V1fdq/fr1+u8VoE+mihYtipeXF6GhoajValOGLoRZkp4sIfKYtLQ0RowYwfXr11myZIn+1t/8+fP57LPPOH/+PIUKFdLvf+DAAebMmcOePXv4/fffqVatmokiF+bM0O9VRiJ/7do1kpOTKVu2rKlCFyLHPe1OwIuQMVkF3LRp0yhVqhSNGjXK9AtUmC+tVkvx4sWpUKECNjY2+l8GDRo0wMnJifT09Ez716lTh/j4eL766iuKFStmoqiFuTP0e6VSqUhPT8fX19dEEQuRc4YNG0blypWpXr06VatWzbHlyCTJKsBOnz7NnTt3mD59OtWrV6dkyZJ8//33pg5LPIednR0dO3bE398/U7mbmxvW1taZGsPDhw9Ts2ZNmjdvntthijzGkO/V0aNHqV69OtbW1rkdphA57u7du/j4+PDLL79gYWGBt7c306ZNw8vL66W/4zImqwCrVKkSkydPZuvWrXTq1Il//vmHatWqsWXLFlJTU00dnnhEZGQkBw4cYMOGDWi1Wn1DqNFo9P/jio2N5f79+/pjxowZo5+MVEYFiKd50e9V8+bN5Xsl8o3ChQszdOhQVqxYwaRJkzh79iytW7dm0aJFLz/djSIKnO7duyvvv//+E+VJSUlKs2bNlAoVKijLly9X0tLSTBCdeNzx48eVkiVLKmXLllVcXV2V8uXLK7/99pty7949RVEURavVKoqiKOfPn1c8PT2V6OhoZfz48Yq9vb1y6NAhU4YuzJh8r4RQFI1G89Ty7t27KzVq1FCmTJmixMXFvfD5pSergElOTqZq1ar8999/DB48WF+elpaGvb09W7ZsoXz58owePZpz584ByP9WTejOnTt07tyZ9957j/Xr13PmzBmqVq3K+PHjmT59Onfu3NH3OLi5uVG8eHH69u3L+PHj2blzJzVr1jTxOxDmSL5XQjycigR0vbqPPiG7cOFCGjduzPLly9m6deuLX+SF0zORZ8XHxytz585VihYtqgwaNEhfnpycrP97rVq1lODgYBNEJx51+vRpxc/P74meg88//1ypUqWK8vXXXyuJiYmKoijKmTNnFJVKpdjb2ytHjx41QbQir5DvlSjoHu3B+uqrr5QePXooW7ZsUbRaraJWq/XbXnvtNaVatWovfB3pySpANBoNAE5OTvj5+dGlSxemT5/OqFGjAN3A15SUFAB+++03bty4wZw5c0wWr4D09HTUajVJSUmAricSYMqUKQQHBzNr1iwuXboEgLu7O/369ePIkSMyTYN4JvleiYIuowdrxIgRTJ8+nbZt21KpUiVUKhWWlpb69nL58uXEx8czevToF7qOzJNVAH366ads2bKFwMBA9u/fz+XLlwkJCdE/WajRaEhPT2f06NGo1Wr+97//mTbgAq5OnTo4OTnpu6xTU1OxtbUFdGvKlS5dmt9//x2AlJQU7OzsTBaryDvkeyUKun379vH++++zYMECGjdu/MT2jNuJs2fPZt++fSxcuNDga0hPVgGzYcMGfv75Z3788UcWLlxIaGgoEyZMYMmSJXzyySeAbgFYOzs72rVrx9KlS/X/oxXGl5iYSHx8PHFxcfqyOXPmcPr0ad59910AbG1t9WMHmjRpQmJion5faQjF08j3ShR0X3zxBadOncpUlpCQgFqtpkSJEk/sn9HbC7r/kKxZs4bjx48bfF1JsgqYGzdu4OXlRZ06dQAoUqQIPXr00PdkjR07Vr9vUFAQU6ZMwcHBwUTRFixnzpyhU6dOBAUFUaFCBZYuXQpAhQoV+OGHH9i0aRNvvfUW6enp+q7uqKgoHB0dUavV8oCCeCr5XomC7uzZs5w4cYLy5ctnKr9//z63b9/Wr27w6Fxwu3bt0i8XVaNGDWbPnv1CbaHcLixgdu3aRefOnfntt98ICgrSlx88eJDmzZuTkJDAN998w9ChQwG4efMmRYsWNVW4BcaZM2do0qQJ3bp1o1atWhw+fJgff/yR/fv3U716dZKSktiyZQv9+vXDycmJ8uXLY2Njw9q1a9m3bx+VK1c29VsQZki+V6KgUx6sXJDx519//YWPjw8NGzYkNTWVxo0b4+joyL///ouzszOgG6PYsWNHmjRpwhdffAFAdHQ0Hh4eBl9fkqx86tFHU0E3zsrS0pLIyEjefPNNypYty+DBg6latSoA586dY+zYsbz//vu0adMGS0tLU4Ve4ERHR9OlSxfKly/PDz/8oC8PDg6mSpUqTJ8+XV8WHx/PhAkTiI6Oxs7Ojr59+1KxYkVThC3MnHyvREGnKAoajQYrK93iNnfv3qVcuXI0adKEkSNHUrt2bVatWsXkyZNJTU1lwoQJ3Llzhz/++IObN29y+PBh/bEvSpbVyYceTbC+//57Tp06xYkTJ+jTpw/t27dn6tSp9O7dmwkTJtC8eXOqVq3K2LFjcXR0pG3btqhUKn1SJowvPT2dmJgY3nzzTeBh/fn7+xMdHQ3oflkoioKzszNTp07NtJ8QTyPfK1HQ3b59G29vbwCWLVvGq6++ysaNG+natSuTJ0/myy+/pGPHjhQtWpRJkybRp08ffHx88Pf359ChQ1hZWb10Wyg9WfnY8OHDmT9/PiNGjODu3bv8/vvvVK9enb///puNGzeyZMkS1q5di4+PD25ubmzfvh1ra+scW31cZN/FixcpU6YMoGscra2tGT16NFevXmXx4sX6/eLi4nBxcQFybpV4kX/J90oUVPv376dp06bs2bOHZcuWsWjRIvbt24efnx+HDh2iS5cuVK5cmTFjxlC9enUAIiIi8PDwwNHREZVKhVqtfumeLPnvSj61Z88eVq5cydq1axkyZAitW7fm2rVrdOjQAYBWrVrx66+/cvbsWf7991927dqFtbU1arVafsGaQEZDqNVq9QuSKopCVFSUfp/Jkyczb948/RMvUk/ieeR7JQoqDw8P3n//fYKCgpg7dy5Hjx7Fz8+P9PR0atWqxW+//capU6eYOHEi+/btA6BEiRI4OTmhUqnQarUvnWCBJFn5RsbEaRlSUlJwcnKidu3a/PHHH7Rt25bp06fTrVs3EhIS2LRpE3FxcXh7e1O6dGksLCxy7EslXpyFhUWmp7kybtuMGTOGL774gubNm0sdCYPJ90oUFBnf8zJlylCqVCkSEhJQFIWIiAhA991Xq9XUrl2b33//ndOnTzNixAjOnj2b6Tw5dctckqx8IuOe8f79+0lPTyctLQ2NRsOqVavo06cPkydPpm/fvgDs3LmT3377TT8uI4OMwzAPGb8krKys8PX15dtvv+Xrr7/m0KFD+gcVhDCUfK+EuXh8lFJOjVrSarX6ntj4+Hjatm1LaGgonTt3pk2bNmzduhVLS0v99WrVqsWvv/5KkSJFKFeuXI7E8Dj5r0set2bNGubOncu///7LkCFDOHToEOvXr6d169Z89dVXdOrUiTlz5tC7d29A18M1Y8YMHB0dKVmypImjF0+TkexaW1vz888/4+Liwq5du6hRo4aJIxN5mXyvhDk4f/48S5cuJSIigkaNGtGoUSPKly//0g9cPHr8lClTiI2N5cMPP6RKlSoUKVKEtLQ03nzzTVatWkWTJk0A+OGHH+jWrRvLli174hw5RQa+G9m1a9fYsWMHqamplCtXjoYNG+bYuTUaDStWrGDw4MG4u7tz/fp1Dh48qB+HsWfPHkJCQrC0tGTMmDHcu3ePP//8k5s3b3L06FGsrKzkSSIzdujQIerUqcOpU6fkcXqRY+R7JUzlzJkzNGjQgBYtWhAZGYlGo+HGjRssXLiQ5s2b58hDF5999hlLlixh4sSJtGnTBh8fHwAuXbrE+PHj+fvvv5k4cSJr1qzh1q1bHDt2zLhP0r/w0tLiuY4fP674+voqTZo0Uby9vZXg4GBlz549OXLujFXCNRqN8vrrrysqlUpp2bJlpn3S0tKUw4cPK23atFFKly6tNGjQQOnWrZuSlpaW6RzCfCUkJJg6BJEPyfdK5Da1Wq28//77ynvvvacvO3r0qNKrVy/F0tJSWbNmjaIoujbtRS1btkwpUqSIcvz4cX1ZbGyscv36dUWtVisxMTHKJ598olSsWFHp2LGjvi18mWs+j/RkGcm5c+cIDg6mZ8+efPnll5w9e5bXXnuN6dOn07Fjxxy7zt9//83NmzdJS0tj1qxZVK1alb///hsg0/we0dHR2Nra4uDgkGOPpgohhBDZkZ6eTsuWLalfvz6TJ0/Wl9+5c4cvv/ySBQsWsG3bNurVq/fC15g1axbr1q1j9erVnD17lrVr1zJr1iycnZ1p0KAB//vf/7C1tSU6Ohp3d/dcaQslyTKCpKQk+vbti42NDXPmzNHfjnvjjTeoWrUqzs7O+Pj48M477xh87scnGh05ciTHjx/Hx8eH9evX8+mnn1KzZk19ogWwZcsWGjVqhK2tLSDz4AghhMh9AwYM4MiRI6xduxZ3d3d9+bVr1xgyZAjJycn8/vvv+jnbnuVp7diMGTMYMmQIPXv2ZPPmzdSpU4eaNWuSkpLCkiVLWL16NWXLltXvnxvDZaQrwwgsLCx477338PT01FfgpEmTWLlyJVqtlri4OM6cOcOJEyeYNGmSwecGOHz4MCkpKcyfP18/Bqt9+/aoVCo+/fRT2rdvz08//UTv3r2xt7enWbNm+nNIgiWEECK3NWnShD179rBgwQJ69+6tXyvQ19eX9u3bM3LkSGJjY5+bZD2aHN26dYv4+HjKlClD//790Wg07N+/ny+++IJmzZrh5+fHhQsX+Ouvv/RzwWXIjfHI0pNlJImJiTg6OgKwb98+WrZsyW+//Ub79u1JSUlh6tSprFq1irVr1xq8APPRo0epWbMmAPPmzeODDz7Qb0tJSWHz5s0MGjQIjUaDt7c3O3fulJnchRBC5JorV66wcuVKEhISKFOmjP7OTf/+/dm6dSsff/wxnTt31i+6fObMGTp06MA///zzzAcyHm3Hxo4dy5o1a7h+/ToBAQH06NGDHj16YGVlpZ8bLiUlhTfffJO0tDQ2btyY6w96yWNlOSQuLo7r169z7do1tFotjo6O+rk46tWrx6lTp2jfvj0AdnZ2uLu7o9FocHV1Nfha1atXZ+HChdjY2HDw4EGSk5P12+zs7GjXrh1Hjx5l6dKl7NmzR2ZyF0IIkWtOnDhBw4YNWbt2LevWrWPIkCEsXboU0N3Sq1OnDrNmzWL8+PGEhYVx9+5dFi1ahIWFBUWKFHnmuTPasQkTJjBr1ixGjx7NpUuXAPjmm2+4cOECFhYWJCcnM2nSJDp06MDNmzdZt26dftLt3CS3C3PAqVOnGDBgADdu3MDe3p7GjRvzww8/ZFpcskSJEpmOCQ8Pp3Llys/NqrO6Z9ytWzeSk5Pp168fvr6+jBgxQv/lUxQFFxcX/XQRj65CLoQQQhjLhQsXePXVV+nWrRsTJkzg5s2b9OrVi5SUFP0+ixYtYty4cWzevJkyZcpQo0YNbty4wbp16yhUqNAzz68oCtHR0WzcuJHp06fToUMHtm7dysmTJ5k2bRqVK1dGrVZjb29P4cKFKVOmDOvWrcPKysokD3zJ7cKXdO7cORo1akSPHj1o0aIFR48e5Z9//mHQoEF06dLlif0TEhKYMmUKc+fOZdu2bVSqVCnLcz+aYP3yyy+cO3eO2NhY2rVrR1BQEK6ursycOZOBAwcyYcIEhg8fLr1VQgghTCI9PZ2QkBDUajW//PKLPqF5++23sbe3x93dnWLFivHpp58CuicLjxw5gpOTEyVLlqR48eLZus69e/do0aIF27dvZ/fu3bz99tt88803hISEkJyczG+//UaLFi0yTbj96NP2ucpok0MUADExMUq7du2U/v3768vS0tKU4OBgpWfPnk/sv27dOqVPnz5K8eLFlSNHjmT7OsOGDVM8PDyUHj16KIGBgUpgYKDSpUsX5e7du4qiKMqsWbMUa2trZcSIEYpWq335NyaEEEK8gNOnTys7d+7Uv540aZKiUqmU9957T+nTp49iZWWlfPjhh9k+39PaNK1Wq1StWlVp06aN4urqqsydO1e/LSwsTAkKClJWrFjxcm8kh8iYrJcQFxeHl5cXLVq0AHSZsrW1Na+//jr379/Xl2Xw9fWlcuXKhIaGUr169WxdY/v27fz555+sXbuWBQsWcPz4cfr378/NmzcZPnw4ycnJhISEMHXqVHbu3Jnzb1IIIYTIpgoVKtCoUSMAjh8/zurVq1mzZg2//vorc+bM4bfffmPZsmWcOnXquWsWProW4fXr1/WLPatUKkaOHMmJEydo0KCBftm4pKQkBg4ciJWVFa+99ppx32g2yUCdl+Dh4cH7779PcHAwkPlx0JiYmExlWq2WypUrU758eYPuCUdHR5Oenp5pTFePHj2IjY1l8eLF3L9/H3t7e4YMGcLgwYNRqVTyFKEQQohcERkZybVr17h//z4tWrTIdEuuatWq/PXXX5meoNdqtfj7+1O0aNHntlMZ7eeoUaNYs2YNMTExDB48mNdff53XXnuNM2fO8OOPP/LKK69QqFAhbt68yf379zl8+DCWlpamu0X46Hsw6dXzoISEBFJTU4mJicHR0VGfYD369J5arSY1NRXQPQkxatQo3n33XYBsV3hGD5izszMODg5cv34d0H1BbWxs+PDDD7lw4QK7d+/WHyMJlhBCiNxy4sQJ6tevT9euXencuTOVK1fm999/Jzo6Wr9PxtqBGQ4fPkzJkiWxtrbO1jX++OMPFi9ezPDhw2nXrh1z585l0qRJ3Lp1i1GjRvHnn3/i6uqKu7s7rVu35siRI/on6k2dYAEyJssQJ06cUBo2bKjUqFFDKVmypPL9998rYWFh+u0Z6x8tWrRICQ4OVhRFUUaMGKHY29srBw8efOa5s1o7KSEhQSlXrpzSsmVL5ebNm/ryiIgIJTAwUNm2bdtLvishhBDCMFFRUUr58uWVkSNHKmFhYcqNGzeUzp07KxUqVFC+/PJLJSoqKtP+kZGRyhdffKG4ubkpJ06cyPK8j7eFy5YtU7755hv963nz5inVq1dXPvzwQ+Xs2bNPPYc5rcsrtwuz6cqVKwQHB/P+++9TvXp1IiIiGDduHAcOHOCjjz6iSZMm+q5NjUaDo6MjY8aMYdq0aezevVs/eejTKIqiP3bGjBkcPXoUKysrWrRowZtvvsmGDRto0KABnTt3pkuXLpQoUYIff/wRKysrGjdunCvvXwghhMhw584dUlJS6NSpEwEBAQAsW7aM4cOHs2LFChwdHenfvz8ODg7s27ePX375hc2bN7Nt2zaqVKny1HM+2hb+8ssvXL58mYsXL+qnIwLo1asXKpWKGTNm8P333/PRRx/pxzgrD+7kmEUPVgYTJ3l5xqxZs5S6detmKtuwYYNSs2ZN5Y033lD279+vL58+fbqiUqkUZ2dn5dChQ88876NZ+8iRIxVXV1fljTfeUF599VVFpVIpgwYNUhRFUW7cuKG88sorSsWKFZVKlSopr776qn4FcXPK2oUQQuR/x44dU4oXL67s2LFDURRFSUpK0m/7+OOPFX9/f+X48eOKoihKeHi4snLlSiU8PDzL8z3aFo4YMUJxdnZWGjVqpNjb2ysVKlR4oi2dP3++Urx4cWXKlCk5+bZynCRZ2TR79mylQoUKSnR0tKLVavVfiM2bNyvly5dXBgwYoKSmpiqKoij//fefUqdOHeXUqVPZPv+pU6eUPn36KHv37tWXrVixQrG2tlZGjhypKIqipKSkKHfv3lWuXbumf6w1PT09p96iEEIIkW21a9fWD41RFF0blaFWrVpK586d9a+zO73Q6dOnlYEDByoHDhxQFEVR/vrrLyU4OFjp0KHDE1MfrVmzxuw7GSTJyqYNGzYo1tbWyqZNmxRFUfS9SIqiKH/++adiYWGhnxskPj5euXPnTrbP/ffffyvFihVTAgIClAsXLiiK8jCrX7x4sWJnZ5eppyxDVuO4hBBCiJyUkJCgxMXFKbGxsfqyI0eOKF5eXkqXLl30ZRn/8f/kk0+U9u3bG3SNjLawWrVqSmRkpL78jz/+UJo3b6689tprytGjR584zpwTLXm6MJtatWpFt27dePvttzl79izW1takpaUB8Oabb1K5cmV27doFgJOTE4ULF872uW1tbalZsybXrl3j5s2bAPr1lYKCgihSpAiRkZFPHJfbC10KIYQoeM6cOUOnTp0ICgqiQoUK+nUIK1SowA8//MCmTZt46623SE9P17dLUVFRODo6olarnzsfVgZbW1tq1KjBhQsX9E/UA7z11luEhISQkpLCgAEDuHjxYqbjzGoM1mNk4PtTXLp0iTlz5nDlyhUqVqxIv379KFKkCMOHDycyMpKgoCA2bdpE1apVAd1Adzs7O9zc3J577qetRdi2bVscHBxISEigd+/e/Prrr9SpUwfQJWyAfkoIIYQQIrecOXOGJk2a0K1bN2rVqsXhw4fp2bMnFStWpHr16rz22ms4OjrSr18/AgMDKV++PDY2Nqxdu5Z9+/ZlOS9kVm2hs7MziYmJ9OrVi19++YVatWoBus6M5ORkDh06RKlSpYz+vnOKrF34mFOnTtGyZUvq16+Po6Mj//zzD+3ateO3337Tbx8zZgxr165l/PjxuLu7c/HiRebNm8eBAwcoXbp0ludWHpnD6s8//yQtLQ17e3s6deoEwJYtW/jf//7HoUOHGDNmDNbW1qxevZqwsDBOnDhh1tm6EEKI/CU6OpouXbpQvnx5fvjhB315cHAwVapUYfr06fqy+Ph4JkyYQHR0NHZ2dvTt25eKFSs+9byPJlibN28mKSmJ1NRU3nrrLQB2797N1KlTuXHjBnPnzn3q0/lPS9LMkmnvVpqX69evK1WqVFGGDh2qLzt+/Lji6OiobN26VV+WkJCgTJ48WalWrZpSpUoVpXHjxk+9T5yV4cOHKy4uLkrFihUVV1dXJSQkRL9t69atSrNmzRRbW1vl1VdfVebMmaMfTGjO952FEELkL7du3VLq1Kmjf4IwYxxwz549lffee09RFCXTg2AZsjteeOjQoYqPj49StmxZxcnJSWnQoIGye/duRVEUZfv27UqHDh2U2rVrK3v27Mmpt5Tr5HbhIzZv3oyXlxdDhgwBdDO3lyxZkhIlSujHXwE4OjoyfPhwevXqhZOTE2q1Gmdn5yzPm5FxK4pCdHQ0R44cYceOHRQqVIh9+/bxwQcfkJyczMKFCwkODkar1TJ79myuXr1KjRo1sLW1JTU1FVtbW6N/BkIIIQRAkSJF+PXXXylTpgygGxpjYWFBsWLFuHr1KqBbaUSlUhEXF4eLi4u+7HkWLFjA4sWL2bhxIz4+Pmg0Gjp06MDHH3/MwoULadKkCWlpaYwbN4558+ZRv359471RI5Ik6xFNmjQhLCyMYsWKAbrBdK6urjg4OHD79u0n9vf09HzuOR/t0rx9+za3bt3C29ubEiVK4O7uzuuvv46NjQ3vv/8+KpWKBQsW0Lx5c7RaLTNmzKB///58//33efYLJoQQIu/KSLC0Wq1+KRxFUYiKitLvM3nyZGxtbfn444+xsrJ6Islau3YtdevWzfRA2Pnz52nYsCHVq1fXrzG4Y8cOatasyahRo1i1ahUtWrTAw8ODatWqGf+NGkkeuKGZe/z9/fnqq68AnlgDMDExUf/35cuXc/DgwWydMyPBGjlyJE2bNqVr167s2LFDv7aTpaUlbdu2ZenSpfzzzz906NABgJYtWzJ48GAcHR0ZOXIkqamp2X5CQwghhMhJGXdjHn0NMGbMGL744guaN2/+1EHuCxYs4K233uK3337LtKZhZGQk9+7dA3TtYHJyMg4ODnzzzTfs37+f8PBwAGrUqIGFhYX+ifu8RpKsLKhUKtRqNQD29va4uroCutXAu3TpQqFChZ55fMYCzwBLlizh999/5+OPP6Zr167ExsYyYsQI4uPjAd0X7NVXX2X27NkkJyfrr9u0aVPGjRvHkiVLsLW1lYWfhRBCmExGkmVlZYWvry/ffvstX3/9NYcOHdI/bf+4nj170rdvX3744Qd+/fVX7ty5A0CPHj04cuQIP/74I6BrZ0E3TKdw4cL6W48Z8sQg96eQ24XPkJHUaLVabG1tmTRpEv/73/84cOCAfq2mxyUlJeHg4KB/EnDdunVERETwxRf/b+/+Y6qq/ziOP68XCC6MWjjSzc2glTAtp2a5wFiMMTFqkAxoUWvDlJhthWzFvkjcVjOaJhVlEBCN0VYzYjRbNSJRuswU44dEhuRYoz9y/BghQy9yvn8YJzFEZ1xu9/J6/AXnnnt37t1ne7/2OZ/P+/yPrVu3AhAdHc3DDz/Mtm3bKC0tJTg4GKvVSkpKCqmpqQA4nU58fX31bEIREflPmAo6vr6+fPDBBwQHB9Pc3MzatWtnPH9qLfHevXtxOp3s378fgCeffJKoqCief/553nzzTcbHx9m+fTvDw8NUVFSwbNmya05keAq1cLgOcXFxdHd3MzAwQHNzs9m340ppaWmkpqayZcsWJicnGRwcJDQ0FIBdu3Zht9vNcx0OB4mJiWzevJl3333XnCkTERH5Lzt+/Dj33XcfJ0+evGqbhsuX3FRUVHD27FnsdjuBgYEUFBSwbds2RkZGKC8vZ/fu3QQFBREUFMQtt9yCw+HA19fXc9o0zEIhaxaGYXD+/HkeeOAB2tra6OzsZOXKlVc93263k5eXh5+fH+Pj4/j7+3P69GliYmJYvnw5H374IStWrDDPb2lpISoqioKCAgoLC+fhG4mIiPx7586dIzAw8Jrn2e12iouLKS0t5eLFi9TX1/PNN9/w8ssv88wzzxAQEMBvv/1Ga2srwcHBxMTEYLVamZiYuGojU0+ikHUduru7MQzjuhqrAbz33ns4nU4yMjIICQnh559/ZsOGDTz44IPs27dvWrfakydPEhER4RWDSUREBC5NUgwPD/PQQw+RmZnJc889Z76WnZ1NdXU1r732Gunp6eYdnylTuw29gWfPw82TyMjIqwYs+OeCvKamJoqLi6mtrWVgYICIiAhaWlo4fPgwL7zwAr29vea5q1atwsfHx1zsLiIi4uksFgu+vr4YhmEGpvHxceDSRMSaNWt45513KC8vZ2RkZNp7vSVggULWnJqaFPzkk0+Ij4/njTfe4MCBAwwMDBAZGUlLSwvff/89Tz31FP39/dPeq5ksERHxJkFBQYSFhVFZWQmAv78/TqcTgOXLl3P+/Hk6Oztnbebt6RSy5pDFYjFbN5SWlhITE8OePXs4cOAAg4ODREZGcujQIYKCgli6dKmbr1ZERMQ1pvpaFRUVMTAwQEJCAvD3nR+n00lNTQ01NTVYLBav7QOpNVk36Mp1WJffQ778761bt3LkyBFyc3NJSkqa1iXeG3ZOiIjIwjVbLZz6/9tvvyU7OxvDMIiMjOT3339ndHSU7u5urFarV9dC7/xW82BqQFRXVzMxMTFtUFmtVnNGq7y8nJiYGHJzc3E4HMDftxW9dVCJiMjCMFsthEv1MD4+nqNHj/L4449z1113ERcXx08//WTWSm+uhVoI9C+cOXOG/Px8Lly4QGZm5rS+IFODx2q1UlZWRnh4OImJicD1PTxTRETEE8xWC6eEhITw6quvTjvmLW0aZuO98XEeLFmyhHvuuYfvvvsO+Gd4unxG66WXXpr2v4iIiDe4Vi0EZlxz5e0BCxSyrothGDOGo4CAAPLz8/niiy+or6+f8b0zTZ2KiIh4mn9TCxfqHRyFrGvo6+vDYrGY94wbGxvNB1wCREREsGnTJjPBa6ZKRES8jWrhjVHImkVRURFhYWF0dHRgsVjo7OwkLi6OtLQ0srKyGBwc5OabbyYtLY2ysjL6+vo0UyUiIl5FtfDGKWTNIjY2lqSkJDZv3kxHRwd33303XV1dbNmyhWPHjnHvvffy7LPPsnjxYmJjY3n77bfVuV1ERLyKauGNU5+sGVRVVfH0008D0N7eTmFhIUePHuXgwYOsWbPG7Omxf/9+WltbqaqqIiAggDvuuAOHw4HNZptxd4WIiIinUC2cA4ZM09TUZFgsFmPnzp3msba2NiMpKclYunSp0dbW9o/3HD582MjNzTUWL15s2O32+bxcERGROadaODcUsq7gdDqN6upqIyAgwMjJyTGPXz642tvbDcMwjImJCWNyctIwDMMYHR017Ha7kZiYaJw7d848LiIi4mlUC+eG1mRdwcfHh/T0dEpLSykpKWHnzp0ArF69msLCQu6//342bdpER0eH2ffKMAwCAwOJiori+PHjDA0NLezpURER8WiqhXNDIesvxmVL03x8fMjIyKC8vHzGwbVhwwYSExNpbW3Fx8fHHESdnZ0A+Pr6zv8XEBER+ZdUC+eWQtZfpgbHW2+9RWNjIxaLhYyMDCoqKigpKSEnJwf4e3CFh4fzyiuvAJcekDk2NkZ/fz9fffUVoaGhbvseIiIiN0q1cG5pd+EVoqOjOXXqFJ9//jnR0dEYhkFNTQ2ZmZns2LGDvXv3AnD69GnCw8NZtGiRuXviyqePi4iIeCLVwrmxoEPW1QbCo48+yrFjx/j000/ZuHGjObi2b99Oeno6FRUV5rlTW1hFREQ8kWqh6yzYX8QwDHNQDQ0NmccA6uvrWbduHampqRw5cgSLxcITTzzBvn376O3tZXJy0vwcDSoREfFUqoWutSBnsj7++GP6+vrIy8ujsrKS/Px8mpqauPPOO6c1TouPj6e3t5ePPvqI6OjoaZ+h1C4iIp5MtdD1FtwvU1paSkZGBuvWrQMgMTGR2267jZSUFHp6erBYLGY6z83N5cyZMyQkJNDe3j7tczSoRETEU6kWzo8F9euUlZWxY8cOPvvsM+Lj4wEIDQ2loaGBm266ieTkZHp6esxB4+fnx4svvkh2djarVq1y56WLiIjMCdXC+bNgQlZVVRVZWVnU1taSnJxsHn///ffx9/fnyy+/xGaz8cgjj3Dw4EE6OzspLi7mwoULFBUVmc3WREREPJVq4fxaEGuyJiYmSE9Pp66ujq6uLlasWAFAcnIyJ06c4MSJE4SEhDA2NkZSUhKtra3YbDaWLFmCw+FQQzUREfF4qoXzz6tDVmNjI7GxsQCMjo6SmppKV1cXDQ0N5Ofnc+rUKerq6rj99tunLfJzOBwsWrSI9evXY7VamZiYwMfHx51fRURE5IaoFrqP14as5uZmkpKSaGtrY9myZQBmOm9oaCA8PJxDhw6Zr8HMvULUVE1ERDyVaqF7ee2arLVr17Jx40Z++eUXAJxOJzabjdraWlJTU/nzzz8ZHh6e9p6ZBpAGlYiIeCrVQvfy2pBls9kIDg4mLy8PuPSgyosXLxIUFERlZSWrV68mISGBH3/80c1XKiIi4hqqhe7llSFr6g7o7t27GRsbY9euXQDmrgibzUZdXR0rV67kscce44cffnDn5YqIiMw51UL388qQNbVo79ZbbyUlJYWmpiYqKyuB6YOrtraWkJAQXn/9dXderoiIyJxTLXQ/r134PqW/v5+cnBz++OMP0tLSyMrKAjB3SYyPj+Pn56eutSIi4rVUC93D60MWQF9fHwUFBfT09BAREUF5ebk5kKa2q2rnhIiIeDPVwvm3IEIWwNmzZ/n666/Zs2cPFouFhIQEkpOTWb9+vbsvTUREZF6oFs6vBROyLldSUsKvv/7K0NAQBQUFhIWFufuSRERE5pVqoestqJB1eSdbgJGREYKDg914RSIiIvNLtXD+LKiQdTVXDjgREZGFRrVw7ilkiYiIiLiA9mqKiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgLKGSJiIiIuIBCloiIiIgL/B9/gzvzDoxM4gAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 9, + "id": "6143f120", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dict_lcoe = {'LCOE': lcoe}\n", + "# for y, l in zip(years, lcoe):\n", + "# print(y,l)\n", + "# dict_lcoe[y] = l\n", + "\n", + "df_lcoe = pd.DataFrame(dict_lcoe, index=years)\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "df_lcoe.plot.bar(rot=45, ax=ax)\n", + "\n", + "# Formatting\n", + "ax.get_legend().remove()\n", + "ax.set_ylabel('Levelized cost of energy, $/MWh')\n", + "\n", + "# SAve fig\n", + "fig_dir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results'\n", + "fname_lcoe = '/lcoe_barchart.png'\n", + "fig.savefig(fig_dir+fname_lcoe, dpi=300, bbox_inches='tight')" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "df_perc = pd.DataFrame(cost_breakdown_perc, index=years)\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot()\n", - "df_perc.plot(rot=45, ax=ax)\n", - "\n", - "# Formatting\n", - "ax.set_ylim([-15, 15])\n", - "ax.set_ylabel('Percent change in Capex')\n", - "# ax.set_xlabel('Commercial operation date')\n", - "ax.legend(loc='upper left')\n", - "\n", - "#\n", - "fname_perc = '/percent_change.png'\n", - "fig.savefig(fig_dir+fname_perc, dpi=300, bbox_inches='tight')" - ] - }, - { - "cell_type": "markdown", - "id": "2f485fd4", - "metadata": {}, - "source": [ - "## Taking a crack at a waterfall" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "db937086", - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Turbine ['blades', 'nacelle', 'tower']\n", - "Substructure ['monopile', 'transition_piece']\n", - "Array System ['array_cable']\n", - "Export System ['export_cable']\n", - "1301.0 {'Turbine': 130.49030000000002, 'Substructure': 226.62796945399697, 'Array System': 0.0, 'Export System': 0.0} {'Turbine': 21.90884, 'Substructure': 127.91889831403384, 'Array System': 19.955383985464, 'Export System': 20.41809} 357.11826945399696 190.20121229949785\n" - ] - } - ], - "source": [ - "european_cost = base_capex \n", - "multiplier_structure = {'Turbine': ['blades', 'nacelle', 'tower'],\n", - " 'Substructure': ['monopile', 'transition_piece'],\n", - " 'Array System': ['array_cable'],\n", - " 'Export System': ['export_cable'],}\n", - "\n", - "transit_cost = {}\n", - "factory_cost = {}\n", - "total_transit_cost = 0\n", - "total_factory_cost = 0\n", - "\n", - "for k,v in multiplier_structure.items():\n", - " print(k,v)\n", - " transit_cost[k] = 0\n", - " factory_cost[k] = 0\n", - " for vi in v:\n", - " if k == 'Turbine':\n", - " split = TURBINE_CAPEX_SPLIT[vi]\n", - " else:\n", - " split = 1\n", - " _transit = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['imported']\n", - " _factory = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['domestic']\n", - " transit_cost[k] += _transit\n", - " factory_cost[k] += _factory\n", - " total_transit_cost += _transit\n", - " total_factory_cost += _factory\n", - "\n", - "print(base_project.capex_breakdown_per_kw['Turbine'], transit_cost, factory_cost, total_transit_cost, total_factory_cost)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "7d021e44", - "metadata": {}, - "outputs": [], - "source": [ - "# Plot waterfall\n", - "european = base_capex + total_transit_cost\n", - "\n", - "slack = total_transit_cost - total_factory_cost\n", - "\n", - "domestic = european\n", - "\n", - "transit_perc = '-' + str(round(100*total_transit_cost / base_capex, 2)) + '%'\n", - "factory_perc = str(round(100*total_factory_cost / base_capex, 2) ) + '%'\n", - "slack_perc = str(round(100*slack / base_capex, 2)) + '%'\n", - "\n", - "x = ['Imported', 'Transit', 'Factory', 'Margin', 'Domestic']\n", - "y = [european, total_transit_cost, total_factory_cost, slack, domestic]\n", - "bottom = [0, european-total_transit_cost, european-total_transit_cost, european-total_transit_cost + total_factory_cost, 0]\n", - "color = ['#5E6A71', '#8CC63F', '#933C06', '#FFC423', '#5E6A71']\n", - "bar_text = {'transit': transit_perc, 'factory': factory_perc, 'margin': slack_perc}\n", - "\n", - "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n", - "fname = 'lcoe_waterfall'\n", - "\n", - "fnamedir = fdir + fname\n", - "\n", - "waterfall_plot(x, y, bottom, color, bar_text, fname=fnamedir)" - ] - }, - { - "cell_type": "markdown", - "id": "e1d1f713", - "metadata": {}, - "source": [ - "### Plot an area chart over time" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "e640e06a", - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 10, + "id": "d2c0f18e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_perc = pd.DataFrame(cost_breakdown_perc, index=years)\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "df_perc.plot(rot=45, ax=ax)\n", + "\n", + "# Formatting\n", + "ax.set_ylim([-15, 15])\n", + "ax.set_ylabel('Percent change in Capex')\n", + "# ax.set_xlabel('Commercial operation date')\n", + "ax.legend(loc='upper left')\n", + "\n", + "#\n", + "fname_perc = '/percent_change.png'\n", + "fig.savefig(fig_dir+fname_perc, dpi=300, bbox_inches='tight')" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: C:\\Users\\mshields\\Documents\\Analysis tools\\ORBIT\\supply_chain_plots.py:182\n", - "FixedFormatter should only be used together with FixedLocator" - ] - } - ], - "source": [ - "x = [2023, 2025, 2027, 2030]\n", - "color_list = {'Wind turbine': '#5E6A71', 'Substructure': '#D9531E', 'Electrical infrastructure': '#5D9732', 'Cost margin': '#00A4E4'}\n", - "\n", - "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n", - "fname = 'capex_area'\n", - "\n", - "fnamedir = fdir + fname\n", - "\n", - "area_time_plot(x, cost_breakdown, color_list, fname=fnamedir)" - ] - }, - { - "cell_type": "markdown", - "id": "f147a0d1", - "metadata": {}, - "source": [ - "### Old methods below" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bffa864a", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "f13a8bfb-edff-4889-b12e-6f0d4a4416ec", - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "id": "2f485fd4", + "metadata": {}, + "source": [ + "## Taking a crack at a waterfall" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "db937086", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Turbine ['blades', 'nacelle', 'tower']\n", + "Substructure ['monopile', 'transition_piece']\n", + "Array System ['array_cable']\n", + "Export System ['export_cable']\n", + "1301.0 {'Turbine': 130.49030000000002, 'Substructure': 226.62796945399697, 'Array System': 0.0, 'Export System': 0.0} {'Turbine': 21.90884, 'Substructure': 127.91889831403384, 'Array System': 19.955383985464, 'Export System': 20.41809} 357.11826945399696 190.20121229949785\n" + ] + } + ], + "source": [ + "european_cost = base_capex \n", + "multiplier_structure = {'Turbine': ['blades', 'nacelle', 'tower'],\n", + " 'Substructure': ['monopile', 'transition_piece'],\n", + " 'Array System': ['array_cable'],\n", + " 'Export System': ['export_cable'],}\n", + "\n", + "transit_cost = {}\n", + "factory_cost = {}\n", + "total_transit_cost = 0\n", + "total_factory_cost = 0\n", + "\n", + "for k,v in multiplier_structure.items():\n", + " print(k,v)\n", + " transit_cost[k] = 0\n", + " factory_cost[k] = 0\n", + " for vi in v:\n", + " if k == 'Turbine':\n", + " split = TURBINE_CAPEX_SPLIT[vi]\n", + " else:\n", + " split = 1\n", + " _transit = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['imported']\n", + " _factory = base_project.capex_breakdown_per_kw[k] * split * DEFAULT_MULTIPLIERS[vi]['domestic']\n", + " transit_cost[k] += _transit\n", + " factory_cost[k] += _factory\n", + " total_transit_cost += _transit\n", + " total_factory_cost += _factory\n", + "\n", + "print(base_project.capex_breakdown_per_kw['Turbine'], transit_cost, factory_cost, total_transit_cost, total_factory_cost)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "7d021e44", + "metadata": {}, + "outputs": [], + "source": [ + "# Plot waterfall\n", + "european = base_capex + total_transit_cost\n", + "\n", + "slack = total_transit_cost - total_factory_cost\n", + "\n", + "domestic = european\n", + "\n", + "transit_perc = '-' + str(round(100*total_transit_cost / base_capex, 2)) + '%'\n", + "factory_perc = str(round(100*total_factory_cost / base_capex, 2) ) + '%'\n", + "slack_perc = str(round(100*slack / base_capex, 2)) + '%'\n", + "\n", + "x = ['Imported', 'Transit', 'Factory', 'Margin', 'Domestic']\n", + "y = [european, total_transit_cost, total_factory_cost, slack, domestic]\n", + "bottom = [0, european-total_transit_cost, european-total_transit_cost, european-total_transit_cost + total_factory_cost, 0]\n", + "color = ['#5E6A71', '#8CC63F', '#933C06', '#FFC423', '#5E6A71']\n", + "bar_text = {'transit': transit_perc, 'factory': factory_perc, 'margin': slack_perc}\n", + "\n", + "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n", + "fname = 'lcoe_waterfall'\n", + "\n", + "fnamedir = fdir + fname\n", + "\n", + "waterfall_plot(x, y, bottom, color, bar_text, fname=fnamedir)" + ] + }, + { + "cell_type": "markdown", + "id": "e1d1f713", + "metadata": {}, + "source": [ + "### Plot an area chart over time" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e640e06a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\mshields\\Documents\\Analysis tools\\ORBIT\\supply_chain_plots.py:182\n", + "FixedFormatter should only be used together with FixedLocator" + ] + } + ], + "source": [ + "x = [2023, 2025, 2027, 2030]\n", + "color_list = {'Wind turbine': '#5E6A71', 'Substructure': '#D9531E', 'Electrical infrastructure': '#5D9732', 'Cost margin': '#00A4E4'}\n", + "\n", + "fdir = 'C:/Users/mshields/Documents/Projects/Supply Chain Roadmap/Analysis repos/LCOE/results/'\n", + "fname = 'capex_area'\n", + "\n", + "fnamedir = fdir + fname\n", + "\n", + "area_time_plot(x, cost_breakdown, color_list, fname=fnamedir)" + ] + }, + { + "cell_type": "markdown", + "id": "f147a0d1", + "metadata": {}, + "source": [ + "### Old methods below" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bffa864a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f13a8bfb-edff-4889-b12e-6f0d4a4416ec", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'sc_manager' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_12020\\3653473131.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# Run a project through this method\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# It will perform the supply chain adjustments and return a project instance with the adjusted values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msc_project\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msc_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_project\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'sc_manager' is not defined" + ] + } + ], + "source": [ + "# Run a project through this method\n", + "# It will perform the supply chain adjustments and return a project instance with the adjusted values\n", + "sc_project = sc_manager.run_project(config)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02b0cfa6-8045-461f-9dfc-ff6019ce4e79", + "metadata": {}, + "outputs": [], + "source": [ + "# This is just for comparison\n", + "project = ProjectManager(config)\n", + "project.run()\n", + "print(project.capex_breakdown_per_kw)\n", + "print('blades', .135 * project.capex_breakdown_per_kw['Turbine'])\n", + "print('nacelle', .274 * project.capex_breakdown_per_kw['Turbine'])\n", + "print('tower', .162 * project.capex_breakdown_per_kw['Turbine'])\n", + "\n", + "install_costs = 0\n", + "for c,v in project.capex_breakdown_per_kw.items():\n", + " if 'Installation' in c:\n", + " install_costs += v\n", + " else:\n", + " pass\n", + "# print(project.capex_breakdown_per_kw)\n", + "print(install_costs)\n", + "print(project.total_capex_per_kw)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "455cdef8", + "metadata": {}, + "outputs": [], + "source": [ + "3274 - (175.6+356.5+210.8+503.6+88.4+105+165+313.5+252.1+543.1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4f63ada-549e-4414-b5f8-6b0722b91b9a", + "metadata": {}, + "outputs": [], + "source": [ + "# Comparing the values from SupplyChainManager vs. ProjectManager\n", + "df = pd.concat([\n", + " pd.Series(project.capex_breakdown, name=\"ORBIT\"),\n", + " pd.Series(sc_project.capex_breakdown, name=\"SupplyChain\")\n", + "], axis=1)\n", + "\n", + "df[\"Ratio\"] = df[\"SupplyChain\"] / df[\"ORBIT\"]" + ] + }, { - "ename": "NameError", - "evalue": "name 'sc_manager' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m~\\AppData\\Local\\Temp\\1\\ipykernel_12020\\3653473131.py\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# Run a project through this method\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[1;31m# It will perform the supply chain adjustments and return a project instance with the adjusted values\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0msc_project\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msc_manager\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun_project\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mconfig\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[1;31mNameError\u001b[0m: name 'sc_manager' is not defined" - ] + "cell_type": "code", + "execution_count": null, + "id": "6eaf7126-844e-48a1-8b5d-23752129f23b", + "metadata": {}, + "outputs": [], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10d77f74-a300-464b-9df0-783541cad297", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" } - ], - "source": [ - "# Run a project through this method\n", - "# It will perform the supply chain adjustments and return a project instance with the adjusted values\n", - "sc_project = sc_manager.run_project(config)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02b0cfa6-8045-461f-9dfc-ff6019ce4e79", - "metadata": {}, - "outputs": [], - "source": [ - "# This is just for comparison\n", - "project = ProjectManager(config)\n", - "project.run()\n", - "print(project.capex_breakdown_per_kw)\n", - "print('blades', .135 * project.capex_breakdown_per_kw['Turbine'])\n", - "print('nacelle', .274 * project.capex_breakdown_per_kw['Turbine'])\n", - "print('tower', .162 * project.capex_breakdown_per_kw['Turbine'])\n", - "\n", - "install_costs = 0\n", - "for c,v in project.capex_breakdown_per_kw.items():\n", - " if 'Installation' in c:\n", - " install_costs += v\n", - " else:\n", - " pass\n", - "# print(project.capex_breakdown_per_kw)\n", - "print(install_costs)\n", - "print(project.total_capex_per_kw)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "455cdef8", - "metadata": {}, - "outputs": [], - "source": [ - "3274 - (175.6+356.5+210.8+503.6+88.4+105+165+313.5+252.1+543.1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d4f63ada-549e-4414-b5f8-6b0722b91b9a", - "metadata": {}, - "outputs": [], - "source": [ - "# Comparing the values from SupplyChainManager vs. ProjectManager\n", - "df = pd.concat([\n", - " pd.Series(project.capex_breakdown, name=\"ORBIT\"),\n", - " pd.Series(sc_project.capex_breakdown, name=\"SupplyChain\")\n", - "], axis=1)\n", - "\n", - "df[\"Ratio\"] = df[\"SupplyChain\"] / df[\"ORBIT\"]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6eaf7126-844e-48a1-8b5d-23752129f23b", - "metadata": {}, - "outputs": [], - "source": [ - "df" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "10d77f74-a300-464b-9df0-783541cad297", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.9.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/misc/supply_chain_plots.py b/misc/supply_chain_plots.py index 75b6fd5c..8c289b62 100644 --- a/misc/supply_chain_plots.py +++ b/misc/supply_chain_plots.py @@ -1,31 +1,41 @@ -import pandas as pd -import math +"""Provides generic plotting routines for the supply chain model.""" + +from pathlib import Path + import numpy as np import matplotlib as mpl -import matplotlib.pyplot as plt import matplotlib.text as txt -import os +import matplotlib.pyplot as plt -def mysave(fig, froot, mode='png'): - assert mode in ['png', 'eps', 'pdf', 'all'] - fileName, fileExtension = os.path.splitext(froot) + +def mysave(fig, froot, mode="png"): + """Custom save method.""" + assert mode in ["png", "eps", "pdf", "all"] + fileName = Path(froot).name padding = 0.1 dpiVal = 200 legs = [] for a in fig.get_axes(): addLeg = a.get_legend() - if not addLeg is None: legs.append(a.get_legend()) + if addLeg is not None: + legs.append(a.get_legend()) ext = [] - if mode == 'png' or mode == 'all': - ext.append('png') - if mode == 'eps': # or mode == 'all': - ext.append('eps') - if mode == 'pdf' or mode == 'all': - ext.append('pdf') + if mode == "png" or mode == "all": + ext.append("png") + if mode == "eps": # or mode == 'all': + ext.append("eps") + if mode == "pdf" or mode == "all": + ext.append("pdf") for sfx in ext: - fig.savefig(fileName + '.' + sfx, format=sfx, pad_inches=padding, bbox_inches='tight', - dpi=dpiVal, bbox_extra_artists=legs) + fig.savefig( + fileName.with_suffix(sfx), + format=sfx, + pad_inches=padding, + bbox_inches="tight", + dpi=dpiVal, + bbox_extra_artists=legs, + ) titleSize = 24 # 40 #38 @@ -38,32 +48,58 @@ def mysave(fig, froot, mode='png'): linewidth = 3 -def myformat(ax, linewidth=linewidth, xticklabel=tickLabelSize, yticklabel=tickLabelSize, mode='save'): - assert type(mode) == type('') - assert mode.lower() in ['save', 'show'], 'Unknown mode' - - def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=yticklabel): - if mode.lower() == 'show': +def myformat( + ax, + linewidth=linewidth, + xticklabel=tickLabelSize, + yticklabel=tickLabelSize, + mode="save", +): + """Custom axes formatter method.""" + assert isinstance(mode, str) + assert mode.lower() in ["save", "show"], "Unknown mode" + + def myformat( + myax, + linewidth=linewidth, + xticklabel=xticklabel, + yticklabel=yticklabel, + ): + if mode.lower() == "show": for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize + 3 * deltaShow) for i in myax.get_lines(): - if i.get_marker() == 'D': continue # Don't modify baseline diamond + if i.get_marker() == "D": + continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() - if not leg is None: - for t in leg.get_texts(): t.set_fontsize(legendSize + deltaShow + 6) + if leg is not None: + for t in leg.get_texts(): + t.set_fontsize(legendSize + deltaShow + 6) th = leg.get_title() - if not th is None: + if th is not None: th.set_fontsize(legendSize + deltaShow + 6) - myax.set_title(myax.get_title(), size=titleSize + deltaShow, weight='bold') - myax.set_xlabel(myax.get_xlabel(), size=axLabelSize + deltaShow, weight='bold') - myax.set_ylabel(myax.get_ylabel(), size=axLabelSize + deltaShow, weight='bold') + myax.set_title( + myax.get_title(), + size=titleSize + deltaShow, + weight="bold", + ) + myax.set_xlabel( + myax.get_xlabel(), + size=axLabelSize + deltaShow, + weight="bold", + ) + myax.set_ylabel( + myax.get_ylabel(), + size=axLabelSize + deltaShow, + weight="bold", + ) myax.tick_params(labelsize=tickLabelSize + deltaShow) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -75,27 +111,29 @@ def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=ytickl for i in myax.get_yticklines(): i.set_linewidth(3) - elif mode.lower() == 'save': + elif mode.lower() == "save": for i in myax.get_children(): # Gets EVERYTHING! if isinstance(i, txt.Text): i.set_size(textSize) for i in myax.get_lines(): - if i.get_marker() == 'D': continue # Don't modify baseline diamond + if i.get_marker() == "D": + continue # Don't modify baseline diamond i.set_linewidth(linewidth) # i.set_markeredgewidth(4) i.set_markersize(10) leg = myax.get_legend() - if not leg is None: - for t in leg.get_texts(): t.set_fontsize(legendSize) + if leg is not None: + for t in leg.get_texts(): + t.set_fontsize(legendSize) th = leg.get_title() - if not th is None: + if th is not None: th.set_fontsize(legendSize) - myax.set_title(myax.get_title(), size=titleSize, weight='bold') - myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight='bold') - myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight='bold') + myax.set_title(myax.get_title(), size=titleSize, weight="bold") + myax.set_xlabel(myax.get_xlabel(), size=axLabelSize, weight="bold") + myax.set_ylabel(myax.get_ylabel(), size=axLabelSize, weight="bold") myax.tick_params(labelsize=tickLabelSize) myax.patch.set_linewidth(3) for i in myax.get_xticklabels(): @@ -107,83 +145,122 @@ def myformat(myax, linewidth=linewidth, xticklabel=xticklabel, yticklabel=ytickl for i in myax.get_yticklines(): i.set_linewidth(3) - if type(ax) == type([]): - for i in ax: myformat(i) + if isinstance(ax, list): + for i in ax: + myformat(i) else: myformat(ax) + def initFigAxis(figx=12, figy=9): + """Initializes the Figure and Axes.""" fig = plt.figure(figsize=(figx, figy)) ax = fig.add_subplot(111) return fig, ax + def waterfall_plot(x, y, bottom, color, bar_text, fname=None): - """ Waterfall plot comparing European andUS manufactining costs""" + """Waterfall plot comparing European andUS manufactining costs.""" fig, ax = initFigAxis() - h = ax.bar(x, y,bottom=bottom, color=color, edgecolor='k') + h = ax.bar(x, y, bottom=bottom, color=color, edgecolor="k") ax.get_yaxis().set_major_formatter( - mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ','))) - ax.set_ylabel('Capital Expenditures, $/kW') - ax.set_title('Comparison of different cost premiums between \nimported and domestically manufactured components') - - h[3].set_linestyle('--') + mpl.ticker.FuncFormatter(lambda x, p: format(int(x), ",")), + ) + ax.set_ylabel("Capital Expenditures, $/kW") + title = ( + "Comparison of different cost premiums between" + "\nimported and domestically manufactured components" + ) + ax.set_title(title) + + h[3].set_linestyle("--") h[3].set_linewidth(1.75) - h[3].set_edgecolor('k') - - ax.text(x[1], 2000, bar_text['transit'], horizontalalignment='center',) - ax.text(x[2], 2000, bar_text['factory'], horizontalalignment='center',) - ax.text(x[3], 2000, bar_text['margin'], horizontalalignment='center',) + h[3].set_edgecolor("k") + + ax.text( + x[1], + 2000, + bar_text["transit"], + horizontalalignment="center", + ) + ax.text( + x[2], + 2000, + bar_text["factory"], + horizontalalignment="center", + ) + ax.text( + x[3], + 2000, + bar_text["margin"], + horizontalalignment="center", + ) if fname is not None: myformat(ax) mysave(fig, fname) plt.close() + def area_time_plot(x, y, color, fname=None): - """Area plot showing changin component cost over time""" + """Area plot showing changing component cost over time.""" fig, ax = initFigAxis() y0 = np.zeros(len(x)) y_init = 0 - y_init = np.sum([v[0] for k,v in y.items()]) + y_init = np.sum([v[0] for k, v in y.items()]) - for k,v in y.items(): - y1 = [yi+vi for yi, vi in zip(y0,v)] + for k, v in y.items(): + y1 = [yi + vi for yi, vi in zip(y0, v)] ax.fill_between(x, y0 / y_init, y1 / y_init, color=color[k], label=k) - ax.plot(x, y1 / y_init, 'w') + ax.plot(x, y1 / y_init, "w") y0 = y1 # Define margin - ax.fill_between(x, y1 / y_init, np.ones(len(x)), color=color['Cost margin'], label='Margin') - - final_margin = round( 100* (1 - y1[-1] / y_init), 1) - - y_margin = ((1 + y1[-1] / y_init) /2) - - margin_text = ' ' + str(final_margin) + '% CapEx margin relative to \n European imports can cover \n local differences in wages, \n taxes, financing, etc' + ax.fill_between( + x, + y1 / y_init, + np.ones(len(x)), + color=color["Cost margin"], + label="Margin", + ) + + final_margin = round(100 * (1 - y1[-1] / y_init), 1) + + y_margin = (1 + y1[-1] / y_init) / 2 + + margin_text = ( + f" {final_margin}" + "% CapEx margin relative to " + "\n European imports can cover " + "\n local differences in wages, " + "\n taxes, financing, etc" + ) right_bound = 2030.5 right_spline_corr = 0.2 - ax.plot([2030, right_bound], [y_margin, y_margin], 'k') - ax.text(right_bound, y_margin, margin_text, verticalalignment='center') - ax.spines["right"].set_position(("data", right_bound-right_spline_corr)) - ax.spines["top"].set_bounds(2022.65, right_bound-right_spline_corr) - ax.spines["bottom"].set_bounds(2022.65, right_bound-right_spline_corr) + ax.plot([2030, right_bound], [y_margin, y_margin], "k") + ax.text(right_bound, y_margin, margin_text, verticalalignment="center") + ax.spines["right"].set_position(("data", right_bound - right_spline_corr)) + ax.spines["top"].set_bounds(2022.65, right_bound - right_spline_corr) + ax.spines["bottom"].set_bounds(2022.65, right_bound - right_spline_corr) - ax.text(2023, -0.215, '(Fully \nimported)', horizontalalignment='center') - ax.text(2030, -0.215, '(Fully \ndomestic)', horizontalalignment='center') + ax.text(2023, -0.215, "(Fully \nimported)", horizontalalignment="center") + ax.text(2030, -0.215, "(Fully \ndomestic)", horizontalalignment="center") - ax.set_yticklabels([-20, 0, 20, 40, 60, 80 ,100]) + ax.set_yticklabels([-20, 0, 20, 40, 60, 80, 100]) ax.legend(loc=(1, 0.05)) - ax.set_ylabel('CapEx breakdown relative to \ncomponents imported from Europe, %') + ax.set_ylabel( + "CapEx breakdown relative to \ncomponents imported from Europe, %", + ) if fname is not None: myformat(ax) diff --git a/pyproject.toml b/pyproject.toml index 81b09129..6ac71302 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,20 +55,18 @@ classifiers = [ source = "https://github.com/WISDEM/ORBIT" documentation = "https://wisdem.github.io/ORBIT/" issues = "https://github.com/WISDEM/ORBIT/issues" -changelog = "https://github.com/WISDEM/ORBIT/blob/main/docs/source/changelog.rst" # TODO +changelog = "https://github.com/WISDEM/ORBIT/blob/main/docs/source/changelog.rst" [project.optional-dependencies] dev = [ "pre-commit", - "pylint", - "flake8", - "Flake8-pyproject", "black", "isort", "pytest", "pytest-cov", "sphinx", "sphinx-rtd-theme", + "ruff", ] [tool.setuptools] @@ -119,14 +117,9 @@ known_first_party = [ ] length_sort = "1" -[tool.flake8] -ignore = [ - "E731", - "E402", - "F", - "W504", - "W503", -] +[tool.ruff] +line-length = 79 +target-version = "py39" exclude = [ ".git", "__pycache__", @@ -135,772 +128,43 @@ exclude = [ "build", "dist", "^tests/", + ".ruff_cache", ] -max-complexity = 10 -max-line-length = 79 - -[tool.pylint.main] -# Analyse import fallback blocks. This can be used to support both Python 2 and 3 -# compatible code, which means that the block might have code that exists only in -# one or another interpreter, leading to false positives when analysed. -# analyse-fallback-blocks = - -# Clear in-memory caches upon conclusion of linting. Useful if running pylint in -# a server-like mode. -# clear-cache-post-run = - -# Always return a 0 (non-error) status code, even if lint errors are found. This -# is primarily useful in continuous integration scripts. -# exit-zero = - -# A comma-separated list of package or module names from where C extensions may -# be loaded. Extensions are loading into the active Python interpreter and may -# run arbitrary code. -# extension-pkg-allow-list = - -# A comma-separated list of package or module names from where C extensions may -# be loaded. Extensions are loading into the active Python interpreter and may -# run arbitrary code. (This is an alternative name to extension-pkg-allow-list -# for backward compatibility.) -# extension-pkg-whitelist = - -# Return non-zero exit code if any of these messages/categories are detected, -# even if score is above --fail-under value. Syntax same as enable. Messages -# specified are enabled, while categories only check already-enabled messages. -# fail-on = - -# Specify a score threshold under which the program will exit with error. -fail-under = 10 - -# Interpret the stdin as a python script, whose filename needs to be passed as -# the module_or_package argument. -# from-stdin = - -# Files or directories to be skipped. They should be base names, not paths. -ignore = ["CVS"] - -# Add files or directories matching the regular expressions patterns to the -# ignore-list. The regex matches against paths and can be in Posix or Windows -# format. Because '\\' represents the directory delimiter on Windows systems, it -# can't be used as an escape character. -# ignore-paths = - -# Files or directories matching the regular expression patterns are skipped. The -# regex matches against base names, not paths. The default value ignores Emacs -# file locks -# ignore-patterns = - -# List of module names for which member attributes should not be checked (useful -# for modules/projects where namespaces are manipulated during runtime and thus -# existing member attributes cannot be deduced by static analysis). It supports -# qualified module names, as well as Unix pattern matching. -# ignored-modules = - -# Python code to execute, usually for sys.path manipulation such as -# pygtk.require(). -# init-hook = - -# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the -# number of processors available to use, and will cap the count on Windows to -# avoid hangs. -jobs = 4 - -# Control the amount of potential inferred values when inferring a single object. -# This can help the performance when dealing with large functions or complex, -# nested conditions. -limit-inference-results = 100 - -# List of plugins (as comma separated values of python module names) to load, -# usually to register additional checkers. -# load-plugins = - -# Pickle collected data for later comparisons. -persistent = true - -# Minimum Python version to use for version dependent checks. Will default to the -# version used to run pylint. -py-version = "3.10" - -# Discover python modules and packages in the file system subtree. -# recursive = - -# Add paths to the list of the source roots. Supports globbing patterns. The -# source root is an absolute path or a path relative to the current working -# directory used to determine a package namespace for modules located under the -# source root. -# source-roots = - -# When enabled, pylint would attempt to guess common misconfiguration and emit -# user-friendly hints instead of false-positive error messages. -suggestion-mode = true - -# Allow loading of arbitrary C extensions. Extensions are imported into the -# active Python interpreter and may run arbitrary code. -# unsafe-load-any-extension = - -[tool.pylint.basic] -# Naming style matching correct argument names. -argument-naming-style = "snake_case" - -# Regular expression matching correct argument names. Overrides argument-naming- -# style. If left empty, argument names will be checked with the set naming style. -# argument-rgx = - -# Naming style matching correct attribute names. -attr-naming-style = "snake_case" - -# Regular expression matching correct attribute names. Overrides attr-naming- -# style. If left empty, attribute names will be checked with the set naming -# style. -# attr-rgx = - -# Bad variable names which should always be refused, separated by a comma. -bad-names = ["foo", "bar", "baz", "toto", "tutu", "tata"] - -# Bad variable names regexes, separated by a comma. If names match any regex, -# they will always be refused -# bad-names-rgxs = - -# Naming style matching correct class attribute names. -class-attribute-naming-style = "any" - -# Regular expression matching correct class attribute names. Overrides class- -# attribute-naming-style. If left empty, class attribute names will be checked -# with the set naming style. -# class-attribute-rgx = - -# Naming style matching correct class constant names. -class-const-naming-style = "UPPER_CASE" - -# Regular expression matching correct class constant names. Overrides class- -# const-naming-style. If left empty, class constant names will be checked with -# the set naming style. -# class-const-rgx = - -# Naming style matching correct class names. -class-naming-style = "PascalCase" - -# Regular expression matching correct class names. Overrides class-naming-style. -# If left empty, class names will be checked with the set naming style. -# class-rgx = - -# Naming style matching correct constant names. -const-naming-style = "UPPER_CASE" - -# Regular expression matching correct constant names. Overrides const-naming- -# style. If left empty, constant names will be checked with the set naming style. -# const-rgx = - -# Minimum line length for functions/classes that require docstrings, shorter ones -# are exempt. -docstring-min-length = -1 - -# Naming style matching correct function names. -function-naming-style = "snake_case" - -# Regular expression matching correct function names. Overrides function-naming- -# style. If left empty, function names will be checked with the set naming style. -# function-rgx = - -# Good variable names which should always be accepted, separated by a comma. -good-names = ["i", "j", "k", "ex", "Run", "_"] - -# Good variable names regexes, separated by a comma. If names match any regex, -# they will always be accepted -# good-names-rgxs = - -# Include a hint for the correct naming format with invalid-name. -include-naming-hint = false - -# Naming style matching correct inline iteration names. -inlinevar-naming-style = "any" - -# Regular expression matching correct inline iteration names. Overrides -# inlinevar-naming-style. If left empty, inline iteration names will be checked -# with the set naming style. -# inlinevar-rgx = - -# Naming style matching correct method names. -method-naming-style = "snake_case" - -# Regular expression matching correct method names. Overrides method-naming- -# style. If left empty, method names will be checked with the set naming style. -# method-rgx = - -# Naming style matching correct module names. -module-naming-style = "snake_case" - -# Regular expression matching correct module names. Overrides module-naming- -# style. If left empty, module names will be checked with the set naming style. -# module-rgx = - -# Colon-delimited sets of names that determine each other's naming style when the -# name regexes allow several styles. -# name-group = - -# Regular expression which should only match function or class names that do not -# require a docstring. -no-docstring-rgx = "^_" - -# List of decorators that produce properties, such as abc.abstractproperty. Add -# to this list to register other decorators that produce valid properties. These -# decorators are taken in consideration only for invalid-name. -property-classes = ["abc.abstractproperty"] - -# Regular expression matching correct type alias names. If left empty, type alias -# names will be checked with the set naming style. -# typealias-rgx = - -# Regular expression matching correct type variable names. If left empty, type -# variable names will be checked with the set naming style. -# typevar-rgx = - -# Naming style matching correct variable names. -variable-naming-style = "snake_case" - -# Regular expression matching correct variable names. Overrides variable-naming- -# style. If left empty, variable names will be checked with the set naming style. -# variable-rgx = - -[tool.pylint.classes] -# Warn about protected attribute access inside special methods -# check-protected-access-in-special-methods = - -# List of method names used to declare (i.e. assign) instance attributes. -defining-attr-methods = ["__init__", "__new__", "setUp"] - -# List of member names, which should be excluded from the protected access -# warning. -exclude-protected = ["_asdict", "_fields", "_replace", "_source", "_make"] - -# List of valid names for the first argument in a class method. -valid-classmethod-first-arg = ["cls"] - -# List of valid names for the first argument in a metaclass class method. -valid-metaclass-classmethod-first-arg = ["mcs"] - -[tool.pylint.design] -# List of regular expressions of class ancestor names to ignore when counting -# public methods (see R0903) -# exclude-too-few-public-methods = - -# List of qualified class names to ignore when counting class parents (see R0901) -# ignored-parents = - -# Maximum number of arguments for function / method. -max-args = 5 - -# Maximum number of attributes for a class (see R0902). -max-attributes = 7 - -# Maximum number of boolean expressions in an if statement (see R0916). -max-bool-expr = 5 - -# Maximum number of branch for function / method body. -max-branches = 12 - -# Maximum number of locals for function / method body. -max-locals = 15 - -# Maximum number of parents for a class (see R0901). -max-parents = 7 -# Maximum number of public methods for a class (see R0904). -max-public-methods = 20 - -# Maximum number of return / yield for function / method body. -max-returns = 6 - -# Maximum number of statements in function / method body. -max-statements = 50 - -# Minimum number of public methods for a class (see R0903). -min-public-methods = 2 - -[tool.pylint.exceptions] -# Exceptions that will emit a warning when caught. -overgeneral-exceptions = ["Exception"] - -[tool.pylint.format] -# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. -# expected-line-ending-format = - -# Regexp for a line that is allowed to be longer than the limit. -ignore-long-lines = "^\\s*(# )??$" - -# Number of spaces of indent required inside a hanging or continued line. -indent-after-paren = 4 - -# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 -# tab). -indent-string = " " - -# Maximum number of characters on a single line. -max-line-length = 79 - -# Maximum number of lines in a module. -max-module-lines = 1000 - -# Allow the body of a class to be on the same line as the declaration if body -# contains single statement. -single-line-class-stmt = false - -# Allow the body of an if to be on the same line as the test if there is no else. -single-line-if-stmt = false - -# List of optional constructs for which whitespace checking is disabled. `dict- -# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. -# `trailing-comma` allows a space between comma and closing bracket: (a, ). -# `empty-line` allows space-only lines. -no-space-check= ["trailing-comma", "dict-separator"] - -[tool.pylint.imports] -# List of modules that can be imported at any level, not just the top level one. -# allow-any-import-level = - -# Allow explicit reexports by alias from a package __init__. -# allow-reexport-from-package = - -# Allow wildcard imports from modules that define __all__. -allow-wildcard-with-all = false - -# Deprecated modules which should not be used, separated by a comma. -deprecated-modules = ["optparse", "tkinter.tix"] - -# Output a graph (.gv or any supported image format) of external dependencies to -# the given file (report RP0402 must not be disabled). -# ext-import-graph = - -# Output a graph (.gv or any supported image format) of all (i.e. internal and -# external) dependencies to the given file (report RP0402 must not be disabled). -# import-graph = - -# Output a graph (.gv or any supported image format) of internal dependencies to -# the given file (report RP0402 must not be disabled). -# int-import-graph = - -# Force import order to recognize a module as part of the standard compatibility -# libraries. -# known-standard-library = - -# Force import order to recognize a module as part of a third party library. -known-third-party = ["enchant"] - -# Couples of modules and preferred modules, separated by a comma. -# preferred-modules = - -[tool.pylint.logging] -# The type of string formatting that logging methods do. `old` means using % -# formatting, `new` is for `{}` formatting. -logging-format-style = "new" - -# Logging modules to check that the string format arguments are in logging -# function parameter format. -logging-modules = ["logging"] - -[tool.pylint."messages control"] -# Only show warnings with the listed confidence levels. Leave empty to show all. -# Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, UNDEFINED. -confidence = ["HIGH", "CONTROL_FLOW", "INFERENCE", "INFERENCE_FAILURE", "UNDEFINED"] - -# Disable the message, report, category or checker with the given id(s). You can -# either give multiple identifiers separated by comma (,) or put this option -# multiple times (only on the command line, not in the configuration file where -# it should appear only once). You can also use "--disable=all" to disable -# everything first and then re-enable specific checks. For example, if you want -# to run only the similarities checker, you can use "--disable=all -# --enable=similarities". If you want to run only the classes checker, but have -# no Warning level messages displayed, use "--disable=all --enable=classes -# --disable=W". -disable = ["all"] - -# Enable the message, report, category or checker with the given id(s). You can -# either give multiple identifier separated by comma (,) or put this option -# multiple time (only on the command line, not in the configuration file where it -# should appear only once). See also the "--disable" option for examples. -enable = [ - "unused-import", - "unused-argument", - "unused-variable", - "unused-wildcard-import", - "used-before-assignment", - "undefined-variable", - "undefined-all-variable", - "missing-docstring", - "empty-docstring", - "unneeded-not", - "singleton-comparison", - "unidiomatic-typecheck", - "consider-using-enumerate", - "consider-iterating-dictionary", - "no-member", - "no-self-use", - "duplicate-code", - "len-as-condition", - "missing-format-argument-key", - "import-self", - "reimported", - "wildcard-import", - "relative-import", - "deprecated-module", - "unpacking-non-sequence", - "invalid-all-object", - "undefined-all-variable", - "used-before-assignment", - "cell-var-from-loop", - "global-variable-undefined", - "redefine-in-handler", - "global-variable-not-assigned", - "undefined-loop-variable", - "global-statement", - "global-at-module-level", - "bad-open-mode", - "redundant-unittest-assert", +[tool.ruff.lint] +fixable = ["ALL"] +unfixable = [] +select = [ + "F", + "E", + "W", + "C4", + "D", + "UP", + "BLE", + "B", + "A", + "NPY", + "PD", + "PTH", + "PERF", + "Q", +] +ignore = [ + "E731", + "E402", + "D202", + "D212", + "C901", + "D205", + "D401", + "PD901", + "PERF203", ] -# Things we'd like to enable someday: -# redefined-outer-name (requires a bunch of work to clean up our code first) -# undefined-variable (re-enable when pylint fixes https://github.com/PyCQA/pylint/issues/760) -# no-name-in-module (giving us spurious warnings https://github.com/PyCQA/pylint/issues/73) -# unused-argument (need to clean up or code a lot, e.g. prefix unused_?) - -# Things we'd like to try. -# Procedure: -# 1. Enable a bunch. -# 2. See if there's spurious ones; if so disable. -# 3. Record above. -# 4. Remove from this list. - # deprecated-method, - # anomalous-unicode-escape-in-string, - # anomalous-backslash-in-string, - # not-in-loop, - # function-redefined, - # continue-in-finally, - # abstract-class-instantiated, - # star-needs-assignment-target, - # duplicate-argument-name, - # return-in-init, - # too-many-star-expressions, - # nonlocal-and-global, - # return-outside-function, - # return-arg-in-generator, - # invalid-star-assignment-target, - # bad-reversed-sequence, - # nonexistent-operator, - # yield-outside-function, - # init-is-generator, - # nonlocal-without-binding, - # lost-exception, - # assert-on-tuple, - # dangerous-default-value, - # duplicate-key, - # useless-else-on-loop, - # expression-not-assigned, - # confusing-with-statement, - # unnecessary-lambda, - # pointless-statement, - # pointless-string-statement, - # unnecessary-pass, - # unreachable, - # eval-used, - # exec-used, - # bad-builtin, - # using-constant-test, - # deprecated-lambda, - # bad-super-call, - # missing-super-argument, - # slots-on-old-class, - # super-on-old-class, - # property-on-old-class, - # not-an-iterable, - # not-a-mapping, - # format-needs-mapping, - # truncated-format-string, - # missing-format-string-key, - # mixed-format-string, - # too-few-format-args, - # bad-str-strip-call, - # too-many-format-args, - # bad-format-character, - # format-combined-specification, - # bad-format-string-key, - # bad-format-string, - # missing-format-attribute, - # missing-format-argument-key, - # unused-format-string-argument, - # unused-format-string-key, - # invalid-format-index, - # bad-indentation, - # mixed-indentation, - # unnecessary-semicolon, - # lowercase-l-suffix, - # fixme, - # invalid-encoded-data, - # unpacking-in-except, - # import-star-module-level, - # parameter-unpacking, - # long-suffix, - # old-octal-literal, - # old-ne-operator, - # backtick, - # old-raise-syntax, - # print-statement, - # metaclass-assignment, - # next-method-called, - # dict-iter-method, - # dict-view-method, - # indexing-exception, - # raising-string, - # standarderror-builtin, - # using-cmp-argument, - # cmp-method, - # coerce-method, - # delslice-method, - # getslice-method, - # hex-method, - # nonzero-method, - # oct-method, - # setslice-method, - # apply-builtin, - # basestring-builtin, - # buffer-builtin, - # cmp-builtin, - # coerce-builtin, - # old-division, - # execfile-builtin, - # file-builtin, - # filter-builtin-not-iterating, - # no-absolute-import, - # input-builtin, - # intern-builtin, - # long-builtin, - # map-builtin-not-iterating, - # range-builtin-not-iterating, - # raw_input-builtin, - # reduce-builtin, - # reload-builtin, - # round-builtin, - # unichr-builtin, - # unicode-builtin, - # xrange-builtin, - # zip-builtin-not-iterating, - # logging-format-truncated, - # logging-too-few-args, - # logging-too-many-args, - # logging-unsupported-format, - # logging-not-lazy, - # logging-format-interpolation, - # invalid-unary-operand-type, - # unsupported-binary-operation, - # no-member, - # not-callable, - # redundant-keyword-arg, - # assignment-from-no-return, - # assignment-from-none, - # not-context-manager, - # repeated-keyword, - # missing-kwoa, - # no-value-for-parameter, - # invalid-sequence-index, - # invalid-slice-index, - # too-many-function-args, - # unexpected-keyword-arg, - # unsupported-membership-test, - # unsubscriptable-object, - # access-member-before-definition, - # method-hidden, - # assigning-non-slot, - # duplicate-bases, - # inconsistent-mro, - # inherit-non-class, - # invalid-slots, - # invalid-slots-object, - # no-method-argument, - # no-self-argument, - # unexpected-special-method-signature, - # non-iterator-returned, - # protected-access, - # arguments-differ, - # attribute-defined-outside-init, - # no-init, - # abstract-method, - # signature-differs, - # bad-staticmethod-argument, - # non-parent-init-called, - # super-init-not-called, - # bad-except-order, - # catching-non-exception, - # bad-exception-context, - # notimplemented-raised, - # raising-bad-type, - # raising-non-exception, - # misplaced-bare-raise, - # duplicate-except, - # broad-except, - # nonstandard-exception, - # binary-op-exception, - # bare-except, - # not-async-context-manager, - # yield-inside-async-function, - -[tool.pylint.method_args] -# List of qualified names (i.e., library.method) which require a timeout -# parameter e.g. 'requests.api.get,requests.api.post' -timeout-methods = ["requests.api.delete", "requests.api.get", "requests.api.head", "requests.api.options", "requests.api.patch", "requests.api.post", "requests.api.put", "requests.api.request"] - -[tool.pylint.miscellaneous] -# List of note tags to take in consideration, separated by a comma. -notes = ["FIXME", "XXX", "TODO"] - -# Regular expression of note tags to take in consideration. -# notes-rgx = - -[tool.pylint.refactoring] -# Maximum number of nested blocks for function / method body -max-nested-blocks = 5 - -# Complete name of functions that never returns. When checking for inconsistent- -# return-statements if a never returning function is called then it will be -# considered as an explicit return statement and no message will be printed. -never-returning-functions = ["sys.exit", "argparse.parse_error"] - -[tool.pylint.reports] -# Python expression which should return a score less than or equal to 10. You -# have access to the variables 'fatal', 'error', 'warning', 'refactor', -# 'convention', and 'info' which contain the number of messages in each category, -# as well as 'statement' which is the total number of statements analyzed. This -# score is used by the global evaluation report (RP0004). -evaluation = "10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)" - -# Template used to display messages. This is a python new-style format string -# used to format the message information. See doc for all details. -# msg-template = - -# Set the output format. Available formats are text, parseable, colorized, json -# and msvs (visual studio). You can also give a reporter class, e.g. -# mypackage.mymodule.MyReporterClass. -output-format = ["text"] - -# Tells whether to display a full report or only the messages. -reports = false - -# Activate the evaluation score. -score = true - -[tool.pylint.similarities] -# Comments are removed from the similarity computation -ignore-comments = true - -# Docstrings are removed from the similarity computation -ignore-docstrings = true - -# Imports are removed from the similarity computation -ignore-imports = false - -# Signatures are removed from the similarity computation -ignore-signatures = true - -# Minimum lines number of a similarity. -min-similarity-lines = 4 - -[tool.pylint.spelling] -# Limits count of emitted suggestions for spelling mistakes. -max-spelling-suggestions = 4 - -# Spelling dictionary name. No available dictionaries : You need to install both -# the python package and the system dependency for enchant to work.. -# spelling-dict = - -# List of comma separated words that should be considered directives if they -# appear at the beginning of a comment and should not be checked. -spelling-ignore-comment-directives = "fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:" - -# List of comma separated words that should not be checked. -# spelling-ignore-words = - -# A path to a file that contains the private dictionary; one word per line. -# spelling-private-dict-file = - -# Tells whether to store unknown words to the private dictionary (see the -# --spelling-private-dict-file option) instead of raising a message. -spelling-store-unknown-words = false - -[tool.pylint.typecheck] -# List of decorators that produce context managers, such as -# contextlib.contextmanager. Add to this list to register other decorators that -# produce valid context managers. -contextmanager-decorators = ["contextlib.contextmanager"] - -# List of members which are set dynamically and missed by pylint inference -# system, and so shouldn't trigger E1101 when accessed. Python regular -# expressions are accepted. -# generated-members = - -# Tells whether missing members accessed in mixin class should be ignored. A -# class is considered mixin if its name matches the mixin-class-rgx option. -# Tells whether to warn about missing members when the owner of the attribute is -# inferred to be None. -ignore-none = true - -# This flag controls whether pylint should warn about no-member and similar -# checks whenever an opaque object is returned when inferring. The inference can -# return multiple potential results while evaluating a Python object, but some -# branches might not be evaluated, which results in partial inference. In that -# case, it might be useful to still emit no-member and other checks for the rest -# of the inferred objects. -ignore-on-opaque-inference = true - -# List of symbolic message names to ignore for Mixin members. -ignored-checks-for-mixins = ["no-member", "not-async-context-manager", "not-context-manager", "attribute-defined-outside-init"] - -# List of class names for which member attributes should not be checked (useful -# for classes with dynamically set attributes). This supports the use of -# qualified names. -ignored-classes = ["optparse.Values", "thread._local", "_thread._local"] - -# Show a hint with possible names when a member name was not found. The aspect of -# finding the hint is based on edit distance. -missing-member-hint = true - -# The minimum edit distance a name should have in order to be considered a -# similar match for a missing member name. -missing-member-hint-distance = 1 - -# The total number of similar names that should be taken in consideration when -# showing a hint for a missing member. -missing-member-max-choices = 1 - -# Regex pattern to define which classes are considered mixins. -mixin-class-rgx = ".*[Mm]ixin" - -# List of decorators that change the signature of a decorated function. -# signature-mutators = - -[tool.pylint.variables] -# List of additional names supposed to be defined in builtins. Remember that you -# should avoid defining new builtins when possible. -# additional-builtins = - -# Tells whether unused global variables should be treated as a violation. -allow-global-unused-variables = true - -# List of names allowed to shadow builtins -# allowed-redefined-builtins = - -# List of strings which can identify a callback function by name. A callback name -# must start or end with one of those strings. -callbacks = ["cb_", "_cb"] - -# A regular expression matching the name of dummy variables (i.e. expected to not -# be used). -dummy-variables-rgx = "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_" - -# Argument names that match this expression will be ignored. -ignored-argument-names = "_.*|^ignored_|^unused_" - -# Tells whether we should check for unused import in __init__ files. -# init-import = +[tool.ruff.lint.per-file-ignores] +"*/__init__.py" = ["D104", "F401"] +"tests/*" = ["D100", "D101", "D102", "D103"] -# List of qualified module names which can have objects that can redefine -# builtins. -redefining-builtins-modules = ["six.moves", "past.builtins", "future.builtins"] +[tool.ruff.lint.pydocstyle] +convention = "numpy" diff --git a/templates/design_module.py b/templates/design_module.py index b308113b..c2162113 100644 --- a/templates/design_module.py +++ b/templates/design_module.py @@ -1,23 +1,25 @@ +"""Provides information about what class or functionality is provided.""" + __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" __email__ = ["jake.nunemaker@nrel.gov"] +import math + from ORBIT.phases.design import DesignPhase class TemplateDesign(DesignPhase): - """Template Design Phase""" + """Template Design Phase.""" expected_config = { "required_input": "unit", - "optional_input": "unit, (optional, default: 'default')" + "optional_input": "unit, (optional, default: 'default')", } - output_config = { - "example_output": "unit" - } + output_config = {"example_output": "unit"} def __init__(self, config, **kwargs): """Creates an instance of `TemplateDesign`.""" @@ -45,9 +47,7 @@ def example_computation(self): def detailed_output(self): """Returns detailed output dictionary.""" - return { - "example_detailed_output": self.result - } + return {"example_detailed_output": self.result} @property def total_cost(self): @@ -60,14 +60,12 @@ def total_cost(self): def design_result(self): """Must match `self.output_config` structure.""" - return { - "example_output": self.result - } + return {"example_output": self.result} # === Annotated Example === class SparDesign(DesignPhase): - """Spar Design Module""" + """Spar Design Module.""" # The expected config tells ProjectManager what inputs are required to run # the module. If a input is optional (and has a default value), then flag @@ -75,18 +73,25 @@ class SparDesign(DesignPhase): # that ProjectManager doesn't raise a warning if doesn't find the input in # a project level config. expected_config = { - "site": {"depth": "m"}, # For common inputs that will be shared across many modules, - "plant": {"num_turbines": "int"}, # it's best to look up how the variable is named in existing modules - "turbine": {"turbine_rating": "MW"}, # so the user doesn't have to input the same thing twice. For example, avoid adding - # 'number_turbines' if 'num_turbines' is already used throughout ORBIT - - - - # Inputs can be grouped into dictionaries like the following: + "site": { + "depth": "m", + }, # For common inputs that will be shared across many modules, + "plant": { + "num_turbines": "int", + }, # look up how the variable is named in existing modules + "turbine": { + "turbine_rating": "MW", + }, # so the user doesn't have to input the same thing twice. For + # example, avoid adding 'number_turbines' if 'num_turbines' is already + # used throughout ORBIT Inputs can be grouped into dictionaries like + # the following: "spar_design": { - "stiffened_column_CR": "$/t (optional, default: 3120)", # I tend to group module specific cost rates - "tapered_column_CR": "$/t (optional, default: 4220)", # into dictionaries named after the component being considered - "ballast_material_CR": "$/t (optional, default: 100)", # eg. spar_design, gbf_design, etc. + # I tend to group module specific cost rates into dictionaries + # named after the component being considered eg. spar_design, + # gbf_design, etc. + "stiffened_column_CR": "$/t (optional, default: 3120)", + "tapered_column_CR": "$/t (optional, default: 4220)", + "ballast_material_CR": "$/t (optional, default: 100)", "secondary_steel_CR": "$/t (optional, default: 7250)", "towing_speed": "km/h (optional, default: 6)", }, @@ -97,12 +102,14 @@ class SparDesign(DesignPhase): # results are used as inputs to installation modules. As such, these output # names should match the input names of the respective installation module output_config = { - "substructure": { # Typically a design phase ouptuts a component design - "mass": "t", # grouped into a dictionary, eg. "substructure" dict to the left. + "substructure": { + # Typically a design phase ouptuts a component design grouped into + # a dictionary, eg. "substructure" dict to the left. + "mass": "t", "ballasted_mass": "t", "unit_cost": "USD", "towing_speed": "km/h", - } + }, } def __init__(self, config, **kwargs): @@ -113,21 +120,25 @@ def __init__(self, config, **kwargs): ---------- config : dict """ + # These first two lines are required in all modules. They initialize + # the library + config = self.initialize_library(config, **kwargs) - config = self.initialize_library(config, **kwargs) # These first two lines are required in all modules. They initialize the library - self.config = self.validate_config(config) # if it hasn't already been and validate the config against '.expected_config' from above - + # if it hasn't already been and validate the config against + # '.expected_config' from above + self.config = self.validate_config(config) - self._design = self.config.get("spar_design", {}) # Not required, but I often save module specific outputs to "_design" for later use - # If the "spar_design" sub dictionary isn't found, an empty one is returned to - # work with later methods. + # Not required, but I often save module specific outputs to "_design" + # for later use. If the "spar_design" sub dictionary isn't found, an + # empty one is returned to work with later methods. + self._design = self.config.get("spar_design", {}) self._outputs = {} def run(self): """ - This method is required. It is the method that ProjectManager will call - after initialization. Any calculations should be called from here and - the outputs should be stored. + Required method that ProjectManager will call after initialization. + Any calculations should be called from here and the outputs should be + stored. """ substructure = { @@ -142,8 +153,8 @@ def run(self): @property def stiffened_column_mass(self): """ - Calculates the mass of the stiffened column for a single spar in tonnes. - From original OffshoreBOS model. + Calculates the mass of the stiffened column for a single spar in + tonnes. From original OffshoreBOS model. """ # The following methods are examples of module specific calculations. @@ -152,36 +163,40 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating ** 2 + 0.02328 * depth * log(depth) + mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * math.log(depth) return mass @property def tapered_column_mass(self): """ - Calculates the mass of the atpered column for a single spar in tonnes. From original OffshoreBOS model. + Calculates the mass of the atpered column for a single spar in tonnes. + From original OffshoreBOS model. """ rating = self.config["turbine"]["turbine_rating"] - mass = 125.81 * log(rating) + 58.712 + mass = 125.81 * math.log(rating) + 58.712 return mass @property def stiffened_column_cost(self): """ - Calculates the cost of the stiffened column for a single spar. From original OffshoreBOS model. + Calculates the cost of the stiffened column for a single spar. From + original OffshoreBOS model. """ - cr = self._design.get("stiffened_column_CR", 3120) # This is how I typically handle outputs. This will look for the key in - # self._design, and return default value if it isn't found. + # This is how I typically handle outputs. This will look for the key in + # self._design, and return default value if it isn't found. + cr = self._design.get("stiffened_column_CR", 3120) return self.stiffened_column_mass * cr @property def tapered_column_cost(self): """ - Calculates the cost of the tapered column for a single spar. From original OffshoreBOS model. + Calculates the cost of the tapered column for a single spar. From + original OffshoreBOS model. """ cr = self._design.get("tapered_column_CR", 4220) @@ -190,18 +205,20 @@ def tapered_column_cost(self): @property def ballast_mass(self): """ - Calculates the ballast mass of a single spar. From original OffshoreBOS model. + Calculates the ballast mass of a single spar. From original OffshoreBOS + model. """ rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating ** 2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @property def ballast_cost(self): """ - Calculates the cost of ballast material for a single spar. From original OffshoreBOS model. + Calculates the cost of ballast material for a single spar. From + original OffshoreBOS model. """ cr = self._design.get("ballast_material_CR", 100) @@ -217,10 +234,10 @@ def secondary_steel_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = exp( + mass = math.exp( 3.58 - + 0.196 * (rating ** 0.5) * log(rating) - + 0.00001 * depth * log(depth) + + 0.196 * (rating**0.5) * math.log(rating) + + 0.00001 * depth * math.log(depth), ) return mass @@ -253,7 +270,10 @@ def ballasted_mass(self): @property def substructure_cost(self): - """Returns the total cost (including ballast) of the spar substructure.""" + """ + Returns the total cost (including ballast) of the + spar substructure. + """ return ( self.stiffened_column_cost @@ -300,7 +320,7 @@ def total_cost(self): # total project configuration. @property def design_result(self): - """Returns the result of `self.run()`""" + """Returns the result of `self.run()`.""" if not self._outputs: raise Exception("Has `SparDesign` been ran yet?") diff --git a/tests/api/test_wisdem_api.py b/tests/api/test_wisdem_api.py index e15c8156..f56d6e9f 100644 --- a/tests/api/test_wisdem_api.py +++ b/tests/api/test_wisdem_api.py @@ -1,4 +1,4 @@ -"""Tests for the Monopile Wisdem API""" +"""Tests for the Monopile Wisdem API.""" __author__ = ["Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -7,6 +7,7 @@ import openmdao.api as om + from ORBIT.api.wisdem import Orbit diff --git a/tests/conftest.py b/tests/conftest.py index a480e04e..6823cbc1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,7 +1,6 @@ """Shared pytest settings and fixtures.""" - -import os +from pathlib import Path import pytest from marmot import Environment @@ -17,8 +16,8 @@ def pytest_configure(): when required. """ - test_dir = os.path.split(os.path.abspath(__file__))[0] - pytest.library = os.path.join(test_dir, "data", "library") + test_dir = Path(__file__).resolve().parent + pytest.library = str(test_dir / "data" / "library") initialize_library(pytest.library) @@ -46,7 +45,8 @@ def feeder(): def cable_vessel(): specs = extract_library_specs( - "array_cable_install_vessel", "test_cable_lay_vessel" + "array_cable_install_vessel", + "test_cable_lay_vessel", ) return Vessel("Test Cable Vessel", specs) @@ -55,7 +55,8 @@ def cable_vessel(): def heavy_lift(): specs = extract_library_specs( - "oss_install_vessel", "test_heavy_lift_vessel" + "oss_install_vessel", + "test_heavy_lift_vessel", ) return Vessel("Test Heavy Vessel", specs) @@ -77,4 +78,4 @@ def simple_cable(): def tmp_yaml_del(): yield - os.remove("tmp.yaml") + Path("tmp.yaml").unlink() diff --git a/tests/core/test_environment.py b/tests/core/test_environment.py index 0ce94758..fbab5705 100644 --- a/tests/core/test_environment.py +++ b/tests/core/test_environment.py @@ -92,7 +92,7 @@ def test_interp(): assert "windspeed_20m" not in env.state.dtype.names constraints = {"waveheight": le(2), "windspeed_20m": le(10)} - valid = env._find_valid_constraints(**constraints) + _ = env._find_valid_constraints(**constraints) assert "windspeed_20m" in env.state.dtype.names assert (env.state["windspeed_10m"] < env.state["windspeed_20m"]).all() assert (env.state["windspeed_20m"] < env.state["windspeed_100m"]).all() @@ -103,7 +103,7 @@ def test_extrap(): assert "windspeed_120m" not in env.state.dtype.names constraints = {"waveheight": le(2), "windspeed_120m": le(10)} - valid = env._find_valid_constraints(**constraints) + _ = env._find_valid_constraints(**constraints) assert "windspeed_120m" in env.state.dtype.names assert (env.state["windspeed_120m"] > env.state["windspeed_100m"]).all() @@ -111,6 +111,6 @@ def test_extrap(): assert "windspeed_120m" not in env2.state.dtype.names constraints = {"waveheight": le(2), "windspeed_120m": le(10)} - valid = env2._find_valid_constraints(**constraints) + _ = env2._find_valid_constraints(**constraints) assert (env.state["windspeed_100m"] == env2.state["windspeed_100m"]).all() assert (env.state["windspeed_120m"] < env2.state["windspeed_120m"]).all() diff --git a/tests/core/test_library.py b/tests/core/test_library.py index 7320a9f6..24c253eb 100644 --- a/tests/core/test_library.py +++ b/tests/core/test_library.py @@ -72,4 +72,4 @@ def test_phase_specific_file_extraction(): bad_config["MonopileInstallation"]["wtiv"] = "missing_vessel" with pytest.raises(LibraryItemNotFoundError): - bad_project = ProjectManager(bad_config) + _ = ProjectManager(bad_config) diff --git a/tests/data/__init__.py b/tests/data/__init__.py index 12d1d092..4def0abd 100644 --- a/tests/data/__init__.py +++ b/tests/data/__init__.py @@ -3,12 +3,12 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -import os +from pathlib import Path import pandas as pd -DIR = os.path.split(__file__)[0] -_fp = os.path.join(DIR, "test_weather.csv") +DIR = Path(__file__).resolve().parent +_fp = DIR / "test_weather.csv" test_weather = ( pd.read_csv(_fp, parse_dates=["datetime"]) .set_index("datetime") diff --git a/tests/phases/design/test_array_system_design.py b/tests/phases/design/test_array_system_design.py index cd1ad5cd..feeab3f5 100644 --- a/tests/phases/design/test_array_system_design.py +++ b/tests/phases/design/test_array_system_design.py @@ -69,7 +69,7 @@ def test_cable_not_found(): @pytest.mark.parametrize( - "config,num_full_strings,num_partial_strings,num_turbines_full_string,num_turbines_partial_string", + "config,num_full_strings,num_partial_strings,num_turbines_full_string,num_turbines_partial_string", # noqa: E501 ( (config_full_ring, 10, 0, 4, 0), (config_partial_ring, 12, 1, 4, 1), diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index e3e972e2..eabab579 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -11,6 +11,7 @@ import numpy as np import pytest + from ORBIT.phases.design._cables import Cable, Plant cables = { diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 45e03155..fb4e3838 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -68,7 +68,10 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_detailed_design_length(): - """Ensure that the same # of output variables are used for a floating and fixed offshore substation.""" + """ + Ensure that the same # of output variables are used for a floating and + fixed offshore substation. + """ elect = ElectricalDesign(base) elect.run() @@ -102,7 +105,10 @@ def test_calc_substructure_mass_and_cost(): def test_calc_topside_mass_and_cost(): - """Test topside mass and cost for HVDC compared to HVDC-Monopole and HVDC-Bipole""" + """ + Test topside mass and cost for HVDC compared to HVDC-Monopole and + HVDC-Bipole. + """ elect = ElectricalDesign(base) elect.run() @@ -206,7 +212,7 @@ def test_dc_oss_kwargs(): def test_new_old_hvac_substation(): - """Temporary test until ElectricalDesign is merged with new release""" + """Temporary test until ElectricalDesign is merged with new release.""" config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} @@ -387,7 +393,8 @@ def test_total_cable_len_property(): cable_name = export.cable.name assert export.total_cable_length_by_type[cable_name] == pytest.approx( - export.total_length, abs=1e-10 + export.total_length, + abs=1e-10, ) diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index 1acfb9d8..fa5c76a5 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -89,7 +89,8 @@ def test_total_cable_len_property(): cable_name = export.cable.name assert export.total_cable_length_by_type[cable_name] == pytest.approx( - export.total_length, abs=1e-10 + export.total_length, + abs=1e-10, ) diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index bf0e7021..b726a50f 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -188,7 +188,7 @@ def test_custom_num_lines(): def test_new_old_semitaut_mooring_system(): - """Temporary test until we delete the SemiTaut_mooring_system""" + """Temporary test until we delete the SemiTaut_mooring_system.""" config = deepcopy(base) config["site"]["depth"] = 900.0 diff --git a/tests/phases/design/test_scour_protection_design.py b/tests/phases/design/test_scour_protection_design.py index 301e5894..98c50731 100644 --- a/tests/phases/design/test_scour_protection_design.py +++ b/tests/phases/design/test_scour_protection_design.py @@ -6,9 +6,6 @@ __email__ = "robert.hammond@nrel.gov" -from copy import deepcopy - -import numpy as np import pytest from ORBIT.phases.design import ScourProtectionDesign diff --git a/tests/phases/design/test_semisubmersible_design.py b/tests/phases/design/test_semisubmersible_design.py index 7c710fb9..2716d627 100644 --- a/tests/phases/design/test_semisubmersible_design.py +++ b/tests/phases/design/test_semisubmersible_design.py @@ -20,7 +20,8 @@ @pytest.mark.parametrize( - "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) + "depth,turbine_rating", + product(range(100, 1201, 200), range(3, 15, 1)), ) def test_parameter_sweep(depth, turbine_rating): diff --git a/tests/phases/design/test_spar_design.py b/tests/phases/design/test_spar_design.py index 393cf7c1..5db7d582 100644 --- a/tests/phases/design/test_spar_design.py +++ b/tests/phases/design/test_spar_design.py @@ -20,7 +20,8 @@ @pytest.mark.parametrize( - "depth,turbine_rating", product(range(100, 1201, 200), range(3, 15, 1)) + "depth,turbine_rating", + product(range(100, 1201, 200), range(3, 15, 1)), ) def test_parameter_sweep(depth, turbine_rating): diff --git a/tests/phases/install/cable_install/test_array_install.py b/tests/phases/install/cable_install/test_array_install.py index dc94153e..81c6ec3c 100644 --- a/tests/phases/install/cable_install/test_array_install.py +++ b/tests/phases/install/cable_install/test_array_install.py @@ -1,6 +1,4 @@ -""" -Testing framework for the `ArrayCableInstallation` class. -""" +"""Testing framework for the `ArrayCableInstallation` class.""" __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -12,6 +10,7 @@ import pandas as pd import pytest + from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs @@ -24,7 +23,9 @@ @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) def test_simulation_setup(config): sim = ArrayCableInstallation(config) @@ -32,7 +33,9 @@ def test_simulation_setup(config): @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) def test_vessel_initialization(config): sim = ArrayCableInstallation(config) @@ -44,10 +47,14 @@ def test_vessel_initialization(config): @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(config, weather): sim = ArrayCableInstallation(config, weather=weather) @@ -62,7 +69,7 @@ def test_for_complete_logging(config, weather): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).fillna(0.0).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/cable_install/test_cable_tasks.py b/tests/phases/install/cable_install/test_cable_tasks.py index 3ab42d15..c416afd5 100644 --- a/tests/phases/install/cable_install/test_cable_tasks.py +++ b/tests/phases/install/cable_install/test_cable_tasks.py @@ -1,6 +1,4 @@ -""" -Testing framework for common cable installation tasks. -""" +"""Testing framework for common cable installation tasks.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -14,7 +12,6 @@ from ORBIT.phases.install.cable_install.common import ( tow_plow, lay_cable, - bury_cable, prep_cable, pull_winch, lower_cable, diff --git a/tests/phases/install/cable_install/test_export_install.py b/tests/phases/install/cable_install/test_export_install.py index b509e060..044fe60f 100644 --- a/tests/phases/install/cable_install/test_export_install.py +++ b/tests/phases/install/cable_install/test_export_install.py @@ -1,6 +1,4 @@ -""" -Testing framework for the `ExportCableInstallation` class. -""" +"""Testing framework for the `ExportCableInstallation` class.""" __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -26,7 +24,9 @@ @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) def test_simulation_setup(config): sim = ExportCableInstallation(config) @@ -39,7 +39,9 @@ def test_simulation_setup(config): @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) def test_vessel_initialization(config): sim = ExportCableInstallation(config) @@ -51,10 +53,14 @@ def test_vessel_initialization(config): @pytest.mark.parametrize( - "config", (base_config, simul_config), ids=["separate", "simultaneous"] + "config", + (base_config, simul_config), + ids=["separate", "simultaneous"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(config, weather): sim = ExportCableInstallation(config, weather=weather) @@ -69,7 +75,7 @@ def test_for_complete_logging(config, weather): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).fillna(0.0).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output @@ -239,7 +245,7 @@ def test_kwargs_for_export_install_in_ProjectManager(): def test_deprecated_values(): - """Temporary test for deprecated values""" + """Temporary test for deprecated values.""" base = deepcopy(base_config) diff --git a/tests/phases/install/jacket_install/test_jacket_install.py b/tests/phases/install/jacket_install/test_jacket_install.py index 6811e631..f6eb7a52 100644 --- a/tests/phases/install/jacket_install/test_jacket_install.py +++ b/tests/phases/install/jacket_install/test_jacket_install.py @@ -11,7 +11,6 @@ import pandas as pd import pytest -from ORBIT import ProjectManager from tests.data import test_weather from ORBIT.core.library import extract_library_specs from ORBIT.core.defaults import process_times as pt @@ -71,7 +70,9 @@ def test_vessel_initialization(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(weather, config): @@ -86,7 +87,7 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/monopile_install/test_monopile_install.py b/tests/phases/install/monopile_install/test_monopile_install.py index 57538063..15fa3c42 100644 --- a/tests/phases/install/monopile_install/test_monopile_install.py +++ b/tests/phases/install/monopile_install/test_monopile_install.py @@ -71,7 +71,9 @@ def test_vessel_initialization(config): ids=["wtiv_only", "single_feeder", "multi_feeder"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(weather, config): @@ -86,7 +88,7 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output @@ -207,10 +209,10 @@ def test_grout_kwargs(): sim = MonopileInstallation(config_wtiv) sim.run() - assert "Bolt TP" in list([a["action"] for a in sim.env.actions]) + assert "Bolt TP" in [a["action"] for a in sim.env.actions] sim = MonopileInstallation(config_wtiv, tp_connection_type="grouted") sim.run() - assert "Pump TP Grout" in list([a["action"] for a in sim.env.actions]) - assert "Cure TP Grout" in list([a["action"] for a in sim.env.actions]) + assert "Pump TP Grout" in [a["action"] for a in sim.env.actions] + assert "Cure TP Grout" in [a["action"] for a in sim.env.actions] diff --git a/tests/phases/install/monopile_install/test_monopile_tasks.py b/tests/phases/install/monopile_install/test_monopile_tasks.py index bff023f5..c43b8aa0 100644 --- a/tests/phases/install/monopile_install/test_monopile_tasks.py +++ b/tests/phases/install/monopile_install/test_monopile_tasks.py @@ -1,6 +1,4 @@ -""" -Testing framework for common monopile installation tasks. -""" +"""Testing framework for common monopile installation tasks.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/tests/phases/install/mooring_install/test_mooring_install.py b/tests/phases/install/mooring_install/test_mooring_install.py index 116f7558..aabf1330 100644 --- a/tests/phases/install/mooring_install/test_mooring_install.py +++ b/tests/phases/install/mooring_install/test_mooring_install.py @@ -1,6 +1,4 @@ -""" -Testing framework for the `MooringSystemInstallation` class. -""" +"""Testing framework for the `MooringSystemInstallation` class.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -33,7 +31,9 @@ def test_simulation_creation(): @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_full_run_logging(weather): sim = MooringSystemInstallation(config, weather=weather) @@ -48,7 +48,7 @@ def test_full_run_logging(weather): assert (df.duration - df["shift"]).fillna(0.0).abs().max() < 1e-9 assert df[df.action == "Install Mooring Line"].shape[0] == lines - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/oss_install/test_oss_install.py b/tests/phases/install/oss_install/test_oss_install.py index be32be3d..bcbec6c9 100644 --- a/tests/phases/install/oss_install/test_oss_install.py +++ b/tests/phases/install/oss_install/test_oss_install.py @@ -19,7 +19,6 @@ FloatingSubstationInstallation, OffshoreSubstationInstallation, ) -from ORBIT.core.exceptions import MissingComponent config_single = extract_library_specs("config", "oss_install") config_floating = extract_library_specs("config", "floating_oss_install") @@ -66,8 +65,7 @@ def test_vessel_initialization(config): js = sim.oss_vessel._jacksys_specs dp = sim.oss_vessel._dp_specs - if not any([js, dp]): - assert False + assert any([js, dp]) for feeder in sim.feeders: assert feeder.storage @@ -79,7 +77,9 @@ def test_vessel_initialization(config): ids=["single_feeder", "multi_feeder"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(weather, config): @@ -95,13 +95,15 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).fillna(0.0).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging_floating(weather): diff --git a/tests/phases/install/oss_install/test_oss_tasks.py b/tests/phases/install/oss_install/test_oss_tasks.py index 67a28c40..c4152fe3 100644 --- a/tests/phases/install/oss_install/test_oss_tasks.py +++ b/tests/phases/install/oss_install/test_oss_tasks.py @@ -1,6 +1,4 @@ -""" -Testing framework for common oss installation tasks. -""" +"""Testing framework for common oss installation tasks.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/tests/phases/install/quayside_assembly_tow/test_common.py b/tests/phases/install/quayside_assembly_tow/test_common.py index 00fa2b4e..fc1801e0 100644 --- a/tests/phases/install/quayside_assembly_tow/test_common.py +++ b/tests/phases/install/quayside_assembly_tow/test_common.py @@ -1,4 +1,4 @@ -"""Tests for common infrastructure for quayside assembly tow-out simulations""" +"""Tests for the common infrastructure for the quayside assembly tow-out.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -59,12 +59,15 @@ def test_TurbineAssemblyLine(env, num, assigned): feed = WetStorage(env, capacity=float("inf")) target = WetStorage(env, capacity=float("inf")) - for i in assigned: + for _ in assigned: feed.put(0) for a in range(num): assembly = TurbineAssemblyLine( - feed, target, {"tower": {"sections": 1}}, a + 1 + feed, + target, + {"tower": {"sections": 1}}, + a + 1, ) env.register(assembly) assembly.start() @@ -106,7 +109,10 @@ def test_Sub_to_Turbine_assembly_interaction(env, sub_lines, turb_lines): for a in range(turb_lines): assembly = TurbineAssemblyLine( - feed, target, {"tower": {"sections": 1}}, a + 1 + feed, + target, + {"tower": {"sections": 1}}, + a + 1, ) env.register(assembly) assembly.start() diff --git a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py index 84c57b9d..d2dfce71 100644 --- a/tests/phases/install/quayside_assembly_tow/test_gravity_based.py +++ b/tests/phases/install/quayside_assembly_tow/test_gravity_based.py @@ -1,4 +1,4 @@ -"""Tests for the `GravityBasedInstallation` class and related infrastructure.""" +"""Tests for the `GravityBasedInstallation` class and infrastructure.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -38,7 +38,9 @@ def test_simulation_setup(): @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) @pytest.mark.parametrize("config", (config, no_supply)) def test_for_complete_logging(weather, config): @@ -54,7 +56,7 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/quayside_assembly_tow/test_moored.py b/tests/phases/install/quayside_assembly_tow/test_moored.py index 8f36ef4c..fffb807e 100644 --- a/tests/phases/install/quayside_assembly_tow/test_moored.py +++ b/tests/phases/install/quayside_assembly_tow/test_moored.py @@ -5,7 +5,6 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -import warnings from copy import deepcopy import pandas as pd @@ -19,11 +18,13 @@ no_supply = extract_library_specs("config", "moored_install_no_supply") multi_assembly = extract_library_specs( - "config", "moored_install_multi_assembly" + "config", + "moored_install_multi_assembly", ) multi_tow = extract_library_specs("config", "moored_install_multi_tow") multi_assembly_multi_tow = extract_library_specs( - "config", "moored_install_multi_assembly_multi_tow" + "config", + "moored_install_multi_assembly_multi_tow", ) @@ -55,7 +56,9 @@ def test_simulation_setup(config): @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) @pytest.mark.parametrize( "config", @@ -80,7 +83,7 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/scour_protection_install/test_scour_protection.py b/tests/phases/install/scour_protection_install/test_scour_protection.py index 85e372c7..8434b6ba 100644 --- a/tests/phases/install/scour_protection_install/test_scour_protection.py +++ b/tests/phases/install/scour_protection_install/test_scour_protection.py @@ -1,6 +1,4 @@ -""" -Testing framework for the `ScourProtectionInstallation` class. -""" +"""Testing framework for the `ScourProtectionInstallation` class.""" __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -34,7 +32,9 @@ def test_simulation_creation(): @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_full_run_logging(weather): sim = ScourProtectionInstallation(config, weather=weather) @@ -45,7 +45,7 @@ def test_full_run_logging(weather): assert (df.duration - df["shift"]).fillna(0.0).abs().max() < 1e-9 assert df[df.action == "Drop SP Material"].shape[0] == sim.num_turbines - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output diff --git a/tests/phases/install/test_install_phase.py b/tests/phases/install/test_install_phase.py index 6b600eb2..0d86e887 100644 --- a/tests/phases/install/test_install_phase.py +++ b/tests/phases/install/test_install_phase.py @@ -6,7 +6,6 @@ __email__ = "jake.nunemaker@nrel.gov" -import pandas as pd import pytest from marmot import Environment @@ -47,9 +46,9 @@ def setup_simulation(self): def test_abstract_methods(): with pytest.raises(TypeError): - install = BadInstallPhase(base_config) + _ = BadInstallPhase(base_config) - install = SampleInstallPhase(base_config) + _ = SampleInstallPhase(base_config) def test_run(): diff --git a/tests/phases/install/turbine_install/test_turbine_install.py b/tests/phases/install/turbine_install/test_turbine_install.py index 1124a792..876d68cf 100644 --- a/tests/phases/install/turbine_install/test_turbine_install.py +++ b/tests/phases/install/turbine_install/test_turbine_install.py @@ -19,7 +19,8 @@ config_wtiv = extract_library_specs("config", "turbine_install_wtiv") config_long_mobilize = extract_library_specs( - "config", "turbine_install_long_mobilize" + "config", + "turbine_install_long_mobilize", ) config_wtiv_feeder = extract_library_specs("config", "turbine_install_feeder") config_wtiv_multi_feeder = deepcopy(config_wtiv_feeder) @@ -67,8 +68,7 @@ def test_vessel_creation(config): js = sim.wtiv._jacksys_specs dp = sim.wtiv._dp_specs - if not any([js, dp]): - assert False + assert any([js, dp]) if config.get("feeder", None) is not None: assert len(sim.feeders) == config["num_feeders"] @@ -79,7 +79,8 @@ def test_vessel_creation(config): @pytest.mark.parametrize( - "config, expected", [(config_wtiv, 72), (config_long_mobilize, 14 * 24)] + "config, expected", + [(config_wtiv, 72), (config_long_mobilize, 14 * 24)], ) def test_vessel_mobilize(config, expected): @@ -96,7 +97,9 @@ def test_vessel_mobilize(config, expected): ids=["wtiv_only", "single_feeder", "multi_feeder", "floating"], ) @pytest.mark.parametrize( - "weather", (None, test_weather), ids=["no_weather", "test_weather"] + "weather", + (None, test_weather), + ids=["no_weather", "test_weather"], ) def test_for_complete_logging(weather, config): @@ -111,7 +114,7 @@ def test_for_complete_logging(weather, config): _df = _df.assign(shift=(_df["time"] - _df["time"].shift(1))) assert (_df["shift"] - _df["duration"]).abs().max() < 1e-9 - assert ~df["cost"].isnull().any() + assert ~df["cost"].isna().any() _ = sim.agent_efficiencies _ = sim.detailed_output @@ -255,8 +258,10 @@ def test_multiple_tower_sections(): def test_large_turbine_installation(): - """Test a library extracted 22MW turbine differs from the - project test config""" + """ + Tests that the library extracted 22MW turbine differs from the project + test config. + """ sim = TurbineInstallation(config_wtiv) sim.run() @@ -264,9 +269,9 @@ def test_large_turbine_installation(): sim_22 = TurbineInstallation(config_22mw) sim_22.run() - def count_component(list, component): + def count_component(component_list, component): - return sum(1 for i in list if i == component) + return sum(1 for i in component_list if i == component) assert sim.config != sim_22.config assert sim.capex_category == sim_22.capex_category @@ -277,11 +282,14 @@ def count_component(list, component): # sim has 1 Nacelle, 3 Blades, and 1 TowerSection # sim_22 has 1 Nacelle, 3 Blades, and 3 TowerSections assert count_component(sim.component_list, "Blade") == count_component( - sim_22.component_list, "Blade" + sim_22.component_list, + "Blade", ) assert count_component(sim.component_list, "Nacelle") == count_component( - sim_22.component_list, "Nacelle" + sim_22.component_list, + "Nacelle", ) assert count_component( - sim.component_list, "TowerSection" + sim.component_list, + "TowerSection", ) < count_component(sim_22.component_list, "TowerSection") diff --git a/tests/phases/install/turbine_install/test_turbine_tasks.py b/tests/phases/install/turbine_install/test_turbine_tasks.py index 055da73d..dcd75318 100644 --- a/tests/phases/install/turbine_install/test_turbine_tasks.py +++ b/tests/phases/install/turbine_install/test_turbine_tasks.py @@ -1,6 +1,4 @@ -""" -Testing framework for common turbine installation tasks. -""" +"""Testing framework for common turbine installation tasks.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" diff --git a/tests/test_config_management.py b/tests/test_config_management.py index f635f271..13a59cef 100644 --- a/tests/test_config_management.py +++ b/tests/test_config_management.py @@ -4,10 +4,6 @@ __email__ = "jake.nunemaker@nrel.gov" -import os - -import pytest - from ORBIT import ProjectManager, load_config, save_config from ORBIT.core.library import extract_library_specs diff --git a/tests/test_parametric.py b/tests/test_parametric.py index 4d73da75..b7ff561f 100644 --- a/tests/test_parametric.py +++ b/tests/test_parametric.py @@ -42,7 +42,10 @@ def test_weather(): without.run() weathered = ParametricManager( - complete_project, params, funcs, weather=weather_df + complete_project, + params, + funcs, + weather=weather_df, ) weathered.run() @@ -59,7 +62,10 @@ def test_individual_phase(): funcs = {"time": lambda phase: phase.total_phase_time} parametric = ParametricManager( - complete_project, params, funcs, module=TurbineInstallation + complete_project, + params, + funcs, + module=TurbineInstallation, ) parametric.run() df = parametric.results.set_index("site.distance") @@ -71,11 +77,14 @@ def test_bad_result_attribute(): funcs = {"result": lambda phase: phase.nonexistent_result} parametric = ParametricManager( - complete_project, params, funcs, module=TurbineInstallation + complete_project, + params, + funcs, + module=TurbineInstallation, ) parametric.run() df = parametric.results - assert df["result"].isnull().all() + assert df["result"].isna().all() def test_bad_result_structure(): @@ -83,7 +92,10 @@ def test_bad_result_structure(): funcs = {"result": "bos_capex"} parametric = ParametricManager( - complete_project, params, funcs, module=TurbineInstallation + complete_project, + params, + funcs, + module=TurbineInstallation, ) with pytest.raises(TypeError): @@ -95,7 +107,10 @@ def test_product_option(): params = {"site.distance": [20, 40, 60], "site.depth": [20, 40, 60]} parametric = ParametricManager( - complete_project, params, funcs, module=TurbineInstallation + complete_project, + params, + funcs, + module=TurbineInstallation, ) assert parametric.num_runs == 3 diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 113c2ac8..777f1680 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -4,15 +4,15 @@ __email__ = "jake.nunemaker@nrel.gov" +import datetime as dt from copy import deepcopy import pandas as pd -import datetime as dt import pytest from ORBIT import ProjectManager -from ORBIT.phases import InstallPhase, DesignPhase from tests.data import test_weather +from ORBIT.phases import DesignPhase, InstallPhase from ORBIT.manager import ProjectProgress from ORBIT.core.library import extract_library_specs from ORBIT.core.exceptions import ( @@ -27,7 +27,8 @@ config = extract_library_specs("config", "project_manager") complete_project = extract_library_specs("config", "complete_project") -### Top Level + +# Top Level @pytest.mark.parametrize("weather", (None, weather_df)) def test_complete_run(weather): @@ -40,7 +41,7 @@ def test_complete_run(weather): assert all(p in list(actions["phase"]) for p in phases) -### Module Integrations +# Module Integrations def test_for_required_phase_structure(): """ Automated integration test to verify that all classes listed in @@ -60,11 +61,9 @@ def test_for_required_phase_structure(): # TODO: Expand these tests -### Config Management +# Config Management def test_phase_specific_definitions(): - """ - Tests that phase specific information makes it to phase_config. - """ + """Tests that phase specific information makes it to phase_config.""" project = ProjectManager(config) @@ -82,9 +81,7 @@ def test_phase_specific_definitions(): def test_expected_config_merging(): - """ - Tests for merging of expected configs - """ + """Tests for merging of expected configs.""" config1 = { "site": {"distance": "float", "depth": "float"}, @@ -148,7 +145,7 @@ class SpecificTurbineInstallation(InstallPhase): assert TestProjectManager.find_key_match(f) is None -### Overlapping Install Phases +# Overlapping Install Phases def test_install_phase_start_parsing__dates(): config_mixed_starts = deepcopy(config) @@ -188,6 +185,7 @@ def test_install_phase_start_parsing__ints(): assert defined["MonopileInstallation"] == 0 assert defined["TurbineInstallation"] == 100 + @pytest.mark.parametrize("weather", (None, weather_df)) @pytest.mark.parametrize("defined", (0, "10/22/2009")) @pytest.mark.parametrize( @@ -198,9 +196,14 @@ def test_install_phase_start_parsing__ints(): ("days=1;hours=10", 34), ("weeks=1", 168), ("weeks=1;days=1;hours=10", 202), - ] + ], ) -def test_dependent_install_phases_fixed_amounts(weather, defined, amount_str, diff): +def test_dependent_install_phases_fixed_amounts( + weather, + defined, + amount_str, + diff, +): new = deepcopy(config) new["install_phases"] = { @@ -211,7 +214,10 @@ def test_dependent_install_phases_fixed_amounts(weather, defined, amount_str, di project = ProjectManager(new, weather=weather) project.run() - diff_calc = project.phase_starts["TurbineInstallation"] - project.phase_starts["MonopileInstallation"] + diff_calc = ( + project.phase_starts["TurbineInstallation"] + - project.phase_starts["MonopileInstallation"] + ) assert diff_calc == diff @@ -250,7 +256,10 @@ def test_dependent_install_phases_phase_dates(weather, defined, input_val): assert p in phase_dates for key in ["start", "end"]: - _ = dt.datetime.strptime(phase_dates[p][key], project.date_format_long) + _ = dt.datetime.strptime( + phase_dates[p][key], + project.date_format_long, + ) assert True @@ -282,11 +291,13 @@ def test_chained_dependencies(): @pytest.mark.parametrize( - "m_start, t_start", [(0, 0), (0, 100), (100, 100), (100, 200)] + "m_start, t_start", + [(0, 0), (0, 100), (100, 100), (100, 200)], ) def test_index_starts(m_start, t_start): """ - Tests functionality related to passing index starts into 'install_phases' sub-dict. + Tests functionality related to passing index starts into 'install_phases' + sub-dict. """ _target_diff = t_start - m_start @@ -356,6 +367,7 @@ def test_mixed_start_date_types(m_start, t_start): project = ProjectManager(config_with_defined_starts, weather_df) project.run() + def test_duplicate_phase_definitions(): config_with_duplicates = deepcopy(config) config_with_duplicates["MonopileInstallation_1"] = { @@ -410,7 +422,6 @@ class MonopileInstallation(InstallPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileInstallation) - # Bad name format class MonopileInstallation_Custom(InstallPhase): pass @@ -423,7 +434,10 @@ class CustomInstallPhase(InstallPhase): pass ProjectManager.register_install_phase(CustomInstallPhase) - assert ProjectManager.find_key_match("CustomInstallPhase") == CustomInstallPhase + assert ( + ProjectManager.find_key_match("CustomInstallPhase") + == CustomInstallPhase + ) def test_custom_design_phases(): @@ -449,7 +463,6 @@ class MonopileDesign(DesignPhase): with pytest.raises(ValueError): ProjectManager.register_install_phase(MonopileDesign) - # Bad name format class MonopileDesign_Custom(DesignPhase): pass @@ -462,9 +475,12 @@ class CustomDesignPhase(DesignPhase): pass ProjectManager.register_design_phase(CustomDesignPhase) - assert ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase + assert ( + ProjectManager.find_key_match("CustomDesignPhase") == CustomDesignPhase + ) + -### Design Phase Interactions +# Design Phase Interactions def test_design_phases(): config_with_design = deepcopy(config) @@ -489,7 +505,7 @@ def test_design_phases(): project.run() -### Outputs +# Outputs def test_resolve_project_capacity(): # Missing turbine rating @@ -570,7 +586,7 @@ def test_resolve_project_capacity(): _ = project6.config["plant"]["num_turbines"] -### Exceptions +# Exceptions def test_incomplete_config(): incomplete_config = deepcopy(config) @@ -705,10 +721,10 @@ def test_ProjectProgress_with_incomplete_project(): _ = project.progress.parse_logs("Turbine") with pytest.raises(ValueError): - project.progress.complete_export_system + _ = project.progress.complete_export_system with pytest.raises(ValueError): - project.progress.complete_array_strings + _ = project.progress.complete_array_strings def test_ProjectProgress_with_complete_project(): From 96c17294ae5aebc998e4e466bb80285110097252 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 8 Jul 2024 14:35:02 -0600 Subject: [PATCH 193/240] Updated spar design common_cost. --- ORBIT/core/defaults/common_costs.yaml | 27 ++++++++ ORBIT/phases/design/spar_design.py | 88 +++++++++++++++++---------- 2 files changed, 82 insertions(+), 33 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 2237a44d..8953d058 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -4,3 +4,30 @@ tp_steel_cost: 3000 # USD/t # Port properties port_cost_per_month: 2e6 # USD/month + +# Spar component cost rates +spar_design: + stiffened_column_CR: 3120 # USD/t + tapered_column_CR: 4220 # USD/t + ballast_material_CR: 100 # USD/t + secondary_steel_CR: 7250 # USD/t + +# Offshore substation component cost rates +offshore_design: + mpt_cost_rate: 12500 # USD/MW + topside_fab_cost_rate: 14500 # USD/t + topside_design_cost: 4.5e6 # USD + shunt_cost_rate: 35000 # USD/MW + switchgear_cost: 4e6 # USD/num_mpt + backup_gen_cost: 1e6 # USD + workspace_cost: 2e6 # USD + other_ancillary_cost: 3e6 # USD + topside_assembly_factor: 0.075 # % + oss_substructure_cost_rate: 3000 # USD/t + oss_pile_cost_rate: 0 # USD/t + +# Semisubmersible component cost rates +#stiffened_column_CR: 3120 # USD/t +truss_cost: 6250 # USD/t +heave_plate_CR: 6250 # USD/t +#secondary_steel_CR: 7250 # USD/t diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index 151e12b3..ef8c51a5 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -1,4 +1,4 @@ -"""Provides the `SparDesign` class (from OffshoreBOS).""" +"""Provides the `SparDesign` class.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" @@ -8,8 +8,17 @@ from numpy import exp, log +from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase +""" +[1] Maness et al. 2017, NREL Offshore Balance-of-System Model. +https://www.nrel.gov/docs/fy17osti/66874.pdf +""" + +if (spar_design_cost := common_costs.get("spar_design", None)) is None: + raise KeyError("No spar_design in common costs.") + class SparDesign(DesignPhase): """Spar Substructure Design.""" @@ -65,23 +74,22 @@ def run(self): @property def stiffened_column_mass(self): - """ - Calculates the mass of the stiffened column for a single spar in - tonnes. Source: original OffshoreBOS model. + """Calculates the mass of the stiffened column for a single spar + in tonnes [1]. """ rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] + mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) return mass @property def tapered_column_mass(self): - """ - Calculates the mass of the atpered column for a single spar in tonnes. - Source: original OffshoreBOS model. + """Calculates the mass of the tapered column for a single + spar in tonnes [1]. """ rating = self.config["turbine"]["turbine_rating"] @@ -92,51 +100,57 @@ def tapered_column_mass(self): @property def stiffened_column_cost(self): - """ - Calculates the cost of the stiffened column for a single spar. - Source: original OffshoreBOS model. + """Calculates the cost of the stiffened column for a single spar + [1]. """ - cr = self._design.get("stiffened_column_CR", 3120) + _key = "stiffened_column_CR" + if ( + cr := self._design.get(_key, spar_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.stiffened_column_mass * cr @property def tapered_column_cost(self): - """ - Calculates the cost of the tapered column for a single spar. - Source: original OffshoreBOS model. - """ + """Calculates the cost of the tapered column for a single spar [1].""" + + _key = "tapered_column_CR" + if ( + cr := self._design.get(_key, spar_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - cr = self._design.get("tapered_column_CR", 4220) return self.tapered_column_mass * cr @property def ballast_mass(self): - """ - Calculates the ballast mass of a single spar. - Source: original OffshoreBOS model. - """ + """Calculates the ballast mass of a single spar [1].""" rating = self.config["turbine"]["turbine_rating"] mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @property def ballast_cost(self): - """ - Calculates the cost of ballast material for a single spar. - Source: original OffshoreBOS model. - """ + """Calculates the cost of ballast material for a single spar [1].""" + + _key = "ballast_material_CR" + + if ( + cr := self._design.get(_key, spar_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - cr = self._design.get("ballast_material_CR", 100) return self.ballast_mass * cr @property def secondary_steel_mass(self): - """ - Calculates the mass of the required secondary steel for a single - spar. From original OffshoreBOS model. + """Calculates the mass of the required secondary steel for a single + spar [1]. """ rating = self.config["turbine"]["turbine_rating"] @@ -145,6 +159,7 @@ def secondary_steel_mass(self): mass = exp( 3.58 + 0.196 * (rating**0.5) * log(rating) + + 0.196 * (rating**0.5) * log(rating) + 0.00001 * depth * log(depth) ) @@ -152,12 +167,16 @@ def secondary_steel_mass(self): @property def secondary_steel_cost(self): + """Calculates the cost of the required secondary steel for a single + spar [1]. """ - Calculates the cost of the required secondary steel for a single - spar. For original OffshoreBOS model. - """ - cr = self._design.get("secondary_steel_CR", 7250) + _key = "secondary_steel_CR" + if ( + cr := self._design.get(_key, spar_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.secondary_steel_mass * cr @property @@ -178,7 +197,10 @@ def ballasted_mass(self): @property def substructure_cost(self): - """Returns the cost (including ballast) of the spar substructure.""" + """ + Returns the total cost (including ballast) of the spar + substructure. + """ return ( self.stiffened_column_cost From c83e6148ca83fb9f81cafd31187511d3ca993646 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 8 Jul 2024 14:42:05 -0600 Subject: [PATCH 194/240] Updated semisub design cost in common cost. --- ORBIT/core/defaults/common_costs.yaml | 9 +- .../phases/design/semi_submersible_design.py | 85 ++++++++++++------- 2 files changed, 60 insertions(+), 34 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 8953d058..9d669462 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -27,7 +27,8 @@ offshore_design: oss_pile_cost_rate: 0 # USD/t # Semisubmersible component cost rates -#stiffened_column_CR: 3120 # USD/t -truss_cost: 6250 # USD/t -heave_plate_CR: 6250 # USD/t -#secondary_steel_CR: 7250 # USD/t +semisubmersible_design: + stiffened_column_CR: 3120 # USD/t + truss_CR: 6250 # USD/t + heave_plate_CR: 6250 # USD/t + secondary_steel_CR: 7250 # USD/t diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index 23f0fd0c..cdb0f016 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -1,13 +1,23 @@ -"""Provides the `SemiSubmersibleDesign` class (from OffshoreBOS).""" +"""Provides the `SemiSubmersibleDesign` class.""" __author__ = "Jake Nunemaker" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" - +from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase +""" +[1] Maness et al. 2017, NREL Offshore Balance-of-System Model. +https://www.nrel.gov/docs/fy17osti/66874.pdf +""" + +if ( + semisub_design_cost := common_costs.get("semisubmersible_design", None) +) is None: + raise KeyError("No spar_design in common costs.") + class SemiSubmersibleDesign(DesignPhase): """Semi-Submersible Substructure Design.""" @@ -61,53 +71,60 @@ def run(self): @property def stiffened_column_mass(self): - """ - Calculates the mass of the stiffened column for a single - semi-submersible in tonnes. From original OffshoreBOS model. + """Calculates the mass of the stiffened column for a single + semi-submersible in tonnes [1]. """ rating = self.config["turbine"]["turbine_rating"] mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 + mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 return mass @property def stiffened_column_cost(self): + """Calculates the cost of the stiffened column for a single + semi-submersible [1]. """ - Calculates the cost of the stiffened column for a single - semi-submersible. From original OffshoreBOS model. - """ - cr = self._design.get("stiffened_column_CR", 3120) + _key = "stiffened_column_CR" + if ( + cr := self._design.get(_key, semisub_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.stiffened_column_mass * cr @property def truss_mass(self): - """ - Calculates the truss mass for a single semi-submersible in tonnes. From - original OffshoreBOS model. + """Calculates the truss mass for a single semi-submersible in tonnes + [1]. """ rating = self.config["turbine"]["turbine_rating"] mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 + mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 return mass @property def truss_cost(self): + """Calculates the cost of the truss for a signle semi-submerisble + [1]. """ - Calculates the cost of the truss for a signle semi-submerisble. From - original OffshoreBOS model. - """ - cr = self._design.get("truss_CR", 6250) + _key = "truss_CR" + if ( + cr := self._design.get(_key, semisub_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.truss_mass * cr @property def heave_plate_mass(self): - """ - Calculates the heave plate mass for a single semi-submersible in - tonnes. Source: original OffshoreBOS model. + """Calculates the heave plate mass for a single semi-submersible + in tonnes [1]. """ rating = self.config["turbine"]["turbine_rating"] @@ -117,34 +134,42 @@ def heave_plate_mass(self): @property def heave_plate_cost(self): + """Calculates the heave plate cost for a single semi-submersible + [1]. """ - Calculates the heave plate cost for a single semi-submersible. From - original OffshoreBOS model. - """ - cr = self._design.get("heave_plate_CR", 6250) + _key = "heave_plate_CR" + if ( + cr := self._design.get(_key, semisub_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.heave_plate_mass * cr @property def secondary_steel_mass(self): - """ - Calculates the mass of the required secondary steel for a single - semi-submersible. From original OffshoreBOS model. + """Calculates the mass of the required secondary steel for a single + semi-submersible [1]. """ rating = self.config["turbine"]["turbine_rating"] mass = -0.153 * rating**2 + 6.54 * rating + 128.34 + mass = -0.153 * rating**2 + 6.54 * rating + 128.34 return mass @property def secondary_steel_cost(self): + """Calculates the cost of the required secondary steel for a single + semi-submersible [1]. """ - Calculates the cost of the required secondary steel for a single - semi-submersible. For original OffshoreBOS model. - """ - cr = self._design.get("secondary_steel_CR", 7250) + _key = "secondary_steel_CR" + if ( + cr := self._design.get(_key, semisub_design_cost.get(_key, None)) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + return self.secondary_steel_mass * cr @property From 265702952b38a476518187e7dec021f9f656ca64 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Mon, 8 Jul 2024 14:46:33 -0600 Subject: [PATCH 195/240] Updated monopile design with common cost --- ORBIT/core/defaults/common_costs.yaml | 7 +++--- ORBIT/phases/design/monopile_design.py | 33 +++++++++++++------------- 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 9d669462..21dfb5ae 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -1,6 +1,7 @@ # Material costs -monopile_steel_cost: 3000 # USD/t -tp_steel_cost: 3000 # USD/t +monopile_design: + monopile_steel_cost: 3000 # USD/t + tp_steel_cost: 3000 # USD/t # Port properties port_cost_per_month: 2e6 # USD/month @@ -29,6 +30,6 @@ offshore_design: # Semisubmersible component cost rates semisubmersible_design: stiffened_column_CR: 3120 # USD/t - truss_CR: 6250 # USD/t + truss_CR: 6250 # USD/t heave_plate_CR: 6250 # USD/t secondary_steel_CR: 7250 # USD/t diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index 8fb33d62..ce26044a 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -13,6 +13,9 @@ from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase +if (monopile_design_cost := common_costs.get("monopile_design", None)) is None: + raise KeyError("No spar_design in common costs.") + class MonopileDesign(DesignPhase): """Monopile Design Class.""" @@ -75,6 +78,8 @@ def __init__(self, config, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) + self._design = self.config.get("monopile_design", {}) + self._outputs = {} def run(self): @@ -306,14 +311,13 @@ def total_tp_mass(self): def monopile_steel_cost(self): """Returns the cost of monopile steel (USD/t) fully fabricated.""" - _design = self.config.get("monopile_design", {}) _key = "monopile_steel_cost" - - try: - cost = _design.get(_key, common_costs[_key]) - - except KeyError as exc: - raise Exception("Cost of monopile steel not found.") from exc + if ( + cost := self._design.get( + _key, monopile_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") return cost @@ -321,16 +325,13 @@ def monopile_steel_cost(self): def tp_steel_cost(self): """Returns the cost of fabricated transition piece steel (USD/t).""" - _design = self.config.get("monopile_design", {}) _key = "tp_steel_cost" - - try: - cost = _design.get(_key, common_costs[_key]) - - except KeyError as exc: - raise Exception( - "Cost of transition piece steel not found." - ) from exc # noqa: E501 + if ( + cost := self._design.get( + _key, monopile_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") return cost From 158cf1b6e7f5243014a3b85ca48345688546ff6b Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 9 Jul 2024 09:49:58 -0600 Subject: [PATCH 196/240] Updated electrical_export and oss_design in common costs. --- ORBIT/core/defaults/common_costs.yaml | 22 +- ORBIT/phases/design/electrical_export.py | 302 +++++++++++++----- ORBIT/phases/design/monopile_design.py | 2 +- ORBIT/phases/design/oss_design.py | 114 +++++-- .../phases/design/semi_submersible_design.py | 2 +- ORBIT/phases/design/spar_design.py | 2 +- tests/phases/design/test_electrical_design.py | 74 +++-- 7 files changed, 387 insertions(+), 131 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 21dfb5ae..43f14a22 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -6,6 +6,10 @@ monopile_design: # Port properties port_cost_per_month: 2e6 # USD/month +# Export system component cost rates +export_system_design: + cable_crossings: + crossing_unit_cost: 500000 # Spar component cost rates spar_design: stiffened_column_CR: 3120 # USD/t @@ -14,19 +18,31 @@ spar_design: secondary_steel_CR: 7250 # USD/t # Offshore substation component cost rates -offshore_design: +substation_design: mpt_cost_rate: 12500 # USD/MW topside_fab_cost_rate: 14500 # USD/t - topside_design_cost: 4.5e6 # USD + topside_design_cost: # USD + #oldHVAC: 4.5e6 + HVAC: 107.3e6 + HVDC-monopole: 294e6 + HVDC-bipole: 476e6 shunt_cost_rate: 35000 # USD/MW - switchgear_cost: 4e6 # USD/num_mpt + mpt_unit_cost: 2.87e6 # USD/mpt + shunt_unit_cost: 1e4 # USD/cable + switchgear_cost: 4e6 # USD/cable + dc_breaker_cost: 10.5e6 # USD/cable backup_gen_cost: 1e6 # USD workspace_cost: 2e6 # USD other_ancillary_cost: 3e6 # USD topside_assembly_factor: 0.075 # % + converter_cost: # USD + HVAC: 0 + HVDC-monopole: 127e6 + HVDC-bipole: 296e6 oss_substructure_cost_rate: 3000 # USD/t oss_pile_cost_rate: 0 # USD/t + # Semisubmersible component cost rates semisubmersible_design: stiffened_column_CR: 3120 # USD/t diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index df0f7dcc..641733c3 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -9,8 +9,22 @@ import numpy as np +from ORBIT.core.defaults import common_costs from ORBIT.phases.design._cables import CableSystem +""" +[1] Maness et al. 2017, NREL Offshore Balance-of-System Model. +https://www.nrel.gov/docs/fy17osti/66874.pdf +""" + +if ( + export_design_cost := common_costs.get("export_system_design", None) +) is None: + raise KeyError("No export system in common costs.") + +if (oss_design_cost := common_costs.get("substation_design", None)) is None: + raise KeyError("No substation design in common costs.") + class ElectricalDesign(CableSystem): """ @@ -93,6 +107,7 @@ class ElectricalDesign(CableSystem): "cable_type": "str", }, }, + "offshore_substation": "dict, (optional)", } def __init__(self, config, **kwargs): @@ -106,11 +121,14 @@ def __init__(self, config, **kwargs): for name in self.expected_config["site"]: setattr(self, "".join(("_", name)), config["site"][name]) + self._depth = config["site"]["depth"] self._distance_to_landfall = config["site"]["distance_to_landfall"] self._plant_capacity = self.config["plant"]["capacity"] self._get_touchdown_distance() + self._design = self.config["export_system_design"] + _landfall = self.config.get("landfall", {}) if _landfall: warn( @@ -121,25 +139,18 @@ def __init__(self, config, **kwargs): ) else: - _landfall = self.config["export_system_design"].get("landfall", {}) + _landfall = self._design.get("landfall", {}) self._distance_to_interconnection = _landfall.get( "interconnection_distance", 3 ) - self.export_system_design = self.config["export_system_design"] - self.offshore_substation_design = self.config.get( - "substation_design", {} - ) + self._oss_design = self.config.get("substation_design", {}) - self.substructure_type = self.offshore_substation_design.get( + self.substructure_type = self._oss_design.get( "oss_substructure_type", "Monopile" ) - self.onshore_substation_design = self.config.get( - "onshore_substation_design", {} - ) - self._outputs = {} def run(self): @@ -187,6 +198,16 @@ def run(self): self.calc_dc_breaker_cost() self.calc_onshore_cost() + self._outputs["offshore_substation"] = { + "substation_mpt_cost": self.mpt_cost, + "substation_shunt_cost": self.shunt_reactor_cost, + "substation_switchgear_cost": self.switchgear_cost, + "substation_converter_cost": self.converter_cost, + "substation_breaker_cost": self.dc_breaker_cost, + "substation_ancillary_cost": self.ancillary_system_costs, + "substation_land_assembly_cost": self.land_assembly_cost, + } + self._outputs["offshore_substation_substructure"] = { "type": self.substructure_type, "deck_space": self.substructure_deck_space, @@ -221,6 +242,13 @@ def detailed_output(self): "substation_substructure_mass": self.substructure_mass, "substation_substructure_cost": self.substructure_cost, "total_substation_cost": self.total_substation_cost, + "substation_mpt_cost": self.mpt_cost, + "substation_shunt_cost": self.shunt_reactor_cost, + "substation_switchgear_cost": self.switchgear_cost, + "substation_converter_cost": self.converter_cost, + "substation_breaker_cost": self.dc_breaker_cost, + "substation_ancillary_cost": self.ancillary_system_costs, + "substation_land_assembly_cost": self.land_assembly_cost, "onshore_shunt_cost": self.onshore_shunt_reactor_cost, "onshore_converter_cost": self.onshore_converter_cost, "onshore_switchgear_cost": self.onshore_switchgear_cost, @@ -254,8 +282,6 @@ def compute_number_cables(self): num_redundant : int """ - _num_redundant = self._design.get("num_redundant", 0) - num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) @@ -320,12 +346,19 @@ def sections_cables(self): def calc_crossing_cost(self): """Compute cable crossing costs.""" - self._crossing_design = self.config["export_system_design"].get( - "cable_crossings", {} + _crossing_design = self._design.get("cable_crossings", {}) + + _key = "crossing_unit_cost" + if ( + crossing_cost := _crossing_design.get( + _key, export_design_cost["cable_crossings"].get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + self.crossing_cost = crossing_cost * _crossing_design.get( + "crossing_number", 0 ) - self.crossing_cost = self._crossing_design.get( - "crossing_unit_cost", 500000 - ) * self._crossing_design.get("crossing_number", 0) """SUBSTATION""" @@ -347,16 +380,16 @@ def calc_num_substations(self): """ # HVAC substation capacity - _substation_capacity = self.offshore_substation_design.get( + _substation_capacity = self._oss_design.get( "substation_capacity", 1200 ) # MW if "HVDC" in self.cable.cable_type: - self.num_substations = self.offshore_substation_design.get( + self.num_substations = self._oss_design.get( "num_substations", int(self.num_cables / 2) ) else: - self.num_substations = self.offshore_substation_design.get( + self.num_substations = self._oss_design.get( "num_substations", int(np.ceil(self._plant_capacity / _substation_capacity)), ) @@ -383,15 +416,19 @@ def calc_mpt_cost(self): mpt_unit_cost : int | float """ - _mpt_cost = self._design.get("mpt_unit_cost", 2.87e6) + _key = "mpt_unit_cost" + if ( + _mpt_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.num_mpt = self.num_cables - if "HVDC" in self.cable.cable_type: - self.mpt_cost = 0 - - else: - self.mpt_cost = self.num_mpt * _mpt_cost + self.mpt_cost = ( + 0 if "HVDC" in self.cable.cable_type else self.num_mpt * _mpt_cost + ) self.mpt_rating = ( round((self._plant_capacity * 1.15 / self.num_mpt) / 10.0) * 10.0 @@ -406,13 +443,21 @@ def calc_shunt_reactor_cost(self): """ touchdown = self.config["site"]["distance_to_landfall"] - shunt_unit_cost = self._design.get("shunt_unit_cost", 1e4) + + _key = "shunt_unit_cost" + if ( + shunt_unit_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") if "HVDC" in self.cable.cable_type: self.compensation = 0 else: for cable in self.cables.values(): self.compensation = touchdown * cable.compensation_factor # MW + self.shunt_reactor_cost = ( self.compensation * shunt_unit_cost * self.num_cables ) @@ -425,7 +470,13 @@ def calc_switchgear_costs(self): switchgear_cost : int | float """ - switchgear_cost = self._design.get("switchgear_cost", 4e6) + _key = "switchgear_cost" + if ( + switchgear_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") num_switchgear = ( 0 if "HVDC" in self.cable.cable_type else self.num_cables @@ -441,7 +492,13 @@ def calc_dc_breaker_cost(self): dc_breaker_cost : int | float """ - dc_breaker_cost = self._design.get("dc_breaker_cost", 10.5e6) + _key = "dc_breaker_cost" + if ( + dc_breaker_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") num_dc_breakers = ( self.num_cables if "HVDC" in self.cable.cable_type else 0 @@ -460,28 +517,33 @@ def calc_ancillary_system_cost(self): other_ancillary_cost : int | float """ - backup_gen_cost = self._design.get("backup_gen_cost", 1e6) - workspace_cost = self._design.get("workspace_cost", 2e6) - other_ancillary_cost = self._design.get("other_ancillary_cost", 3e6) - - self.ancillary_system_costs = ( - backup_gen_cost + workspace_cost + other_ancillary_cost - ) * self.num_substations - - def calc_converter_cost(self): - """Computes converter cost.""" + _key = "backup_gen_cost" + if ( + backup_gen_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - if self.cable.cable_type == "HVDC-monopole": - self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 127e6 + _key = "workspace_cost" + if ( + workspace_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - elif self.cable.cable_type == "HVDC-bipole": - self.converter_cost = self.num_substations * self._design.get( - "converter_cost", 296e6 + _key = "other_ancillary_cost" + if ( + other_ancillary_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) ) - else: - self.converter_cost = 0 + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + self.ancillary_system_costs = ( + backup_gen_cost + workspace_cost + other_ancillary_cost + ) * self.num_substations def calc_assembly_cost(self): """ @@ -492,9 +554,16 @@ def calc_assembly_cost(self): topside_assembly_factor : int | float """ - topside_assembly_factor = self.offshore_substation_design.get( - "topside_assembly_factor", 0.075 - ) + _key = "topside_assembly_factor" + if ( + topside_assembly_factor := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if topside_assembly_factor > 1.0: + topside_assembly_factor /= 100 self.land_assembly_cost = ( self.switchgear_cost @@ -502,9 +571,26 @@ def calc_assembly_cost(self): + self.ancillary_system_costs ) * topside_assembly_factor + def calc_converter_cost(self): + """Computes converter cost.""" + + _key = "converter_cost" + if ( + converter_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if isinstance(converter_cost, dict): + converter_cost = converter_cost[self.cable.cable_type] + + self.converter_cost = converter_cost + def calc_substructure_mass_and_cost(self): """ - Calculates the mass and associated cost of the substation substructure. + Calculates the mass and associated cost of the substation substructure + based on equations 81-84 [1]. Parameters ---------- @@ -512,26 +598,32 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate : int | float """ - oss_pile_cost_rate = self.offshore_substation_design.get( - "oss_pile_cost_rate", 0 - ) - oss_substructure_cost_rate = self.offshore_substation_design.get( - "oss_substructure_cost_rate", 3000 - ) + _key = "oss_substructure_cost_rate" + if ( + oss_substructure_cost_rate := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - # Substructure mass components calculated by curve fits in - # equations 81-84 from Maness et al. 2017 - # https://www.nrel.gov/docs/fy17osti/66874.pdf - # + _key = "oss_pile_cost_rate" + if ( + oss_pile_cost_rate := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + # Substructure mass components # TODO: Determine a better method to calculate substructure mass # for different substructure types substructure_mass = 0.4 * self.topside_mass - if self.substructure_type == "Floating": - substructure_pile_mass = 0 # No piles used for floating platform - - else: - substructure_pile_mass = 8 * substructure_mass**0.5574 + substructure_pile_mass = ( + 0 + if "Floating" in self.substructure_type + else 8 * substructure_mass**0.5574 + ) self.substructure_cost = ( substructure_mass * oss_substructure_cost_rate @@ -576,18 +668,23 @@ def calc_topside_mass_and_cost(self): topside_design_cost: int | float """ - _design = self.config.get("substation_design", {}) - self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations + 285 ) - if self.cable.cable_type == "HVDC-monopole": - self.topside_cost = _design.get("topside_design_cost", 294e6) - elif self.cable.cable_type == "HVDC-bipole": - self.topside_cost = _design.get("topside_design_cost", 476e6) - else: - self.topside_cost = _design.get("topside_design_cost", 107.3e6) + + _key = "topside_design_cost" + if ( + topside_design_cost := self._oss_design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if isinstance(topside_design_cost, dict): + topside_design_cost = topside_design_cost[self.cable.cable_type] + + self.topside_cost = topside_design_cost def calc_onshore_cost(self): """Minimum Cost of Onshore Substation Connection. @@ -601,16 +698,63 @@ def calc_onshore_cost(self): _design = self.config.get("onshore_substation_design", {}) - _shunt_unit_cost = _design.get("shunt_unit_cost", 1.3e4) # per cable - _switchgear_cost = _design.get("switchgear_cost", 9.33e6) # per cable - _compensation_rate = _design.get( - "compensation_rate", 31.3e6 - ) # per cable + if ( + onshore_design_cost := common_costs.get( + "onshore_substation_design", None + ) + ) is None: + raise KeyError("No onshore substation in common costs.") + + _key = "shunt_unit_cost" + if ( + _shunt_unit_cost := _design.get( + _key, onshore_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "switchgear_cost" + if ( + _switchgear_cost := _design.get( + _key, onshore_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "compensation_rate" + if ( + _compensation_rate := _design.get( + _key, onshore_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.onshore_shunt_reactor_cost = ( self.compensation * self.num_cables * _shunt_unit_cost ) + _key = "onshore_converter_cost" + if ( + _converter_cost := _design.get( + _key, onshore_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if isinstance(_converter_cost, dict): + _converter_cost = _converter_cost[self.cable_type.cable] + + _key = "onshore_construction_rate" + if ( + _construction_rate := _design.get( + _key, onshore_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if isinstance(_construction_rate, dict): + _construction_rate = _construction_rate[self.cable_type.cable] + if self.cable.cable_type == "HVDC-monopole": self.onshore_converter_cost = ( self.num_substations diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index ce26044a..de9a08dd 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -14,7 +14,7 @@ from ORBIT.phases.design import DesignPhase if (monopile_design_cost := common_costs.get("monopile_design", None)) is None: - raise KeyError("No spar_design in common costs.") + raise KeyError("No monopile design in common costs.") class MonopileDesign(DesignPhase): diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index 1c276550..e634192a 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -8,8 +8,12 @@ import numpy as np +from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase +if (oss_design_cost := common_costs.get("substation_design", None)) is None: + raise KeyError("No substation design in common costs.") + class OffshoreSubstationDesign(DesignPhase): """Offshore Substation Design Class.""" @@ -51,6 +55,8 @@ def __init__(self, config, **kwargs): config = self.initialize_library(config, **kwargs) self.config = self.validate_config(config) + self._design = self.config.get("substation_design", {}) + self._outputs = {} def run(self): @@ -143,13 +149,11 @@ def calc_num_mpt_and_rating(self): turbine_rating : float """ - _design = self.config.get("substation_design", {}) - num_turbines = self.config["plant"]["num_turbines"] turbine_rating = self.config["turbine"]["turbine_rating"] capacity = num_turbines * turbine_rating - self.num_substations = _design.get( + self.num_substations = self._design.get( "num_substations", int(np.ceil(capacity / 1200)) ) self.num_mpt = np.ceil( @@ -175,8 +179,13 @@ def calc_mpt_cost(self): mpt_cost_rate : float """ - _design = self.config.get("substation_design", {}) - mpt_cost_rate = _design.get("mpt_cost_rate", 12500) + _key = "mpt_cost_rate" + if ( + mpt_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.mpt_cost = self.mpt_rating * self.num_mpt * mpt_cost_rate @@ -190,9 +199,21 @@ def calc_topside_mass_and_cost(self): topside_design_cost: int | float """ - _design = self.config.get("substation_design", {}) - topside_fab_cost_rate = _design.get("topside_fab_cost_rate", 14500) - topside_design_cost = _design.get("topside_design_cost", 4.5e6) + _key = "topside_fab_cost_rate" + if ( + topside_fab_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "topside_design_cost" + if ( + topside_design_cost := self._design.get( + _key, oss_design_cost[_key].get("HVAC", None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.topside_mass = 3.85 * self.mpt_rating * self.num_mpt + 285 self.topside_cost = ( @@ -208,8 +229,13 @@ def calc_shunt_reactor_cost(self): shunt_cost_rate : int | float """ - _design = self.config.get("substation_design", {}) - shunt_cost_rate = _design.get("shunt_cost_rate", 35000) + _key = "shunt_cost_rate" + if ( + shunt_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.shunt_reactor_cost = ( self.mpt_rating * self.num_mpt * shunt_cost_rate * 0.5 @@ -224,10 +250,15 @@ def calc_switchgear_cost(self): switchgear_cost : int | float """ - _design = self.config.get("substation_design", {}) - switchgear_cost = _design.get("switchgear_cost", 4e6) + _key = "switchgear_cost" + if ( + switchgear_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") - self.switchgear_costs = self.num_mpt * switchgear_cost + self.switchgear_costs = self.num_mpt * switchgear_cost_rate def calc_ancillary_system_cost(self): """ @@ -240,10 +271,29 @@ def calc_ancillary_system_cost(self): other_ancillary_cost : int | float """ - _design = self.config.get("substation_design", {}) - backup_gen_cost = _design.get("backup_gen_cost", 1e6) - workspace_cost = _design.get("workspace_cost", 2e6) - other_ancillary_cost = _design.get("other_ancillary_cost", 3e6) + _key = "backup_gen_cost" + if ( + backup_gen_cost := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "workspace_cost" + if ( + workspace_cost := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "other_ancillary_cost" + if ( + other_ancillary_cost := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") self.ancillary_system_costs = ( backup_gen_cost + workspace_cost + other_ancillary_cost @@ -258,8 +308,14 @@ def calc_assembly_cost(self): topside_assembly_factor : int | float """ - _design = self.config.get("substation_design", {}) - topside_assembly_factor = _design.get("topside_assembly_factor", 0.075) + _key = "topside_assembly_factor" + if ( + topside_assembly_factor := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + self.land_assembly_cost = ( self.switchgear_costs + self.shunt_reactor_cost @@ -276,11 +332,21 @@ def calc_substructure_mass_and_cost(self): oss_pile_cost_rate : int | float """ - _design = self.config.get("substation_design", {}) - oss_substructure_cost_rate = _design.get( - "oss_substructure_cost_rate", 3000 - ) - oss_pile_cost_rate = _design.get("oss_pile_cost_rate", 0) + _key = "oss_substructure_cost_rate" + if ( + oss_substructure_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + _key = "oss_pile_cost_rate" + if ( + oss_pile_cost_rate := self._design.get( + _key, oss_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") substructure_mass = 0.4 * self.topside_mass substructure_pile_mass = 8 * substructure_mass**0.5574 diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index cdb0f016..c71a09ca 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -16,7 +16,7 @@ if ( semisub_design_cost := common_costs.get("semisubmersible_design", None) ) is None: - raise KeyError("No spar_design in common costs.") + raise KeyError("No semisub design in common costs.") class SemiSubmersibleDesign(DesignPhase): diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index ef8c51a5..e5371622 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -17,7 +17,7 @@ """ if (spar_design_cost := common_costs.get("spar_design", None)) is None: - raise KeyError("No spar_design in common costs.") + raise KeyError("No spar design in common costs.") class SparDesign(DesignPhase): diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index fb4e3838..e45e857a 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -68,9 +68,8 @@ def test_parameter_sweep(distance_to_landfall, depth, plant_cap, cable): def test_detailed_design_length(): - """ - Ensure that the same # of output variables are used for a floating and - fixed offshore substation. + """Ensure that the same # of output variables are used for a floating + and fixed offshore substation. """ elect = ElectricalDesign(base) @@ -104,32 +103,50 @@ def test_calc_substructure_mass_and_cost(): ) -def test_calc_topside_mass_and_cost(): - """ - Test topside mass and cost for HVDC compared to HVDC-Monopole and - HVDC-Bipole. - """ +"""def test_calc_topside_mass_and_cost(): + #Test topside mass and cost for HVDC compared to HVDC-Monopole and + #HVDC-Bipole. + # elect = ElectricalDesign(base) elect.run() - base_dc = deepcopy(base) - cables = ["HVDC_2000mm_320kV", "HVDC_2500mm_525kV"] + mono_dc = deepcopy(base) + mono_dc["export_system_design"]["cables"] = "HVDC_2000mm_320kV" + elect_mono = ElectricalDesign(mono_dc) + elect_mono.run() - for cable in cables: - base_dc["export_system_design"]["cables"] = cable + assert ( + elect.detailed_output["substation_topside_mass"] + == elect_mono.detailed_output["substation_topside_mass"] + ) + assert ( + elect.detailed_output["substation_topside_cost"] + != elect_mono.detailed_output["substation_topside_cost"] + ) - elect_dc = ElectricalDesign(base_dc) - elect_dc.run() + bi_dc = deepcopy(base) + bi_dc["export_system_design"]["cables"] = "HVDC_2500mm_525kV" + elect_bi = ElectricalDesign(bi_dc) + elect_bi.run() - assert ( - elect.detailed_output["substation_topside_mass"] - == elect_dc.detailed_output["substation_topside_mass"] - ) - assert ( - elect.detailed_output["substation_topside_cost"] - != elect_dc.detailed_output["substation_topside_cost"] - ) + assert ( + elect.detailed_output["substation_topside_mass"] + == elect_bi.detailed_output["substation_topside_mass"] + ) + assert ( + elect.detailed_output["substation_topside_cost"] + != elect_bi.detailed_output["substation_topside_cost"] + ) + + assert ( + elect_bi.detailed_output["substation_topside_mass"] + == elect_mono.detailed_output["substation_topside_mass"] + ) + assert ( + elect_bi.detailed_output["substation_topside_cost"] + != elect_mono.detailed_output["substation_topside_cost"] + )""" def test_oss_substructure_kwargs(): @@ -211,6 +228,19 @@ def test_dc_oss_kwargs(): assert cost != base_cost +def test_calc_topside_mass_and_cost(): + + config = deepcopy(base) + config["substation_design"]["topside_design_cost"] = 9999.9 + elec = ElectricalDesign(config) + elec.run() + + assert elec._outputs["num_substations"] == 1 + assert elec._outputs["offshore_substation_topside"][ + "unit_cost" + ] == pytest.approx(23673542.01, abs=1) + + def test_new_old_hvac_substation(): """Temporary test until ElectricalDesign is merged with new release.""" From a64980fc25ee093a34214ef98a7af2ab098bf616 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 9 Jul 2024 09:53:30 -0600 Subject: [PATCH 197/240] Fixed typos in electrical_export and updated common_cost. --- ORBIT/core/defaults/common_costs.yaml | 13 +++++++++++++ ORBIT/phases/design/electrical_export.py | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 43f14a22..8066a004 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -42,6 +42,19 @@ substation_design: oss_substructure_cost_rate: 3000 # USD/t oss_pile_cost_rate: 0 # USD/t +# Onshore substation component cost rates +onshore_substation_design: + shunt_unit_cost: 1.3e4 # USD/cable + switchgear_cost: 9.33e6 # USD/cable + compensation_rate: 31.3e6 # USD/cable + onshore_converter_cost: # USD + HVAC: 0 + HVDC-monopole: 157e6 + HVDC-bipole: 350e6 + onshore_construction_rate: # USD + HVAC: 5e6 + HVDC-monopole: 87.3e6 + HVDC-bipole: 100e6 # Semisubmersible component cost rates semisubmersible_design: diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 641733c3..2130d491 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -742,7 +742,7 @@ def calc_onshore_cost(self): raise KeyError(f"{_key} not found in common_costs.") if isinstance(_converter_cost, dict): - _converter_cost = _converter_cost[self.cable_type.cable] + _converter_cost = _converter_cost[self.cable.cable_type] _key = "onshore_construction_rate" if ( @@ -753,7 +753,7 @@ def calc_onshore_cost(self): raise KeyError(f"{_key} not found in common_costs.") if isinstance(_construction_rate, dict): - _construction_rate = _construction_rate[self.cable_type.cable] + _construction_rate = _construction_rate[self.cable.cable_type] if self.cable.cable_type == "HVDC-monopole": self.onshore_converter_cost = ( From 6902f39f41e274fffe63d39600bd242c2a09dde1 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 9 Jul 2024 10:55:37 -0600 Subject: [PATCH 198/240] Updated mooring system and common_cost. --- ORBIT/core/defaults/common_costs.yaml | 4 ++ ORBIT/phases/design/mooring_system_design.py | 40 ++++++++++++++------ 2 files changed, 33 insertions(+), 11 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 8066a004..18d470dd 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -62,3 +62,7 @@ semisubmersible_design: truss_CR: 6250 # USD/t heave_plate_CR: 6250 # USD/t secondary_steel_CR: 7250 # USD/t + +# Mooring system component cost rates +mooring_system_design: # USD/m + mooring_line_cost_rate: [399.0, 721.0, 1088.0] diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 7e703c99..9e63100a 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -12,8 +12,22 @@ from scipy.interpolate import interp1d +from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase +""" +[1] Maness et al. 2017, NREL Offshore Balance-of-System Model. +https://www.nrel.gov/docs/fy17osti/66874.pdf + +[2] Cooperman et al. (2022), Assessment of Offshore Wind Energy Leasing Areas +for Humboldt and Morry Bay. https://www.nrel.gov/docs/fy22osti/82341.pdf +""" + +if ( + mooring_design_cost := common_costs.get("mooring_system_design", None) +) is None: + raise KeyError("No mooring design in common costs.") + class MooringSystemDesign(DesignPhase): """Mooring System and Anchor Design.""" @@ -68,8 +82,7 @@ def __init__(self, config, **kwargs): self.anchor_type = self._design.get("anchor_type", "Suction Pile") self.mooring_type = self._design.get("mooring_type", "Catenary") - # Semi-Taut mooring system design parameters based on depth - # Cooperman et al. (2022), https://www.nrel.gov/docs/fy22osti/82341.pdf + # Semi-Taut mooring system design parameters based on depth [2]. self._semitaut_params = { "depths": [500.0, 750.0, 1000.0, 1250.0, 1500.0], "rope_lengths": [478.41, 830.34, 1229.98, 1183.93, 1079.62], @@ -108,26 +121,31 @@ def determine_mooring_line(self): tr = self.config["turbine"]["turbine_rating"] fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 + _key = "mooring_line_cost_rate" + if ( + mooring_line_cost_rate := self._design.get( + _key, mooring_design_cost.get(_key, None) + ) + ) is None: + raise KeyError(f"{_key} not found in common_costs.") + + if isinstance(mooring_line_cost_rate, (int, float)): + mooring_line_cost_rate = [mooring_line_cost_rate] * 3 + if fit <= 0.09: self.line_diam = 0.09 self.line_mass_per_m = 0.161 - self.line_cost_rate = self._design.get( - "mooring_line_cost_rate", 399.0 - ) + self.line_cost_rate = mooring_line_cost_rate[0] elif fit <= 0.12: self.line_diam = 0.12 self.line_mass_per_m = 0.288 - self.line_cost_rate = self._design.get( - "mooring_line_cost_rate", 721.0 - ) + self.line_cost_rate = mooring_line_cost_rate[1] else: self.line_diam = 0.15 self.line_mass_per_m = 0.450 - self.line_cost_rate = self._design.get( - "mooring_line_cost_rate", 1088.0 - ) + self.line_cost_rate = mooring_line_cost_rate[2] def calculate_breaking_load(self): """Returns the mooring line breaking load.""" From e672a1bfc3a965af4b27523284c2647d27e70a94 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 9 Jul 2024 17:02:36 -0600 Subject: [PATCH 199/240] Quick fix for #168, missing topside costs in substation system_capex --- ORBIT/phases/design/electrical_export.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index df0f7dcc..704d5177 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -195,10 +195,11 @@ def run(self): "unit_cost": self.substructure_cost, } + # TODO: cheap fix for topside unit_cost bug #168 self._outputs["offshore_substation_topside"] = { "deck_space": self.topside_deck_space, "mass": self.topside_mass, - "unit_cost": self.substation_cost, + "unit_cost": self.substation_cost + self.topside_cost, } self._outputs["num_substations"] = self.num_substations From 888982f25b81cec4a393383a9bd1c03fcd0c6edc Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 10 Jul 2024 09:27:27 -0600 Subject: [PATCH 200/240] formatting common_cost. --- ORBIT/core/defaults/common_costs.yaml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 18d470dd..8262b732 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -10,6 +10,7 @@ port_cost_per_month: 2e6 # USD/month export_system_design: cable_crossings: crossing_unit_cost: 500000 + # Spar component cost rates spar_design: stiffened_column_CR: 3120 # USD/t @@ -28,7 +29,7 @@ substation_design: HVDC-bipole: 476e6 shunt_cost_rate: 35000 # USD/MW mpt_unit_cost: 2.87e6 # USD/mpt - shunt_unit_cost: 1e4 # USD/cable + shunt_unit_cost: 10000 # USD/cable switchgear_cost: 4e6 # USD/cable dc_breaker_cost: 10.5e6 # USD/cable backup_gen_cost: 1e6 # USD @@ -44,7 +45,7 @@ substation_design: # Onshore substation component cost rates onshore_substation_design: - shunt_unit_cost: 1.3e4 # USD/cable + shunt_unit_cost: 13000 # USD/cable switchgear_cost: 9.33e6 # USD/cable compensation_rate: 31.3e6 # USD/cable onshore_converter_cost: # USD From a2c2101c9389d00cb9ffe1266937a256b671be47 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 10 Jul 2024 09:33:47 -0600 Subject: [PATCH 201/240] Updated electrical export test. --- tests/phases/design/test_electrical_design.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index e45e857a..100e0374 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -238,7 +238,7 @@ def test_calc_topside_mass_and_cost(): assert elec._outputs["num_substations"] == 1 assert elec._outputs["offshore_substation_topside"][ "unit_cost" - ] == pytest.approx(23673542.01, abs=1) + ] == pytest.approx(23673542, abs=1e2) def test_new_old_hvac_substation(): From d07a3b088d9d8fe4854bf2128976d74d4153fd73 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 10 Jul 2024 09:56:25 -0600 Subject: [PATCH 202/240] Updated test to fix F811 error. --- tests/phases/design/test_electrical_design.py | 30 ++++++++----------- 1 file changed, 12 insertions(+), 18 deletions(-) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 100e0374..916617e1 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -103,14 +103,21 @@ def test_calc_substructure_mass_and_cost(): ) -"""def test_calc_topside_mass_and_cost(): - #Test topside mass and cost for HVDC compared to HVDC-Monopole and - #HVDC-Bipole. +def test_calc_topside_mass_and_cost(): + # Test topside mass and cost for HVDC compared to HVDC-Monopole and + # HVDC-Bipole. # - elect = ElectricalDesign(base) + config = deepcopy(base) + config["substation_design"]["topside_design_cost"] = 9999.9 + elect = ElectricalDesign(config) elect.run() + assert elect._outputs["num_substations"] == 1 + assert elect._outputs["offshore_substation_topside"][ + "unit_cost" + ] == pytest.approx(23683541, abs=1e2) + mono_dc = deepcopy(base) mono_dc["export_system_design"]["cables"] = "HVDC_2000mm_320kV" elect_mono = ElectricalDesign(mono_dc) @@ -146,7 +153,7 @@ def test_calc_substructure_mass_and_cost(): assert ( elect_bi.detailed_output["substation_topside_cost"] != elect_mono.detailed_output["substation_topside_cost"] - )""" + ) def test_oss_substructure_kwargs(): @@ -228,19 +235,6 @@ def test_dc_oss_kwargs(): assert cost != base_cost -def test_calc_topside_mass_and_cost(): - - config = deepcopy(base) - config["substation_design"]["topside_design_cost"] = 9999.9 - elec = ElectricalDesign(config) - elec.run() - - assert elec._outputs["num_substations"] == 1 - assert elec._outputs["offshore_substation_topside"][ - "unit_cost" - ] == pytest.approx(23673542, abs=1e2) - - def test_new_old_hvac_substation(): """Temporary test until ElectricalDesign is merged with new release.""" From d5b7ad579ee6cd0496c4330fb3f9611dd11b76d3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 11 Jul 2024 13:38:07 -0600 Subject: [PATCH 203/240] Added general method to base for getting default cost --- ORBIT/phases/base.py | 32 ++++++++++++++++++++++++++++++ ORBIT/phases/design/spar_design.py | 10 ++++++---- 2 files changed, 38 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/base.py b/ORBIT/phases/base.py index 3e73b951..d63868ef 100644 --- a/ORBIT/phases/base.py +++ b/ORBIT/phases/base.py @@ -12,6 +12,7 @@ from benedict import benedict from ORBIT.core.library import initialize_library, extract_library_data +from ORBIT.core.defaults import common_costs from ORBIT.core.exceptions import MissingInputs @@ -117,6 +118,37 @@ def validate_config(self, config): else: return benedict(config) + def set_default_cost(self, design_name, key, subkey=None): + """Return the cost value for a key in a design + dictionary read from common_cost.yaml. + """ + + if (design_dict := common_costs.get(design_name, None)) is None: + raise KeyError(f"No {design_name} in common_cost.yaml.") + + # expected = deepcopy(getattr(self, "expected_config", None)) + # if expected is None: + # raise AttributeError(f"'expected_config' not set for '{self}'.") + # design_name = deepcopy(getattr(self, + # f"expected_config.{design_name}")) + + if (cost_value := design_dict.get(key, None)) is None: + raise KeyError( + f"{key} not found in [{design_name}] common_costs.yaml." + ) + + if isinstance(cost_value, dict): + if (sub_cost_value := cost_value.get(subkey, None)) is None: + raise KeyError( + f"{subkey} not found in [{design_name}][{cost_value}]" + " common_costs." + ) + + return sub_cost_value + + else: + return cost_value + @abstractmethod def run(self): """Main run function for phase.""" diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index e5371622..aa417bd4 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -105,10 +105,12 @@ def stiffened_column_cost(self): """ _key = "stiffened_column_CR" - if ( - cr := self._design.get(_key, spar_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cr = self._design.get(_key, self.set_default_cost("spar_design", _key)) + + # if ( + # cr := self._design.get(_key, spar_design_cost.get(_key, None)) + # ) is None: + # raise KeyError(f"{_key} not found in common_costs.") return self.stiffened_column_mass * cr From 5fe95dc35533656fe0e87d15d9bfda9e47793a0f Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 17 Jul 2024 13:56:15 -0600 Subject: [PATCH 204/240] Moved get_default_cost from base to design phase. Tested with spar_design module. --- ORBIT/phases/base.py | 32 ----------------------------- ORBIT/phases/design/design_phase.py | 30 +++++++++++++++++++++++++++ ORBIT/phases/design/spar_design.py | 27 ++++-------------------- 3 files changed, 34 insertions(+), 55 deletions(-) diff --git a/ORBIT/phases/base.py b/ORBIT/phases/base.py index d63868ef..3e73b951 100644 --- a/ORBIT/phases/base.py +++ b/ORBIT/phases/base.py @@ -12,7 +12,6 @@ from benedict import benedict from ORBIT.core.library import initialize_library, extract_library_data -from ORBIT.core.defaults import common_costs from ORBIT.core.exceptions import MissingInputs @@ -118,37 +117,6 @@ def validate_config(self, config): else: return benedict(config) - def set_default_cost(self, design_name, key, subkey=None): - """Return the cost value for a key in a design - dictionary read from common_cost.yaml. - """ - - if (design_dict := common_costs.get(design_name, None)) is None: - raise KeyError(f"No {design_name} in common_cost.yaml.") - - # expected = deepcopy(getattr(self, "expected_config", None)) - # if expected is None: - # raise AttributeError(f"'expected_config' not set for '{self}'.") - # design_name = deepcopy(getattr(self, - # f"expected_config.{design_name}")) - - if (cost_value := design_dict.get(key, None)) is None: - raise KeyError( - f"{key} not found in [{design_name}] common_costs.yaml." - ) - - if isinstance(cost_value, dict): - if (sub_cost_value := cost_value.get(subkey, None)) is None: - raise KeyError( - f"{subkey} not found in [{design_name}][{cost_value}]" - " common_costs." - ) - - return sub_cost_value - - else: - return cost_value - @abstractmethod def run(self): """Main run function for phase.""" diff --git a/ORBIT/phases/design/design_phase.py b/ORBIT/phases/design/design_phase.py index a27ba0b1..242f270a 100644 --- a/ORBIT/phases/design/design_phase.py +++ b/ORBIT/phases/design/design_phase.py @@ -9,6 +9,7 @@ from abc import abstractmethod from ORBIT.phases import BasePhase +from ORBIT.core.defaults import common_costs class DesignPhase(BasePhase): @@ -31,3 +32,32 @@ def design_result(self): """ return {} + + def get_default_cost(self, design_name, key, subkey=None): + """Return the cost value for a key in a design + dictionary read from common_cost.yaml. + """ + + if (design_dict := common_costs.get(design_name, None)) is None: + raise KeyError(f"No {design_name} in common_cost.yaml.") + + # expected = deepcopy(getattr(self, "expected_config", None)) + # if expected is None: + # raise AttributeError(f"'expected_config' not set for '{self}'.") + # design_name = deepcopy(getattr(self, + # f"expected_config.{design_name}")) + + if (cost_value := design_dict.get(key, None)) is None: + raise KeyError(f"{key} not found in [{design_name}] common_costs.") + + if isinstance(cost_value, dict): + if (sub_cost_value := cost_value.get(subkey, None)) is None: + raise KeyError( + f"{subkey} not found in [{design_name}][{cost_value}]" + " common_costs." + ) + + return sub_cost_value + + else: + return cost_value diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index aa417bd4..9f5856f5 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -8,7 +8,6 @@ from numpy import exp, log -from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase """ @@ -16,9 +15,6 @@ https://www.nrel.gov/docs/fy17osti/66874.pdf """ -if (spar_design_cost := common_costs.get("spar_design", None)) is None: - raise KeyError("No spar design in common costs.") - class SparDesign(DesignPhase): """Spar Substructure Design.""" @@ -105,12 +101,7 @@ def stiffened_column_cost(self): """ _key = "stiffened_column_CR" - cr = self._design.get(_key, self.set_default_cost("spar_design", _key)) - - # if ( - # cr := self._design.get(_key, spar_design_cost.get(_key, None)) - # ) is None: - # raise KeyError(f"{_key} not found in common_costs.") + cr = self._design.get(_key, self.get_default_cost("spar_design", _key)) return self.stiffened_column_mass * cr @@ -119,10 +110,7 @@ def tapered_column_cost(self): """Calculates the cost of the tapered column for a single spar [1].""" _key = "tapered_column_CR" - if ( - cr := self._design.get(_key, spar_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cr = self._design.get(_key, self.get_default_cost("spar_design", _key)) return self.tapered_column_mass * cr @@ -141,11 +129,7 @@ def ballast_cost(self): """Calculates the cost of ballast material for a single spar [1].""" _key = "ballast_material_CR" - - if ( - cr := self._design.get(_key, spar_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cr = self._design.get(_key, self.get_default_cost("spar_design", _key)) return self.ballast_mass * cr @@ -174,10 +158,7 @@ def secondary_steel_cost(self): """ _key = "secondary_steel_CR" - if ( - cr := self._design.get(_key, spar_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cr = self._design.get(_key, self.get_default_cost("spar_design", _key)) return self.secondary_steel_mass * cr From 5d2612d2750ec4c319b18f5777994bfb81dcce37 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 18 Jul 2024 16:11:52 -0600 Subject: [PATCH 205/240] Updated electrical_export with new get_default_cost method. --- ORBIT/core/defaults/common_costs.yaml | 9 +- ORBIT/phases/design/design_phase.py | 11 +- ORBIT/phases/design/electrical_export.py | 248 ++++++------------ tests/phases/design/test_electrical_design.py | 5 +- 4 files changed, 101 insertions(+), 172 deletions(-) diff --git a/ORBIT/core/defaults/common_costs.yaml b/ORBIT/core/defaults/common_costs.yaml index 8262b732..1e8e9867 100644 --- a/ORBIT/core/defaults/common_costs.yaml +++ b/ORBIT/core/defaults/common_costs.yaml @@ -45,13 +45,16 @@ substation_design: # Onshore substation component cost rates onshore_substation_design: - shunt_unit_cost: 13000 # USD/cable - switchgear_cost: 9.33e6 # USD/cable - compensation_rate: 31.3e6 # USD/cable onshore_converter_cost: # USD HVAC: 0 HVDC-monopole: 157e6 HVDC-bipole: 350e6 + shunt_unit_cost: 13000 # USD/cable + switchgear_cost: 9.33e6 # USD/cable + compensation_rate: # USD/cable + HVAC: 31.3e6 + HVDC-monopole: 0 + HVDC-bipole: 0 onshore_construction_rate: # USD HVAC: 5e6 HVDC-monopole: 87.3e6 diff --git a/ORBIT/phases/design/design_phase.py b/ORBIT/phases/design/design_phase.py index 242f270a..2cbdb6f4 100644 --- a/ORBIT/phases/design/design_phase.py +++ b/ORBIT/phases/design/design_phase.py @@ -41,16 +41,15 @@ def get_default_cost(self, design_name, key, subkey=None): if (design_dict := common_costs.get(design_name, None)) is None: raise KeyError(f"No {design_name} in common_cost.yaml.") - # expected = deepcopy(getattr(self, "expected_config", None)) - # if expected is None: - # raise AttributeError(f"'expected_config' not set for '{self}'.") - # design_name = deepcopy(getattr(self, - # f"expected_config.{design_name}")) - if (cost_value := design_dict.get(key, None)) is None: raise KeyError(f"{key} not found in [{design_name}] common_costs.") if isinstance(cost_value, dict): + if subkey is None: + raise ValueError( + f"{key} is a dictionary and requires a" " 'subkey' input." + ) + if (sub_cost_value := cost_value.get(subkey, None)) is None: raise KeyError( f"{subkey} not found in [{design_name}][{cost_value}]" diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 94ee1b35..225930f8 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -350,12 +350,12 @@ def calc_crossing_cost(self): _crossing_design = self._design.get("cable_crossings", {}) _key = "crossing_unit_cost" - if ( - crossing_cost := _crossing_design.get( - _key, export_design_cost["cable_crossings"].get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + crossing_cost = _crossing_design.get( + _key, + self.get_default_cost( + "export_system_design", "cable_crossings", subkey=_key + ), + ) self.crossing_cost = crossing_cost * _crossing_design.get( "crossing_number", 0 @@ -418,12 +418,9 @@ def calc_mpt_cost(self): """ _key = "mpt_unit_cost" - if ( - _mpt_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + _mpt_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.num_mpt = self.num_cables @@ -446,12 +443,10 @@ def calc_shunt_reactor_cost(self): touchdown = self.config["site"]["distance_to_landfall"] _key = "shunt_unit_cost" - if ( - shunt_unit_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + + shunt_unit_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) if "HVDC" in self.cable.cable_type: self.compensation = 0 @@ -472,12 +467,9 @@ def calc_switchgear_costs(self): """ _key = "switchgear_cost" - if ( - switchgear_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + switchgear_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) num_switchgear = ( 0 if "HVDC" in self.cable.cable_type else self.num_cables @@ -494,12 +486,9 @@ def calc_dc_breaker_cost(self): """ _key = "dc_breaker_cost" - if ( - dc_breaker_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + dc_breaker_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) num_dc_breakers = ( self.num_cables if "HVDC" in self.cable.cable_type else 0 @@ -519,28 +508,19 @@ def calc_ancillary_system_cost(self): """ _key = "backup_gen_cost" - if ( - backup_gen_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + backup_gen_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "workspace_cost" - if ( - workspace_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + workspace_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "other_ancillary_cost" - if ( - other_ancillary_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + other_ancillary_cost = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.ancillary_system_costs = ( backup_gen_cost + workspace_cost + other_ancillary_cost @@ -556,12 +536,9 @@ def calc_assembly_cost(self): """ _key = "topside_assembly_factor" - if ( - topside_assembly_factor := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + topside_assembly_factor = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) if topside_assembly_factor > 1.0: topside_assembly_factor /= 100 @@ -576,15 +553,12 @@ def calc_converter_cost(self): """Computes converter cost.""" _key = "converter_cost" - if ( - converter_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - - if isinstance(converter_cost, dict): - converter_cost = converter_cost[self.cable.cable_type] + converter_cost = self._oss_design.get( + _key, + self.get_default_cost( + "substation_design", _key, subkey=self.cable.cable_type + ), + ) self.converter_cost = converter_cost @@ -600,20 +574,14 @@ def calc_substructure_mass_and_cost(self): """ _key = "oss_substructure_cost_rate" - if ( - oss_substructure_cost_rate := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + oss_substructure_cost_rate = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "oss_pile_cost_rate" - if ( - oss_pile_cost_rate := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + oss_pile_cost_rate = self._oss_design.get( + _key, self.get_default_cost("substation_design", _key) + ) # Substructure mass components # TODO: Determine a better method to calculate substructure mass @@ -675,15 +643,12 @@ def calc_topside_mass_and_cost(self): ) _key = "topside_design_cost" - if ( - topside_design_cost := self._oss_design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - - if isinstance(topside_design_cost, dict): - topside_design_cost = topside_design_cost[self.cable.cable_type] + topside_design_cost = self._oss_design.get( + _key, + self.get_default_cost( + "substation_design", _key, subkey=self.cable.cable_type + ), + ) self.topside_cost = topside_design_cost @@ -699,95 +664,54 @@ def calc_onshore_cost(self): _design = self.config.get("onshore_substation_design", {}) - if ( - onshore_design_cost := common_costs.get( - "onshore_substation_design", None - ) - ) is None: - raise KeyError("No onshore substation in common costs.") + _key = "onshore_converter_cost" + _converter_cost = _design.get( + _key, + self.get_default_cost( + "onshore_substation_design", _key, subkey=self.cable.cable_type + ), + ) - _key = "shunt_unit_cost" - if ( - _shunt_unit_cost := _design.get( - _key, onshore_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + self.onshore_converter_cost = self.num_substations * _converter_cost _key = "switchgear_cost" - if ( - _switchgear_cost := _design.get( - _key, onshore_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - - _key = "compensation_rate" - if ( - _compensation_rate := _design.get( - _key, onshore_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - - self.onshore_shunt_reactor_cost = ( - self.compensation * self.num_cables * _shunt_unit_cost + _switchgear_cost = _design.get( + _key, self.get_default_cost("onshore_substation_design", _key) ) - _key = "onshore_converter_cost" - if ( - _converter_cost := _design.get( - _key, onshore_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - - if isinstance(_converter_cost, dict): - _converter_cost = _converter_cost[self.cable.cable_type] + self.onshore_switchgear_cost = self.num_cables * _switchgear_cost _key = "onshore_construction_rate" - if ( - _construction_rate := _design.get( - _key, onshore_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + _construction_rate = _design.get( + _key, + self.get_default_cost( + "onshore_substation_design", _key, subkey=self.cable.cable_type + ), + ) - if isinstance(_construction_rate, dict): - _construction_rate = _construction_rate[self.cable.cable_type] + self.onshore_construction = self.num_substations * _construction_rate - if self.cable.cable_type == "HVDC-monopole": - self.onshore_converter_cost = ( - self.num_substations - * self._design.get("onshore_converter_cost", 157e6) - ) - self.onshore_switchgear_cost = 0 - self.onshore_construction = self.num_substations * _design.get( - "onshore_construction_rate", 87.3e6 - ) - self.onshore_compensation_cost = 0 + _key = "shunt_unit_cost" + _shunt_unit_cost = _design.get( + _key, self.get_default_cost("onshore_substation_design", _key) + ) - elif self.cable.cable_type == "HVDC-bipole": - self.onshore_converter_cost = ( - self.num_substations - * self._design.get("onshore_converter_cost", 350e6) - ) - self.onshore_switchgear_cost = 0 - self.onshore_construction = self.num_substations * _design.get( - "onshore_construction_rate", 100e6 - ) - self.onshore_compensation_cost = 0 + self.onshore_shunt_reactor_cost = ( + self.compensation * self.num_cables * _shunt_unit_cost + ) - else: - self.onshore_converter_cost = 0 - self.onshore_switchgear_cost = self.num_cables * _switchgear_cost - self.onshore_construction = self.num_substations * _design.get( - "onshore_construction_rate", 5e6 - ) - self.onshore_compensation_cost = ( - self.num_cables * _compensation_rate - + self.onshore_shunt_reactor_cost - ) + _key = "compensation_rate" + _compensation_rate = _design.get( + _key, + self.get_default_cost( + "onshore_substation_design", _key, subkey=self.cable.cable_type + ), + ) + + self.onshore_compensation_cost = ( + self.num_cables * _compensation_rate + + self.onshore_shunt_reactor_cost + ) self.onshore_cost = ( self.onshore_converter_cost diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 916617e1..4d11bad7 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -290,18 +290,21 @@ def test_onshore_substation(): config = deepcopy(base) elect = ElectricalDesign(config) elect.run() + assert elect.onshore_compensation_cost != 0.0 assert elect.onshore_cost == pytest.approx(95.487e6, abs=1e2) # 109.32e6 config_mono = deepcopy(config) config_mono["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} o_monelect = ElectricalDesign(config_mono) o_monelect.run() - assert o_monelect.onshore_cost == 244.3e6 + assert o_monelect.onshore_compensation_cost == 0.0 + # assert o_monelect.onshore_cost == 244.3e6 config_bi = deepcopy(config) config_bi["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} o_bi = ElectricalDesign(config_bi) o_bi.run() + assert o_bi.onshore_compensation_cost == 0.0 assert o_bi.onshore_cost == 450e6 From 02fdade67034481184d7c3bf0ad6ac13b3b5cb9e Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 18 Jul 2024 16:29:22 -0600 Subject: [PATCH 206/240] Had to add and swap self.num_switchgear with self.num_cables. 0 switchgear for HVDC application --- ORBIT/phases/design/electrical_export.py | 13 ++++++++++--- tests/phases/design/test_electrical_design.py | 2 +- 2 files changed, 11 insertions(+), 4 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 225930f8..7f96ff70 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -471,11 +471,11 @@ def calc_switchgear_costs(self): _key, self.get_default_cost("substation_design", _key) ) - num_switchgear = ( + self.num_switchgear = ( 0 if "HVDC" in self.cable.cable_type else self.num_cables ) - self.switchgear_cost = num_switchgear * switchgear_cost + self.switchgear_cost = self.num_switchgear * switchgear_cost def calc_dc_breaker_cost(self): """Computes HVDC circuit breaker cost. Breaker cost is 0 for HVAC. @@ -679,7 +679,7 @@ def calc_onshore_cost(self): _key, self.get_default_cost("onshore_substation_design", _key) ) - self.onshore_switchgear_cost = self.num_cables * _switchgear_cost + self.onshore_switchgear_cost = self.num_switchgear * _switchgear_cost _key = "onshore_construction_rate" _construction_rate = _design.get( @@ -712,6 +712,13 @@ def calc_onshore_cost(self): self.num_cables * _compensation_rate + self.onshore_shunt_reactor_cost ) + print( + f"converter: {self.onshore_converter_cost}" + f" switchgear: {self.onshore_switchgear_cost}" + f"construction:{self.onshore_construction}" + f" compensation: {self.onshore_compensation_cost}" + f" mpt_cost:{self.mpt_cost}" + ) self.onshore_cost = ( self.onshore_converter_cost diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 4d11bad7..b9f61f01 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -298,7 +298,7 @@ def test_onshore_substation(): o_monelect = ElectricalDesign(config_mono) o_monelect.run() assert o_monelect.onshore_compensation_cost == 0.0 - # assert o_monelect.onshore_cost == 244.3e6 + assert o_monelect.onshore_cost == 244.3e6 config_bi = deepcopy(config) config_bi["export_system_design"] = {"cables": "HVDC_2500mm_525kV"} From 6bddc9e9e8b06d7f3bb4946accc857b3c732f3ff Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 18 Jul 2024 16:35:52 -0600 Subject: [PATCH 207/240] Updated monopile design with get_default_cost. --- ORBIT/phases/design/monopile_design.py | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index de9a08dd..84739571 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -312,12 +312,9 @@ def monopile_steel_cost(self): """Returns the cost of monopile steel (USD/t) fully fabricated.""" _key = "monopile_steel_cost" - if ( - cost := self._design.get( - _key, monopile_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cost = self._design.get( + _key, self.get_default_cost("monopile_design", _key) + ) return cost @@ -326,12 +323,9 @@ def tp_steel_cost(self): """Returns the cost of fabricated transition piece steel (USD/t).""" _key = "tp_steel_cost" - if ( - cost := self._design.get( - _key, monopile_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + cost = self._design.get( + _key, self.get_default_cost("monopile_design", _key) + ) return cost From 953c8ed72735f95e3dafe4dbb8597c164ff122d1 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Thu, 18 Jul 2024 17:12:59 -0600 Subject: [PATCH 208/240] Updating oss, monopile and mooring system with get_default_cost. Started added export_system output as expected input for oss_design. --- ORBIT/phases/design/monopile_design.py | 4 - ORBIT/phases/design/mooring_system_design.py | 23 ++-- ORBIT/phases/design/oss_design.py | 106 +++++++------------ tests/phases/design/test_oss_design.py | 2 + 4 files changed, 51 insertions(+), 84 deletions(-) diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index 84739571..459333b5 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -10,12 +10,8 @@ from scipy.optimize import fsolve -from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase -if (monopile_design_cost := common_costs.get("monopile_design", None)) is None: - raise KeyError("No monopile design in common costs.") - class MonopileDesign(DesignPhase): """Monopile Design Class.""" diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index 9e63100a..ff41c1d1 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -12,7 +12,6 @@ from scipy.interpolate import interp1d -from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase """ @@ -23,11 +22,6 @@ for Humboldt and Morry Bay. https://www.nrel.gov/docs/fy22osti/82341.pdf """ -if ( - mooring_design_cost := common_costs.get("mooring_system_design", None) -) is None: - raise KeyError("No mooring design in common costs.") - class MooringSystemDesign(DesignPhase): """Mooring System and Anchor Design.""" @@ -122,13 +116,14 @@ def determine_mooring_line(self): fit = -0.0004 * (tr**2) + 0.0132 * tr + 0.0536 _key = "mooring_line_cost_rate" - if ( - mooring_line_cost_rate := self._design.get( - _key, mooring_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + mooring_line_cost_rate = self._design.get( + _key, + self.get_default_cost( + "mooring_system_design", + _key, + ), + ) if isinstance(mooring_line_cost_rate, (int, float)): mooring_line_cost_rate = [mooring_line_cost_rate] * 3 @@ -232,8 +227,8 @@ def calculate_anchor_mass_cost(self): """ Returns the mass and cost of anchors. - TODO: Anchor masses are rough estimates based on initial literature - review. Should be revised when this module is overhauled in the future. + TODO: Anchor masses are rough estimates based on [1]. Should be + revised when this module is overhauled in the future. TODO: Mooring types for Catenary, TLP, SemiTaut will likely have different anchors. """ diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index e634192a..dc652b70 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -36,6 +36,12 @@ class OffshoreSubstationDesign(DesignPhase): "oss_pile_cost_rate": "USD/t (optional)", "num_substations": "int (optional)", }, + "export_system": { + "cable": { + "number": "int", + "cable_type": "str", + }, + }, } output_config = { @@ -180,12 +186,9 @@ def calc_mpt_cost(self): """ _key = "mpt_cost_rate" - if ( - mpt_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + mpt_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.mpt_cost = self.mpt_rating * self.num_mpt * mpt_cost_rate @@ -200,20 +203,15 @@ def calc_topside_mass_and_cost(self): """ _key = "topside_fab_cost_rate" - if ( - topside_fab_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + topside_fab_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "topside_design_cost" - if ( - topside_design_cost := self._design.get( - _key, oss_design_cost[_key].get("HVAC", None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + topside_design_cost = self._design.get( + _key, + self.get_default_cost("substation_design", _key, subkey="HVAC"), + ) self.topside_mass = 3.85 * self.mpt_rating * self.num_mpt + 285 self.topside_cost = ( @@ -230,12 +228,9 @@ def calc_shunt_reactor_cost(self): """ _key = "shunt_cost_rate" - if ( - shunt_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + shunt_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.shunt_reactor_cost = ( self.mpt_rating * self.num_mpt * shunt_cost_rate * 0.5 @@ -251,12 +246,9 @@ def calc_switchgear_cost(self): """ _key = "switchgear_cost" - if ( - switchgear_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + switchgear_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.switchgear_costs = self.num_mpt * switchgear_cost_rate @@ -272,28 +264,19 @@ def calc_ancillary_system_cost(self): """ _key = "backup_gen_cost" - if ( - backup_gen_cost := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + backup_gen_cost = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "workspace_cost" - if ( - workspace_cost := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + workspace_cost = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "other_ancillary_cost" - if ( - other_ancillary_cost := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + other_ancillary_cost = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.ancillary_system_costs = ( backup_gen_cost + workspace_cost + other_ancillary_cost @@ -309,12 +292,9 @@ def calc_assembly_cost(self): """ _key = "topside_assembly_factor" - if ( - topside_assembly_factor := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + topside_assembly_factor = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) self.land_assembly_cost = ( self.switchgear_costs @@ -333,20 +313,14 @@ def calc_substructure_mass_and_cost(self): """ _key = "oss_substructure_cost_rate" - if ( - oss_substructure_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + oss_substructure_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) _key = "oss_pile_cost_rate" - if ( - oss_pile_cost_rate := self._design.get( - _key, oss_design_cost.get(_key, None) - ) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") + oss_pile_cost_rate = self._design.get( + _key, self.get_default_cost("substation_design", _key) + ) substructure_mass = 0.4 * self.topside_mass substructure_pile_mass = 8 * substructure_mass**0.5574 diff --git a/tests/phases/design/test_oss_design.py b/tests/phases/design/test_oss_design.py index b6257e2d..9f3c0ba5 100644 --- a/tests/phases/design/test_oss_design.py +++ b/tests/phases/design/test_oss_design.py @@ -16,6 +16,7 @@ "plant": {"num_turbines": 50}, "turbine": {"turbine_rating": 6}, "substation_design": {}, + "export_system": {"cable": {"number": 3, "cable_type": "HVAC"}}, } @@ -30,6 +31,7 @@ def test_parameter_sweep(depth, num_turbines, turbine_rating): "plant": {"num_turbines": num_turbines}, "turbine": {"turbine_rating": turbine_rating}, "substation_design": {}, + "export_system": {"cable": {"number": 3, "cable_type": "HVAC"}}, } o = OffshoreSubstationDesign(config) From eeeb140d09f8d94bd9c71a36af978cd7ee818d12 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jul 2024 11:02:34 -0600 Subject: [PATCH 209/240] Updated semisub model with get_default_cost. cleaned up other files. --- ORBIT/phases/design/electrical_export.py | 16 -------- ORBIT/phases/design/oss_design.py | 4 -- .../phases/design/semi_submersible_design.py | 38 ++++++------------- tests/phases/design/test_electrical_design.py | 2 + 4 files changed, 14 insertions(+), 46 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 7f96ff70..f0e188e7 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -9,7 +9,6 @@ import numpy as np -from ORBIT.core.defaults import common_costs from ORBIT.phases.design._cables import CableSystem """ @@ -17,14 +16,6 @@ https://www.nrel.gov/docs/fy17osti/66874.pdf """ -if ( - export_design_cost := common_costs.get("export_system_design", None) -) is None: - raise KeyError("No export system in common costs.") - -if (oss_design_cost := common_costs.get("substation_design", None)) is None: - raise KeyError("No substation design in common costs.") - class ElectricalDesign(CableSystem): """ @@ -712,13 +703,6 @@ def calc_onshore_cost(self): self.num_cables * _compensation_rate + self.onshore_shunt_reactor_cost ) - print( - f"converter: {self.onshore_converter_cost}" - f" switchgear: {self.onshore_switchgear_cost}" - f"construction:{self.onshore_construction}" - f" compensation: {self.onshore_compensation_cost}" - f" mpt_cost:{self.mpt_cost}" - ) self.onshore_cost = ( self.onshore_converter_cost diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index dc652b70..08b8c3e9 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -8,12 +8,8 @@ import numpy as np -from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase -if (oss_design_cost := common_costs.get("substation_design", None)) is None: - raise KeyError("No substation design in common costs.") - class OffshoreSubstationDesign(DesignPhase): """Offshore Substation Design Class.""" diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index c71a09ca..1f6c6c8a 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -5,7 +5,6 @@ __maintainer__ = "Jake Nunemaker" __email__ = "jake.nunemaker@nrel.gov" -from ORBIT.core.defaults import common_costs from ORBIT.phases.design import DesignPhase """ @@ -13,11 +12,6 @@ https://www.nrel.gov/docs/fy17osti/66874.pdf """ -if ( - semisub_design_cost := common_costs.get("semisubmersible_design", None) -) is None: - raise KeyError("No semisub design in common costs.") - class SemiSubmersibleDesign(DesignPhase): """Semi-Submersible Substructure Design.""" @@ -88,11 +82,9 @@ def stiffened_column_cost(self): """ _key = "stiffened_column_CR" - if ( - cr := self._design.get(_key, semisub_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - + cr = self._design.get( + _key, self.get_default_cost("semisubmersible_design", _key) + ) return self.stiffened_column_mass * cr @property @@ -114,11 +106,9 @@ def truss_cost(self): """ _key = "truss_CR" - if ( - cr := self._design.get(_key, semisub_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - + cr = self._design.get( + _key, self.get_default_cost("semisubmersible_design", _key) + ) return self.truss_mass * cr @property @@ -139,11 +129,9 @@ def heave_plate_cost(self): """ _key = "heave_plate_CR" - if ( - cr := self._design.get(_key, semisub_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - + cr = self._design.get( + _key, self.get_default_cost("semisubmersible_design", _key) + ) return self.heave_plate_mass * cr @property @@ -165,11 +153,9 @@ def secondary_steel_cost(self): """ _key = "secondary_steel_CR" - if ( - cr := self._design.get(_key, semisub_design_cost.get(_key, None)) - ) is None: - raise KeyError(f"{_key} not found in common_costs.") - + cr = self._design.get( + _key, self.get_default_cost("semisubmersible_design", _key) + ) return self.secondary_steel_mass * cr @property diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index b9f61f01..2854b934 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -244,6 +244,8 @@ def test_new_old_hvac_substation(): config["plant"]["num_turbines"] = 200 config["turbine"] = {"turbine_rating": 5} + config["export_system"] = {"cable": {"number": 5, "cable_type": "HVAC"}} + new = ElectricalDesign(config) new.run() From 55e7205c7049de3031711c5af0605645536b5b14 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 19 Jul 2024 11:48:21 -0600 Subject: [PATCH 210/240] Removed export_system from oss_design config temporarily. --- ORBIT/phases/design/oss_design.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/ORBIT/phases/design/oss_design.py b/ORBIT/phases/design/oss_design.py index 08b8c3e9..9418e2fc 100644 --- a/ORBIT/phases/design/oss_design.py +++ b/ORBIT/phases/design/oss_design.py @@ -32,12 +32,12 @@ class OffshoreSubstationDesign(DesignPhase): "oss_pile_cost_rate": "USD/t (optional)", "num_substations": "int (optional)", }, - "export_system": { - "cable": { - "number": "int", - "cable_type": "str", - }, - }, + # "export_system": { + # "cable": { + # "number": "int", + # "cable_type": "str", + # }, + # }, } output_config = { From d13c270b22059ed5d7651dee42e31a7484672471 Mon Sep 17 00:00:00 2001 From: Shields Date: Wed, 31 Jul 2024 10:31:49 -0400 Subject: [PATCH 211/240] Updated monopile design load factor --- ORBIT/phases/design/monopile_design.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/ORBIT/phases/design/monopile_design.py b/ORBIT/phases/design/monopile_design.py index 8fb33d62..09c565ee 100644 --- a/ORBIT/phases/design/monopile_design.py +++ b/ORBIT/phases/design/monopile_design.py @@ -487,8 +487,7 @@ def calculate_50year_wind_moment( Rated windspeed of turbine (m/s). load_factor : float Added safety factor on the extreme wind moment. - Default: 3.375 (2.5x DNV standard as this model - does not design for buckling or fatigue) + Default: 1.3 (approximately matches DNV standard) Returns ------- @@ -496,7 +495,7 @@ def calculate_50year_wind_moment( 50 year extreme wind moment (N-m). """ - load_factor = kwargs.get("load_factor", 3.375) + load_factor = kwargs.get("load_factor", 1.3) F_50y = self.calculate_50year_wind_load( mean_windspeed=mean_windspeed, From 9e9abb63bbcf04219d436c3c4fbc84f6a76a43bb Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 31 Jul 2024 13:14:22 -0600 Subject: [PATCH 212/240] Addressed doc string items and duplicate mass calculations. --- ORBIT/phases/design/design_phase.py | 2 +- ORBIT/phases/design/electrical_export.py | 75 +++---------------- .../phases/design/semi_submersible_design.py | 7 +- ORBIT/phases/design/spar_design.py | 4 +- 4 files changed, 16 insertions(+), 72 deletions(-) diff --git a/ORBIT/phases/design/design_phase.py b/ORBIT/phases/design/design_phase.py index 2cbdb6f4..acf7b829 100644 --- a/ORBIT/phases/design/design_phase.py +++ b/ORBIT/phases/design/design_phase.py @@ -47,7 +47,7 @@ def get_default_cost(self, design_name, key, subkey=None): if isinstance(cost_value, dict): if subkey is None: raise ValueError( - f"{key} is a dictionary and requires a" " 'subkey' input." + f"{key} is a dictionary and requires a 'subkey' input." ) if (sub_cost_value := cost_value.get(subkey, None)) is None: diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index f0e188e7..2ca34bfe 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -269,9 +269,6 @@ def compute_number_cables(self): Calculate the total number of required and redundant cables to transmit power to the onshore interconnection. - Parameters - ---------- - num_redundant : int """ num_required = np.ceil(self._plant_capacity / self.cable.cable_power) @@ -365,10 +362,6 @@ def total_substation_cost(self): def calc_num_substations(self): """Computes number of substations based on HVDC or HVAC export cables. - - Parameters - ---------- - substation_capacity : int | float """ # HVAC substation capacity @@ -401,11 +394,8 @@ def substation_cost(self): ) / self.num_substations def calc_mpt_cost(self): - """Computes HVAC main power transformer (MPT). MPT cost is 0 for HVDC. - - Parameters - ---------- - mpt_unit_cost : int | float + """Computes HVAC main power transformer (MPT). MPT cost is 0 for + HVDC. """ _key = "mpt_unit_cost" @@ -424,11 +414,8 @@ def calc_mpt_cost(self): ) def calc_shunt_reactor_cost(self): - """Computes HVAC shunt reactor cost. Shunt reactor cost is 0 for HVDC. - - Parameters - ---------- - shunt_unit_cost : int | float + """Computes HVAC shunt reactor cost. Shunt reactor cost is 0 for + HVDC. """ touchdown = self.config["site"]["distance_to_landfall"] @@ -450,12 +437,7 @@ def calc_shunt_reactor_cost(self): ) def calc_switchgear_costs(self): - """Computes HVAC switchgear cost. Switchgear cost is 0 for HVDC. - - Parameters - ---------- - switchgear_cost : int | float - """ + """Computes HVAC switchgear cost. Switchgear cost is 0 for HVDC.""" _key = "switchgear_cost" switchgear_cost = self._oss_design.get( @@ -469,12 +451,7 @@ def calc_switchgear_costs(self): self.switchgear_cost = self.num_switchgear * switchgear_cost def calc_dc_breaker_cost(self): - """Computes HVDC circuit breaker cost. Breaker cost is 0 for HVAC. - - Parameters - ---------- - dc_breaker_cost : int | float - """ + """Computes HVDC circuit breaker cost. Breaker cost is 0 for HVAC.""" _key = "dc_breaker_cost" dc_breaker_cost = self._oss_design.get( @@ -488,15 +465,7 @@ def calc_dc_breaker_cost(self): self.dc_breaker_cost = num_dc_breakers * dc_breaker_cost def calc_ancillary_system_cost(self): - """ - Calculates cost of ancillary systems. - - Parameters - ---------- - backup_gen_cost : int | float - workspace_cost : int | float - other_ancillary_cost : int | float - """ + """Calculates cost of ancillary systems.""" _key = "backup_gen_cost" backup_gen_cost = self._oss_design.get( @@ -518,13 +487,7 @@ def calc_ancillary_system_cost(self): ) * self.num_substations def calc_assembly_cost(self): - """ - Calculates the cost of assembly on land. - - Parameters - ---------- - topside_assembly_factor : int | float - """ + """Calculates the cost of assembly on land.""" _key = "topside_assembly_factor" topside_assembly_factor = self._oss_design.get( @@ -557,11 +520,6 @@ def calc_substructure_mass_and_cost(self): """ Calculates the mass and associated cost of the substation substructure based on equations 81-84 [1]. - - Parameters - ---------- - oss_substructure_cost_rate : int | float - oss_pile_cost_rate : int | float """ _key = "oss_substructure_cost_rate" @@ -620,13 +578,7 @@ def calc_topside_deck_space(self): self.topside_deck_space = 1 def calc_topside_mass_and_cost(self): - """ - Calculates the mass and cost of the substation topsides. - - Parameters - ---------- - topside_design_cost: int | float - """ + """Calculates the mass and cost of the substation topsides.""" self.topside_mass = ( 3.85 * (self.mpt_rating * self.num_mpt) / self.num_substations @@ -644,14 +596,7 @@ def calc_topside_mass_and_cost(self): self.topside_cost = topside_design_cost def calc_onshore_cost(self): - """Minimum Cost of Onshore Substation Connection. - - Parameters - ---------- - shunt_unit_cost : int | float - onshore_converter_cost: int | float - switchgear_cost: int | float - """ + """Minimum Cost of Onshore Substation Connection.""" _design = self.config.get("onshore_substation_design", {}) diff --git a/ORBIT/phases/design/semi_submersible_design.py b/ORBIT/phases/design/semi_submersible_design.py index 1f6c6c8a..17fd0a80 100644 --- a/ORBIT/phases/design/semi_submersible_design.py +++ b/ORBIT/phases/design/semi_submersible_design.py @@ -70,7 +70,7 @@ def stiffened_column_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 + mass = -0.9581 * rating**2 + 40.89 * rating + 802.09 return mass @@ -94,7 +94,7 @@ def truss_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 + mass = 2.7894 * rating**2 + 15.591 * rating + 266.03 return mass @@ -118,6 +118,7 @@ def heave_plate_mass(self): """ rating = self.config["turbine"]["turbine_rating"] + mass = -0.4397 * rating**2 + 21.545 * rating + 177.42 return mass @@ -141,7 +142,7 @@ def secondary_steel_mass(self): """ rating = self.config["turbine"]["turbine_rating"] - mass = -0.153 * rating**2 + 6.54 * rating + 128.34 + mass = -0.153 * rating**2 + 6.54 * rating + 128.34 return mass diff --git a/ORBIT/phases/design/spar_design.py b/ORBIT/phases/design/spar_design.py index 9f5856f5..e3713c4c 100644 --- a/ORBIT/phases/design/spar_design.py +++ b/ORBIT/phases/design/spar_design.py @@ -77,7 +77,6 @@ def stiffened_column_mass(self): rating = self.config["turbine"]["turbine_rating"] depth = self.config["site"]["depth"] - mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) mass = 535.93 + 17.664 * rating**2 + 0.02328 * depth * log(depth) return mass @@ -119,7 +118,7 @@ def ballast_mass(self): """Calculates the ballast mass of a single spar [1].""" rating = self.config["turbine"]["turbine_rating"] - mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 + mass = -16.536 * rating**2 + 1261.8 * rating - 1554.6 return mass @@ -145,7 +144,6 @@ def secondary_steel_mass(self): mass = exp( 3.58 + 0.196 * (rating**0.5) * log(rating) - + 0.196 * (rating**0.5) * log(rating) + 0.00001 * depth * log(depth) ) From b7e513ee08d034ec82145d66352dc978207321c4 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 31 Jul 2024 14:33:07 -0600 Subject: [PATCH 213/240] Updated changelog with relocate cost updates --- docs/source/changelog.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 92f5b249..6349519e 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -5,6 +5,7 @@ ORBIT Changelog Unreleased (TBD) ---------------- +- Relocated all the get design costs in each design class to `common_cost.yaml`. Spar, Semisub, monopile, electrical, offshore substation, and mooring designs all recieved this update. Merged SemiTaut Moorings ~~~~~~~~~~~~~~~~~~~~~~~~ From b451a03b14a11e1cac598a2d76b3ca8bff0b6b3a Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Thu, 8 Aug 2024 12:02:53 -0500 Subject: [PATCH 214/240] Add cost curve creator notebook --- examples/cost_curves.ipynb | 723 +++++++++++++++++++++++++++++++++++++ examples/nrwal.yaml | 62 ++++ 2 files changed, 785 insertions(+) create mode 100644 examples/cost_curves.ipynb create mode 100644 examples/nrwal.yaml diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb new file mode 100644 index 00000000..29726af9 --- /dev/null +++ b/examples/cost_curves.ipynb @@ -0,0 +1,723 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cost Curve Creator\n", + "\n", + "This notebook enables fitting curves to ORBIT cost models, visualizing them,\n", + "and exporting to the NRWAL format. Functions are included for a variety of curve\n", + "shapes and more can be added as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", + "\n", + "from copy import deepcopy\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from scipy import stats, optimize, linalg\n", + "\n", + "from ORBIT import (\n", + " ParametricManager,\n", + " load_config,\n", + ")\n", + "\n", + "# NOTE: must install:\n", + "# ipympl # enables interactive matplotlib elements in jupyter notebooks via the `%matplotlib widget` magic command above" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Instructions\n", + "\n", + "This notebook is used to generate cost curves for NRWAL based on the ORBIT model.\n", + "Follow the steps below to configure and run the notebook.\n", + "\n", + "1. Create a basic ORBIT configuration file including at least the following sections:\n", + "- site\n", + "- turbine\n", + "- plant\n", + "\n", + "2. Configure the notebook by setting the following variables:\n", + "- `base_config_path`: the path to the ORBIT configuration file\n", + "- `DEPTHS`: the list of dea bed depths to use for the cost curves\n", + "- Add any additional global parameter ranges\n", + "\n", + "3. Run the notebook to establish a basic fit for the ORBIT data. This will also plot the ORBIT\n", + "data and curves.\n", + "\n", + "4. Refine the curve fits by swapping the curve-fit function from the options available in\n", + "the \"Curve Fit Library\" section\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Global Variables\n", + "\n", + "Replace any of these throughout the notebook to customize a curve fit or plot." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "base_config_path = \"nrwal.yaml\"\n", + "base_config = load_config(base_config_path)\n", + "\n", + "DEPTHS = [i for i in range(5, 60, 5)] # Ocean depth in meters\n", + "MEAN_WIND_SPEED = [i for i in range(2, 20, 2)] # Mean wind speed in m/s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Curve Fit Library\n", + "\n", + "These functions enable fitting a curve to a set of points based on a variety of curve shapes.\n", + "They should always be generic, so the global variables should not be used here." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def line_eval(slope, intercept, data_points):\n", + " return np.array([slope * i + intercept for i in data_points])\n", + "\n", + "def linear_1d(x, y, fit_check=False):\n", + " \"\"\"\n", + " Fits a line to a set of 2D data points with the SciPy stats library.\n", + " \"\"\"\n", + " slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)\n", + "\n", + " if fit_check:\n", + " print(f\"Slope: {slope:.6f}\")\n", + " print(f\"Intercept: {intercept:.6f}\")\n", + " print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = line_eval(slope, intercept, x)\n", + " return curve\n", + "\n", + "def linear_poly(x, y, fit_check=False):\n", + "\n", + " def f(x, a, b):\n", + " return a * x + b\n", + "\n", + " popt, pcov = optimize.curve_fit(f, x, y)\n", + " slope, intercept = popt[0], popt[1]\n", + "\n", + " if fit_check:\n", + " print(f\"Slope: {slope:.6f}\")\n", + " print(f\"Intercept: {intercept:.6f}\")\n", + " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = line_eval(slope, intercept, x)\n", + " return curve" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def quadratic():\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def logarithmic():\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def exponential():\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def linear_2d(x, y, z, fit_check=False):\n", + "\n", + " data_to_fit = np.array(list(zip(x, y, z)))\n", + "\n", + " # Best-fit linear plane\n", + " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " Z = C[0]*x + C[1]*y + C[2]\n", + "\n", + " return Z\n", + "\n", + "def quadratic_2d(x, y, z, fit_check=False):\n", + " \"\"\"\n", + " Fits a quadratic surface to the data points.\n", + " x and y are the independent variables, and data is the dependent variable.\n", + " Each of the arguments should be given directly from ORBIT and they are transformed\n", + " here into the required form for use with the curve fitting library.\n", + " \"\"\"\n", + "\n", + " data_to_fit = np.array(list(zip(x, y, z)))\n", + "\n", + " # best-fit quadratic curve\n", + " A = np.c_[\n", + " np.ones(data_to_fit.shape[0]),\n", + " data_to_fit[:,:2],\n", + " np.prod(data_to_fit[:,:2], axis=1),\n", + " data_to_fit[:,:2]**2\n", + " ]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " Z = np.dot(np.c_[np.ones(x.shape), x, y, x*y, x**2, y**2], C).reshape(x.shape)\n", + "\n", + " return Z" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ORBIT Design Phase Cost Curves" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Monopile Substructure\n", + "\n", + "Dependent variables:\n", + "- Water depth: impacts the mass of the monopile since it is fixed to the ocean floor\n", + "- Mean wind speed: impact the mass of the monopile by the load transferred from the turbine" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c017c86e9d98483eb2d665e3406414cd", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eXwkdZ3//6yj7yP35JpJ5r4YYIARnAEFFGURcUFddnV/X0HQVUHXY10PFMXVdXc9EPHAvZRV8cALXTwQccEDRIVJ5r4ymckkM7k7R99dVZ/fH91V0510ku4kM8nMfJ6PBzrpVH/q09Wd7le/j9dbEUIIJBKJRCKRSCTnDOpCb0AikUgkEolEcnqRAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQAlAikUgkEonkHEMKQIlEsii46qqruOqqq5yfjxw5gqIoPPjggwu2p5mw9/iZz3xmobcikUgkZSEFoERyhvDggw+iKAqKovC73/1u0u+FECxbtgxFUXjlK1+5ADtc/ESjUT760Y+yadMmAoEANTU1bN68mXe+850cP358obfHl7/85QUXvIthDxKJ5NSjL/QGJBJJeXi9Xr71rW9xxRVXFNz+1FNP0d3djcfjWaCdzY1f/vKXp3T9TCbDi1/8Yvbt28ctt9zCO97xDqLRKLt37+Zb3/oWN910E01NTad0DzPx5S9/mdraWm699dZzeg8SieTUIwWgRHKG8YpXvILvfe973H///ej6yT/hb33rW1xyySUMDg4u4O5mj9vtPqXrP/LII2zfvp2HHnqI17/+9QW/SyaTpNPpU3r++SYWixEIBBZ6GyUhhCCZTOLz+RZ6KxKJJIdMAUskZxive93rGBoa4vHHH3duS6fTfP/7358kbGxisRj/8A//wLJly/B4PKxbt47PfOYzCCEKjlMUhbe//e088sgjbNq0CY/Hw3nnnccvfvGLSWtu376d6667jnA4TDAY5KUvfSl/+MMfCo6x09a/+c1veMtb3kJNTQ3hcJg3vOENRCKRgmMn1gBOxb59+3jta19LdXU1Xq+XLVu28JOf/GTG+3V0dABw+eWXT/qd1+slHA7PuJdbb72V5cuXF13/c5/7HK2trfh8Pq688kp27dpV8Pve3l7e+MY3snTpUjweD42NjfzlX/4lR44cAWD58uXs3r2bp556ykn123uwr+NTTz3FHXfcwZIlS1i6dOm0e7rnnntQFGXS7d/85je59NJL8fv9VFVV8eIXv9iJvk63h6nWs/dmPw57nVe+8pU89thjbNmyBZ/Px7//+78DMDIywrve9S7ntbh69Wr+7d/+Dcuyil5XiURyapARQInkDGP58uVs3bqVb3/721x33XUA/PznP2d0dJS/+Zu/4f777y84XgjBq171Kv7v//6P22+/nc2bN/PYY4/xj//4j/T09PC5z32u4Pjf/e53/PCHP+SOO+4gFApx//3385rXvIauri5qamoA2L17Ny960YsIh8O8733vw+Vy8e///u9cddVVPPXUU1x22WUFa7797W+nsrKSe+65h/379/PAAw9w9OhRnnzyyaKiYip2797N5ZdfTnNzMx/4wAcIBAI8/PDD3HjjjfzgBz/gpptumvK+ra2tAHz961/nwx/+cFnnnYmvf/3rjI+Pc+edd5JMJvn85z/PS17yEnbu3El9fT0Ar3nNa9i9ezfveMc7WL58Of39/Tz++ON0dXWxfPly7rvvPt7xjncQDAb50Ic+BODc1+aOO+6grq6Oj3zkI8RisbL3+bGPfYx77rmHbdu28U//9E+43W6effZZfv3rX/Pyl7+8pD2Uyv79+3nd617HW97yFt785jezbt064vE4V155JT09PbzlLW+hpaWFp59+mg9+8IOcOHGC++67b1bnkkgks0BIJJIzgq997WsCEH/605/EF7/4RREKhUQ8HhdCCPFXf/VX4uqrrxZCCNHa2iquv/56536PPPKIAMQnPvGJgvVe+9rXCkVRxKFDh5zbAOF2uwtua29vF4D4whe+4Nx24403CrfbLTo6Opzbjh8/LkKhkHjxi188ac+XXHKJSKfTzu2f+tSnBCB+/OMfO7ddeeWV4sorr3R+7uzsFID42te+5tz20pe+VJx//vkimUw6t1mWJbZt2ybWrFkz7fWLx+Ni3bp1AhCtra3i1ltvFf/93/8t+vr6Jh07cS82t9xyi2htbZ20R5/PJ7q7u53bn332WQGId7/73UIIISKRiADEpz/96Wn3eN555xU9r30dr7jiCmEYxrR7svnoRz8q8t/iDx48KFRVFTfddJMwTbPgWMuyZtzDxPUm7q2zs9O5rbW1VQDiF7/4RcGxH//4x0UgEBAHDhwouP0DH/iA0DRNdHV1TVpfIpGcGmQKWCI5A7n55ptJJBI8+uijjI+P8+ijj06Z/v3Zz36Gpmn8/d//fcHt//AP/4AQgp///OcFt19zzTWsWrXK+fmCCy4gHA5z+PBhAEzT5Je//CU33ngjK1eudI5rbGzk9a9/Pb/73e8YGxsrWPPv/u7vcLlczs9ve9vb0HWdn/3sZyU/5uHhYX79619z8803Mz4+zuDgIIODgwwNDXHttddy8OBBenp6pry/z+fj2Wef5R//8R+BbOry9ttvp7GxkXe84x2kUqmS9zKRG2+8kebmZufnSy+9lMsuu8x5fD6fD7fbzZNPPjkp9V0Ob37zm9E0bVb3feSRR7Asi4985COoauFb/3xGQ21WrFjBtddeW3Db9773PV70ohdRVVXlPH+Dg4Ncc801mKbJb37zm3nfh0QiKY4UgBLJGUhdXR3XXHMN3/rWt/jhD3+IaZq89rWvLXrs0aNHaWpqIhQKFdy+YcMG5/f5tLS0TFqjqqrKES4DAwPE43HWrVs36bgNGzZgWRbHjh0ruH3NmjUFPweDQRobGwvqxmbi0KFDCCG4++67qaurK/jvox/9KAD9/f3TrlFRUcGnPvUpjhw5wpEjR/jv//5v1q1bxxe/+EU+/vGPl7yXiUx8fABr1651Hp/H4+Hf/u3f+PnPf059fT0vfvGL+dSnPkVvb29Z51mxYsWs99jR0YGqqmzcuHHWa5RDsb0ePHiQX/ziF5Oev2uuuQaY+fmTSCTzh6wBlEjOUF7/+tfz5je/md7eXq677joqKyvnZd2pIkxiQsPI6cZuEnjve987KbJks3r16pLXa21t5bbbbuOmm25i5cqVPPTQQ3ziE58AshGxYo/XNM1Z7DzLu971Lm644QYeeeQRHnvsMe6++27+5V/+hV//+tdcdNFFJa1RrIt2qujdXPZajHLPU2yvlmXxspe9jPe9731F77N27drZb1AikZSFFIASyRnKTTfdxFve8hb+8Ic/8N3vfnfK41pbW/nVr37F+Ph4QRRw3759zu/Loa6uDr/fz/79+yf9bt++faiqyrJlywpuP3jwIFdffbXzczQa5cSJE7ziFa8o+bx2utnlcjkRo/mgqqqKVatWFXTtVlVVOSnvfCZGS20OHjw46bYDBw5M6s5dtWoV//AP/8A//MM/cPDgQTZv3sxnP/tZvvnNbwKzS8VWVVUxMjIy415XrVqFZVns2bOHzZs3T7neVHuoqqoCsl28+V82promxVi1ahXRaHRenz+JRDI7ZApYIjlDCQaDPPDAA9xzzz3ccMMNUx73ile8AtM0+eIXv1hw++c+9zkURXE6iUtF0zRe/vKX8+Mf/7gghdvX1+cYVOdbqgD8x3/8B5lMxvn5gQcewDCMss69ZMkSrrrqKv793/+dEydOTPr9wMDAtPdvb28v6pF49OhR9uzZU5DSXrVqFfv27StYs729nd///vdF137kkUcK6g//+Mc/8uyzzzqPLx6Pk0wmC+6zatUqQqFQQe1hIBAoKuamY9WqVYyOjrJjxw7nthMnTvCjH/2o4Lgbb7wRVVX5p3/6p0mWK/nRzqn2YNeF5tfpxWIx/ud//qfkvd58880888wzPPbYY5N+NzIygmEYJa8lkUjmhowASiRnMLfccsuMx9xwww1cffXVfOhDH+LIkSNceOGF/PKXv+THP/4x73rXuwoaPkrlE5/4BI8//jhXXHEFd9xxB7qu8+///u+kUik+9alPTTo+nU7z0pe+lJtvvpn9+/fz5S9/mSuuuIJXvepVZZ33S1/6EldccQXnn38+b37zm1m5ciV9fX0888wzdHd3097ePuV9H3/8cT760Y/yqle9ihe+8IUEg0EOHz7MV7/6VVKpFPfcc49z7G233ca9997Ltddey+23305/fz9f+cpXOO+88yY1uEA29XzFFVfwtre9jVQqxX333UdNTY2T6jxw4IDz+Ddu3Iiu6/zoRz+ir6+Pv/mbv3HWueSSS3jggQf4xCc+werVq1myZAkveclLpr0mf/M3f8P73/9+brrpJv7+7/+eeDzOAw88wNq1a3n++ecL9vihD32Ij3/847zoRS/i1a9+NR6Phz/96U80NTXxL//yL9Pu4eUvfzktLS3cfvvt/OM//iOapvHVr36Vuro6urq6Snr+/vEf/5Gf/OQnvPKVr+TWW2/lkksuIRaLsXPnTr7//e9z5MgRamtrS1pLIpHMkQXtQZZIJCWTbwMzHRNtYIQQYnx8XLz73e8WTU1NwuVyiTVr1ohPf/rTBfYfQmRtYO68886ia95yyy0Ftz3//PPi2muvFcFgUPj9fnH11VeLp59+uuien3rqKfF3f/d3oqqqSgSDQfG3f/u3YmhoqODYUmxghBCio6NDvOENbxANDQ3C5XKJ5uZm8cpXvlJ8//vfn/a6HD58WHzkIx8RL3zhC8WSJUuEruuirq5OXH/99eLXv/71pOO/+c1vipUrVwq32y02b94sHnvssSltYD796U+Lz372s2LZsmXC4/GIF73oRaK9vd05bnBwUNx5551i/fr1IhAIiIqKCnHZZZeJhx9+uOCcvb294vrrrxehUEgAzvWY6bn/5S9/KTZt2iTcbrdYt26d+OY3vzmlbctXv/pVcdFFFwmPxyOqqqrElVdeKR5//PEZ9yCEEM8995y47LLLhNvtFi0tLeLee++d0gZm4mvQZnx8XHzwgx8Uq1evFm63W9TW1opt27aJz3zmMwVWQRKJ5NSiCLHAld0SieSs5cEHH+SNb3wjf/rTn9iyZctCb0cikUgkOWQNoEQikUgkEsk5hhSAEolEIpFIJOcYUgBKJBKJRCKRnGPIGkCJRCKRSCSScwwZAZRIJBKJRCI5x5ACUCKRSCQSieQcQwpAiUQikUgkknMMKQAlEolEIpFIzjGkAJRIJBKJRCI5x5ACUCKRSCQSieQcQwpAiUQikUgkknMMKQAlEolEIpFIzjGkAJRIJBKJRCI5x5ACUCKRSCQSieQcQ1/oDUgkEolkcSCEwDAMTNNc6K1I5gFN09B1HUVRFnorkkWIFIASiUQiIZ1Oc+LECeLx+EJvRTKP+P1+GhsbcbvdC70VySJDEUKIhd6ERCKRSBYOy7I4ePAgmqZRV1eH2+2WUaMzHCEE6XSagYEBTNNkzZo1qKqs+pKcREYAJRKJ5BwnnU5jWRbLli3D7/cv9HYk84TP58PlcnH06FHS6TRer3ehtyRZRMivAxKJRCIBkBGisxD5nEqmQr4yJBKJRCKRSM4xpACUSCQSyVnJgw8+SGVl5UJvQyJZlMgaQIlEIpFMyc+efOa0nu8VV20t6/hbb72V//mf/wHA5XLR0tLCG97wBu66665TsT2J5KxBCkCJRCKRnNH8xV/8BV/72tdIpVL87Gc/484778TlctHY2LjQWwOyTTbShkWy2JApYIlEIpGc0Xg8HhoaGmhtbeVtb3sb11xzDT/5yU8mHdfR0cFf/uVfUl9fTzAY5AUveAG/+tWvCo5Zvnw5n/zkJ7ntttsIhUK0tLTwH//xHwXHvP/972ft2rX4/X5WrlzJ3XffTSaTcX5/zz33sHnzZv7rv/6LFStWyO5byaJECkCJRCKRnFX4fD7S6fSk26PRKK94xSt44okn2L59O3/xF3/BDTfcQFdXV8Fxn/3sZ9myZQvbt2/njjvu4G1vexv79+93fh8KhXjwwQfZs2cPn//85/nP//xPPve5zxWscejQIX7wgx/wwx/+kLa2tlPyOCWSuSAFoEQikUjOCoQQ/OpXv+Kxxx7jJS95yaTfX3jhhbzlLW9h06ZNrFmzho9//OOsWrVqUrTwFa94BXfccQerV6/m/e9/P7W1tfzf//2f8/sPf/jDbNu2jeXLl3PDDTfw3ve+l4cffrhgjXQ6zde//nUuuugiLrjgglPzgCWSOSBrACUSiURyRvPoo48SDAbJZDJYlsXrX/967rnnHr73ve8VHBeNRrnnnnv46U9/yokTJzAMg0QiMSkCmC/YFEWhoaGB/v5+57bvfve73H///XR0dBCNRjEMg3A4XLBGa2srdXV1p+DRSiTzgxSAEolEIjmjufrqq3nggQdwu900NTWh68U/2t773vfy+OOP85nPfIbVq1fj8/l47WtfOyld7HK5Cn5WFAXLsgB45pln+Nu//Vs+9rGPce2111JRUcF3vvMdPvvZzxbcJxAIzOMjlEjmHykAJRKJRHJGEwgEWL169YzH/f73v+fWW2/lpptuArIRwSNHjpR1rqeffprW1lY+9KEPObcdPXq0rDUkksWArAGUSCQSyTnBmjVrnKaM9vZ2Xv/61zuRvXLW6Orq4jvf+Q4dHR3cf//9/OhHPzpFO5ZITh1SAEokEonknODee++lqqqKbdu2ccMNN3Dttddy8cUXl7XGq171Kt797nfz9re/nc2bN/P0009z9913n6IdSySnDkUIIRZ6ExKJRCJZOJLJJJ2dndKz7ixEPreSqZARQIlEIpFIJJJzDCkAJRKJRCKRSM4xpACUSCQSiUQiOceQNjASiWTBEUJgmiYAmqahKMoC70gikUjObqQAlEgkC4plWWQyGRKJBEIIVFXF5XKhaRq6rqOqqhSEEolEMs9IASiRSBYEO+pnGAaWZTkiTwhBMpkEshMYbEGo6zqapklBKJFIJPOAFIASieS0I4Qgk8k4aV9b1Nn/aZqGEML5TwpCiUQimV+kAJRIJKcVy7JIp9NYluWIt2J2pLYYBKYVhHaqWApCiUQiKR0pACUSyWnBTvlmMhmn1i9fqE0lBPN/X0wQWpZFKpUimUyiqiqqqkpBKJFIJDMgBaBEIjnlWJaFYRiTUr5zIV8QAo4gNE0T0zRJpVJOylgKQolEIilECkCJRHLKsCN0dtRvomibT+y1VVV1zp3faJJfX2iLQV3XT+mezgaee/LR03q+S6565Wk933xwzz338Mgjj9DW1nZK1r/qqqvYvHkz99133ylZX3JuIo2gJRLJKUEIgWEYpNPpUy7+ipEf/bNtZRRFwTAMEokEsViM3t5eent7SSQSZDIZLMuaNg0tWbwcO3aM2267jaamJtxuN62trbzzne9kaGhoobdWMk8++SSKojAyMlJw+w9/+EM+/vGPL8ymJGctUgBKJJJ5x270+P3vf09/f/+iSLsWE4R9fX0cO3aMRCJBNBplbGyMaDRKMpl0BKFk8XP48GG2bNnCwYMH+fa3v82hQ4f4yle+whNPPMHWrVsZHh5e0P2l0+k53b+6uppQKDRPu5FIskgBKJFI5o38qJ9pmos6mpZvOzMxQhiPxxkfH5eC8AzhzjvvxO1288tf/pIrr7ySlpYWrrvuOn71q1/R09PDhz70ISD7nD/yyCMF962srOTBBx90fn7/+9/P2rVr8fv9rFy5krvvvptMJlNwn3/913+lvr6eUCjE7bff7nSl29x6663ceOON/PM//zNNTU2sW7cOgG984xts2bKFUChEQ0MDr3/96+nv7wfgyJEjXH311QBUVVWhKAq33norkE0Bv+td73LWT6VSvP/972fZsmV4PB5Wr17Nf//3f8/1MkrOMWQNoEQimRem8vZbzCIwn6lqCDOZjBPBmdhQYjeVSBaO4eFhHnvsMf75n/8Zn89X8LuGhgb+9m//lu9+97t8+ctfLmm9UCjEgw8+SFNTEzt37uTNb34zoVCI973vfQA8/PDD3HPPPXzpS1/iiiuu4Bvf+Ab3338/K1euLFjniSeeIBwO8/jjjzu3ZTIZPv7xj7Nu3Tr6+/t5z3vew6233srPfvYzli1bxg9+8ANe85rXsH//fsLh8KTHY/OGN7yBZ555hvvvv58LL7yQzs5OBgcHy7lsEokUgBKJZO4U8/aDrGA6UwTgRIoJQruhxY4IKYoiBeECc/DgQYQQbNiwoejvN2zYQCQSYWBgoKT1PvzhDzv/Xr58Oe9973v5zne+4wjA++67j9tvv53bb78dgE984hP86le/mhQFDAQC/Nd//Rdut9u57bbbbnP+vXLlSu6//35e8IIXEI1GCQaDVFdXA7BkyRIqKyuL7u/AgQM8/PDDPP7441xzzTXOWhJJuch3KolEMmvslG8qlZok/mBmb7+Fppz9FTOdBpw5xsVqCBfzYz/bmOla5wux6fjud7/L5ZdfTkNDA8FgkA9/+MN0dXU5v9+7dy+XXXZZwX22bt06aZ3zzz9/0jmfe+45brjhBlpaWgiFQlx55ZUABevPRFtbG5qmOfeVSGaLFIASiWRW2OlROxpWrNGjXAF4Jgmm6QRhPB6fJAgNwzijHt+ZwurVq1EUhb179xb9/d69e6mrq6OysrLo6zG/vu+ZZ57hb//2b3nFK17Bo48+yvbt2/nQhz40qyaOQCBQ8HMsFuPaa68lHA7z0EMP8ac//Ykf/ehHQHlNIlOlhSWScpECUCKRlI1ttGz7603V5bvYI4DzSb4gtJtKbJGc31QSi8Wca3euXJtTSU1NDS972cv48pe/TCKRKPhdb28vDz30kNNMUVdXx4kTJ5zfHzx4kHg87vz89NNP09rayoc+9CG2bNnCmjVrOHr0aMGaGzZs4Nlnny247Q9/+MOM+9y3bx9DQ0P867/+Ky960YtYv3690wBiY0cM7TraYpx//vlYlsVTTz014zklkumQAlAikZRMflNEsXFuEzmXBOBEikUIhRCk02lisZgUhPPIF7/4RVKpFNdeey2/+c1vOHbsGL/4xS942ctextq1a/nIRz4CwEte8hK++MUvsn37dv785z/z1re+FZfL5ayzZs0aurq6+M53vkNHRwf333+/E6Wzeec738lXv/pVvva1r3HgwAE++tGPsnv37hn32NLSgtvt5gtf+AKHDx/mJz/5ySRvv9bWVhRF4dFHH2VgYIBoNDppneXLl3PLLbdw22238cgjj9DZ2cmTTz7Jww8/PJtLJzmHkU0gEomkJOwGCNsKpRRj51IFoBCCoaEhdF0nHA6fNs/A030eO01sXxO7eSaVStHX10dFRQUVFRUFTSUL7Z94JkzmWLNmDX/605+45557uPnmm+nv70cIwatf/Wq+8Y1v4Pf7AfjsZz/LG9/4Rl70ohfR1NTE5z//eZ577jlnnVe96lW8+93v5u1vfzupVIrrr7+eu+++m3vuucc55q//+q/p6Ojgfe97H8lkkte85jW87W1v47HHHpt2j3V1dTz44IPcdddd3H///Vx88cV85jOf4VWvepVzTHNzMx/72Mf4wAc+wBvf+Ebe8IY3FFjU2DzwwAPcdddd3HHHHQwNDdHS0sJdd901t4soOedQhPzKKZFIpiG/+7VYo8d0bN++naqqKpYvXz7lMZlMhp07dxKJRLAsC0VRqKqqcv7z+/2nTAR1dnaSSCTYuHHjKVm/VIQQPPfcczQ3N1NbW1vQRT2xy/hUXItkMklnZycrVqzA6/XO+/oLwUc/+lHuvfdeHn/8cV74whcu9HYWjLPxuZXMDzICKJFIpmQqb79SmSkCODIyQnt7O4FAgMsuuwxVVYnH40QiEQYHBzl06BC6rhcIQq/Xu+BRsfkmP0LocrkcD0IhBKlUqsCH0K4v1HV9UUxYWax87GMfY/ny5fzhD3/g0ksvlfY8EskEpACUSCRFmcrbrxymEoBCCI4cOcLBgwdZs2YNra2tGIaBZVmEw2HC4TCtra1YlsXY2BiRSITe3l7279+Px+MpEIQej2c+Hu6Ck3+d8tPrdu2g/Z/tN2c337hcLidCKAVhIW984xsXegsSyaJFCkCJRFKAEALTNBkaGuL555/n6quvnrWoKCYA0+k0O3fuZHx8nEsvvZTKysopo4SqqlJZWUllZSUrVqzANE1GR0eJRCJ0d3ezZ88e/H6/IwYrKytL9ntbjEx1naUglEgk840UgBKJxCE/5asoilOTN1smCsBIJEJ7ezsVFRVcfvnlTgdmKQ0lkBU/1dXVzsQEwzAYGRkhEolw5MgRZ6JCviDU9anf5s7ULuVSBeHELmQpCCUSiY0UgBKJBMh6j+U3etjCYi7YAksIweHDhzl8+DBr166lpaVlXoSIruvU1tZSW1sLZKOLtiA8dOgQiUSCUCjkCMKKigqnE3exMZdrPZUgtCyLVCpFMplEVdVJTSUTBeGZKIYl0yOfU8lUSAEokZzj2OPcbB86WxTMR3RMURQymQx//vOfSSQSXHrppVRUVMzTzifjdrtZsmQJS5YsAbIdkJFIhEgkwt69e0mn01RUVDiCcLF9OM5XdG5iRNUWhKZpOibedspY13XnuY7FYnLSxFmGbXSd73cokYAUgBLJOY1lWRiGUbTL104Bz4VUKsXQ0BB1dXVcdNFF06ZjTwVer5fGxkYaGxsRQpBIJBxB2N3djWEYuFwujh49SlVVFaFQaMFSpKdSjNqC0O6EnSgIITtizPbP8/v9zrEyZXxmIoQgHo/T399PZWXloo18SxYOKQAlknOQfG8/IUTRGrx8sVCuCLAsi46ODgYGBqiurubCCy9ccCGhKAp+vx+/309zczNCCA4ePMjo6Cijo6POyK/KykonQhgIBE7rvk+nMfVEQWhHRPv6+hyBONF3cKGfQ0n5VFZW0tDQsNDbkCxCpACUSM4xJnr7TdWAYd9WrgBMJpO0t7eTTqdpbGzE5XKVdP/TLS4URcHj8eDz+di0aRNCCMbHx4lEIgwNDXH48GFUVS2wnPH5fGelCLIbRurq6rAsi2PHjjE2Nsbq1asLviDk+w/aNYSSxYvtGSmRFEMKQInkHMKO+pmmOWNHqP3hbjeFlMLAwAA7duxgyZIlXHLJJXR0dEw72D6fha7HUxRlSg/Cvr4+Dhw4gNvtnmRKPV8s9OO3sZtF7IgpUNBUYpqm8/+2cbU9pUQKQonkzEEKQInkHMCu97LNlkuxA8mPAM6EZVkcOHCAY8eOsXHjRpqbm5015lpHuFBM50HY09PDvn378Hq9BYJwrh6EiyW6ODHqO1UNoWEYZDIZoPjYOikIJZLFixSAEslZzmzHueV/2E9HPB6nvb0dy7LYunUrwWDQ+d1iETRTUc7+pvMgPHr0KLt37yYQCBR4EJbTeblYIoAwc9p/KkGYyWRIp9PO76UglEgWL1IASiRnMXMZ52YfO10Er7e3l127dtHY2Mj69esn1RupqnrGRgBnYqIHYSaTcTqMOzo6iMfjBR6EpXRiLhbBXG7dZzFBaJcb2BHCiYLQtp+RSCQLgxSAEslZiJ3ytbt8ZzMBYroUsGVZ7Nu3j+PHj7Np06ZpuwwXU2SrGPO1P5fLVeBBmEqlHEG4f/9+UqkU4XC4wJQ6PyK2mK7TfEyAyRe7+YKwWITQFoVSEEokpw8pACWSswzb2+/ZZ5/l/PPPx+v1zmmW78QIXiwWo729HYBt27Y5jQLFUFV1UQmb04nH46GhocERx/kehMePH8cwjEVrSj0b65/pKEUQ2p3F+U0lUhBKJKcOKQAlkrOEid5+IyMjc47kTBRwJ06cYPfu3TQ3N7Nu3boZa7rKmSZytn/Y+3w+fD4fTU1NjkmvLQi7urowDIOOjg6WLFlCVVUVwWBwQU2pT+W58wWh/fooJggn1hCe7a8RieR0IgWgRHIWkD/ODU7WZM3XLF/TNNm7dy99fX1ccMEFTpqz1L0tVhZKUCiKQiAQIBAIsHTpUoQQ/O53vyMUChGJROjs7HS6kO0Iod/vP237PdUCMJ/8Gcb2ueFk/WoqlSIej5PJZFiyZIkUhBLJPCEFoERyhpPv7ZdfiD8fDRiqqhKNRmlvb0fXdbZt21bWrNgzIQW8GPZnP28NDQ1UVFRgWZZjSj0wMMChQ4fQdX2SKfWp4nQKwIkUE4RjY2MMDw9TWVlJOp0GitvOSEEokZSOFIASyRnKTN5+cxWAdkp5586dLF++nNWrV5dt41FuFHIxiLGFIv+xq6pKRUUFFRUVLF++HNM0HVPqEydOsH//fjweT4Eg9Hg887qXxWLZYteh2p3DtuWMEIJUKiUFoUQyS6QAlEjOQErx9puLCbNhGOzZswfDMFi7di0rV66c1TqlCsDx8XHa2trIZDKnLcq1GJlKsGia5lwTyD4/tin1sWPH2LNnz5w8CCeykBHAYuQL0vzRhZqmTRKEqVTKiai6XC5HEM6mE14iOZuRAlAiOcMo1dtvtunXsbEx2tra8Hq9+Hw+KioqZr3XUgRgd3c3e/fupbW1lXA4zMjIiBPlsidtVFdXU1lZOedJG2cLuq5TU1NDTU0NkPUgtE2pDx8+TCwWIxgMFghCXS/97X6xCcDpmpmmE4TJZNI5RgpCiaQQKQAlkjOEcr39yk0BCyE4duwY+/fvZ8WKFaxatYrf/e53c0rLTicATdNkz549DAwMcNFFF1FVVUU6nS46aaOzs9MRNdXV1SUbK5eyv8XCXESXy+Wirq6Ouro6ANLptNNhfPDgQZLJZIEpdUVFxbTXbjGlgKG8edSlCkI7pSwFoeRcRQpAieQMYDbj3MoRgJlMht27dxOJRLj44oudyNJcZ/lOJQCj0ShtbW24XC62bduG1+t1OphtJk7aSKfTDA8PFxgr2z561dXVhEKhWYmWs7Hu0O12U19fT319PZD1ILTF9N69e8lkMo4pdbFrtxgjgLMVpFMJQsuyHEGoquqkGkIpCCVnO1IASiSLHDvqV+44t1Lr70ZHR2lrayMQCLBt27aCZoK5dvEW28Px48fZvXs3LS0trFmzpuQPdrfb7RgrCyEKjJW7u7uxLIvKykonQhgIBM6oD/BTKURtD8LGxsZpr50dIZyrf+R8I4SYc7TXZipBaJompmmSTCalIJScE0gBKJEsUiZ6+5X7ATRTBFAIwdGjRzl48CCrVq1ixYoVRRtJ5ksAmqbJvn376O3t5cILLyzLS7DYun6/H7/fT3NzM0IIotEokUiEoaEhOjo60DTNEYNnSkPJ6RAYxa5dLBZzBGFnZyeWZRGPx1FV9bR7EBbjVArSYnOM8wXhxKaS/DnGUhBKzmSkAJRIFiG2t58t4GbzYTOdAEyn0+zatYuxsTG2bNnidJeWs0Yp2AIwHo/T1taGoihlewmWep5QKEQoFKKlpQXLshzvuHzblHxB6Ha7F9UH+EKlohVFIRgMEgwGWbZsGZZlsX37dlwuF4ODg0U9COcyXnA2zCUFXC7TCULDMJzfm6aJx+PB4/E4ljOL6fUkkcyEFIASySLCrvUbGRkhGAzOKe00lXiLRCK0t7cTDofZtm3btJ218xEBzGQyPP300yWPj5sP7CkalZWVQGFDydGjR9m9ezfBYBCXy+VEWcvpkj1VLAYBYac+a2pqaG5udsR0JBKht7f3lHsQFuN0CsCJTCUI29vbWbp0KXV1dU5TSf4c48XURCORFGPh3/EkEglQKP7+9Kc/8dKXvnROgmBiA4cQgs7OTjo6OlizZg2tra0zrj+XJhDLsjh27BjJZJLNmzfT0NAwq3Xmg2INJXb9WywW47e//S3hcNiJEIbD4XP6Azw/5ZovplesWIFpmo4HYXd3N3v27MHv9xdYzsy3Xc9i6kq2BaFlWY7gs8s1MpmM83spCCWLHSkAJZJFQP44N03T5qXmKb+BI5VKsWPHDuLxOJdeemnJ3n6zbQJJJBKOsbPX611Q8VcMu0vWMAw0TWPdunVOh/HEpojq6urT0lCymLqRp+sCtmsri9n1HDlyhGg0OicPwmIstqYUwJlOMlWE0BaEUHxKiRSEk7H/Bhbbc322IgWgRLKAFBvnZgvAuVpx2CngoaEhduzYQVVVFdu2bStrQsRsIoD9/f3s3LmThoYG6uvr2b17d8nnWih8Ph/Nzc2TGkrspgi7GcKOEJ6qhpLF8sFXzmuvWHTVFoSHDh0ikUiU5UFYjIVMAU+FaZpF9zSVIMxkMqTTaef3UhBOJv81t9isiM5GpACUSBaIqbz98j845poCHhwc5PDhw6xfv56lS5fOqpGk1MiUZVkcPHiQrq4uzjvvPJqamohEIosqsjWRYjWOUzWUFJvDawvC+Uh5LqbrNJfXntvtZsmSJU6XdzKZdMT03r17SafTjn9jqen2xSgA7QjgTBQThHbE344QThSEdpfxucZXvvIVLrjgAi677LJ5s/2RTI0UgBLJAjCdt5/9QTGXD71kMsng4CCWZfHCF76QUCg0q3VKbQJJJpO0t7eTyWTYunUrwWCwrPsvZibWwNlzeIeHhwsaSuYj5blYPvTnM/ri9XppbGyc0oPQNM0CD8JQKDTp3IupBtBmqgjgTNj1gTb5grBYhNAWhYvltXEqueOOO1i/fj0vfelLefWrX82FF17olBpI5h8pACWS00i+t99U49zyBeBsGBgYYMeOHbjdbmpqamYt/qA0ATc4OMiOHTuoq6tj48aNBR9u5QjAM+UDbuIc3vyxawcOHCCVShVM2TgTG0pOVfptJg/Co0ePAhQIwkAgsOhqAO207nxEqUoRhHZpSH5TyWK6HvNBJpNB0zRe+cpX8vjjj/PII49wxRVXcOutt3LxxRc7Yw4l84cUgBLJacKyLAzDmHGc22wFYH4KduPGjUSjUedcs2U6H0AhBIcOHeLIkSNs2LCBpUuXTjqm3AjgmfihVmzsWiQSYXh4mJ6enklTNoLBYNHHuZgipaer/mqiB6EQgvHxccfQ+/Dhw85rcHh4GL/fj8/nW/DXif03cSqEfamC8Mknn0RVVW644YZ538NCEIvFUBSFT33qUyQSCR566CG++tWv8trXvpYtW7bwhje8gde85jVFI8SS2SEFoERyisl/A7c/WKd7A8s3mi2VRCJBe3s7hmE4KdgDBw7MWVRMJeBSqRTt7e2kUqlpU8xznSV8JmKPXWtqanIiXHaHcX5DiR0hzG8oWSwfbAuVclUUhXA4TDgcprW11am/bG9vZ2RkhJ6eHtxu9yRT6tNN/pe4U02+ILT/Fi3L4n//938Jh8NnlQDUdZ1UKoXP5+NNb3oTb3rTm3jyySf50pe+xJ133sndd9/NHXfcwV133bXQ2z0rkAJQIjmFTGz0KHVaQDkTOPr6+ti1axcNDQ2sX7/e+bCY6xQPe78T17C7iqurq7n44ounrXdbLIJmKk51jWJ+hGtiQ0lfXx8HDhxwGkogm05eCEEzkcXSgWnXX2qaxvr16wkEAo4HYU9PD/v27cPr9RYIwvn2ICzGqYwATkf+DON4PE5jY+NpPf+pZHR0lHQ6jcfjcVLsAFdddRVXXXUV/f39/Ou//iv/+7//KwXgPCEFoERyisj39pvvOb72+vv376enp4fzzjtv0ofBfAjA/C5gIQSHDx/m8OHDrFu3jmXLls34mOZjD2cTxUyVR0ZGGB4eBuDPf/4zgUDA6S6eDw+92bBYBKCNXQM4nQeh3ZATCAQKGnLKsT0qldn8Tc83sViMQCCwYOefb4QQbN26FTj5RdnOngAsWbKEe++9dyG3eNYhBaBEMs8U8/Yr94PC9gKcCnu2LsDWrVuLfhDMR/rVXiOdTjtG0pdddhnhcLjkNRZTbdtiQ9M0ampqqKqq4tixY1x66aXE43GGh4c5ePAgyWTSaSixPfROR9RpMQrAYo97ogdhJpNxGko6OjqIx+MFHoR2NHE+9rPQNiWxWMzptj8baGlp4b777gMoKJVZTK/Dsw0pACWSeWQqb79ymS5yduLECXbv3j3jbN3ZTvGYuEY0GuXpp5+moqKCrVu3lhVRmS9Pw3MFt9tNMBh0PPTyLVOOHz+OYRgFE0qmaiiZK4vt+Sq1JtHlchV4EKZSKef67d+/v6BDey6CejH4Ep5tAjAUCnHJJZcAJ794Hjt2jEAg4Aj8xXDdzyakAJRI5gnLsjh+/LhjczEfUzzyMU2Tffv20dvby/nnn+90nZazRjkIIZz05Lp160qaHTwR+/iZBIX92IaGhgoMlhci/bmYKNZQYncYHzlyxEkp508omQ/htpgEoF0PNpsPfo/HQ0NDgzOKsJigzjelDoVCJZ3HHtm4kMTj8bMqBQwnX3d79uzhoYce4v/+7/+4+OKL+eIXv0hPTw/PPPMMW7dupbm5eaG3elZwbr+7SiTzgJ3yzWQyHDx4kBUrVsz5jXmieItGo7S1taHrOtu2bStpFNlcBGAmk2Hnzp2Mjo5SU1PD8uXLZ7VOvgCcivx09vLlyxkbG6Ojo8MZIWbXfJ0KP73FYlRdyh4mWqZYlsX4+DjDw8NOQ4nb7XbEYFVVFR6PZ9b7WSwC0H4Nz8d+JgrqeDzuCMKuri6EECVZ9ix0JMr+MnA2RQDt11xnZyfvf//7GR4exuPxsG/fPiAbzf3e975HV1cX73nPexZ4t2cHUgBKJHNgorefpmnzIijyxVtPTw979uyhpaWFNWvWlPzBM1txMzo6SltbG8FgkOXLlxONRsteI38PMLXAsU2rGxsbWbt2LYZhONGaZDLp2Kfs3LnT8dOzBU4gEFg0ImW+KLdRqKKigoqKioKGkkgkwrFjx9izZ4/TEFFdXV1WQ8liFICnQvwHAgECgQBLly6dcgZ0viC0I/uznQIyn0Sj0TmZvC827LrKn/zkJwwPD/P73/+e//zP/+R73/seACtXrqSqqoqDBw8u8E7PHqQAlEhmwVTefpqmzdl8GbIfdplMhh07djAwMMDmzZvLdsIvNwIohKCrq4sDBw6watUqVqxYwdGjR+ckaKcSgPkm0vbc4Il79Xq9NDU1TfLTGxoaoqOjA13XHTFYXV0962jXYmA+vjTYDSX2hJL8hgi7ocSOqM5U/7aYBKB9bU614Co2A9o2pR4YGODQoUPouk5VVVXZezEtgWkJ3Pr8PYZ4PH5WRQBturu7aWpqAmD//v0FDWdnW+fzQiMFoERSJvnj3KDQ22++bE8sy+LQoUMEAgEuv/zyWXnDlbMXwzDYtWsXkUiELVu2OL50c+0kLiYA0+k07e3tJBKJkucUF/PTs+fxdnd3s3fv3kVhnzJX5lN0TWyIyI+oTmwomTiDdzEJwPlMAZdDfoR1+fLlmKbpeDj29vaSTCZ5+umnCzwIJ34JGU8aPNLey28ODZMyLDY0BLnxwgY2NMxNuNlfiM5GMdTQ0MCf//xnAMc0HeDQoUMcP36c66+/fiG3d1Zx5r1DSiQLSL63nz2SKR9VVecUARRC0N3d7dTeXXLJJbP+4CtVvI2NjdHW1obP52Pbtm0FH2Jz7SSeKABHRkZoa2ujoqKCbdu2zVqk5U/TWLVqlRPtmmifYtcPTlXcv1hEzumgWETVjhAeOXIERVGca7oY6iJtbA/AhX6uNE1zro+u64yMjNDc3Fw05V5VVUUgFObeXx/lua5RfC4Nl6bydGeEfX1R7rp2NevqZy8CE4kElmWdVSlgu6nmNa95DU899RQf/OAH+eMf/0h9fT3PPfccd911F4qiSAE4j0gBKJGUQKnefjP5901HfhSusrKSmpqaOXcST/dBbovNffv2sWLFClatWjXpfHNtkrDXsyyLrq4u9u/fz5o1a2bVUTwdE6NdiUTCiXYdO3YMwKkftMevldKgcrqw93C6RM5UDSWRSIT+/n4AnnvuOed6zaWhZK4sdMNFMUzTRNf1SSl3uwbz8OHDtB2P84cunWq/i5BXR9c1Kn06RyMJfrq7f04CMBaLAZx1KWAhBMuXL+fjH/8473vf+zh8+DC7d+/mBz/4AVu3buXLX/4y69atW+htnjVIASiRzEA53n6zjQCOjo7S3t7uROH2798/L1M8plrDMAz27NnD4OAgF198sfMhVs4apWBfp7179zI6Osoll1ziTHE4lfh8Ppqbm2lubkYI4XTLDgwMcPDgQadbdi6C/WwiP925bNkynnrqKdasWcP4+HjR6NbptOhZiLnEQgi6R5JEUyZNFR4qfIXel8VEqcvloq6uzqnVPfRsF+rx47i1bMOGaVq4XDouodLWFZmTlUwsFkNV1ZLcAM4k7AabCy+8kMcee4yenh6OHj3K0qVLndIPyfwhBaBEMg32FIxSJ3qUKyiEEBw9epSDBw86jRd2avlUCUDbUsblcrFt27Zp6wvnGgG0O4hTqdSk9PLpQlEUwuEw4XDYqeWyIzX9/f0kk0n++Mc/FtQPnm6Pt8UQhbSx91JTU+N4TU6csGFb9NgNOOFw+JRdMzsFfLroG0vxtT8cY29vlLRhEfa5eNn6Wm66sAFNPRnRnunxhv0eNE3DH/ChKgqWlbWKGh5JIlIxfvvb387KgxBONkMsdFr8VJB/Xe0vcZCtHX7HO97BW9/6Vi666KKF2t5ZhRSAEkkR8r397AhEKW+2qqqSTqdLOkc6nWbXrl2MjY0VNF7Y68y1m7hYCvj48ePs3r2b1tZWVq9ePeMHzlyaQHp7e9m5cycA559//qLp0s3vlg2Hwxw5coTW1laGh4fZt28fmUzG+WC26wdPZ2p2oSmWji7WUGLXXO7evdsxVLZF9Hxes9OZAs6YFl/+7VF2Hx+nLuSmyu9iJJHh+9tPEPRo/MXG7OM3TXPGiTiXtlby/e0nODGaoiHsQVVU0kJHc7t57dZlXLo67IjqY8eOOTZHM3kQQvaL1dkmAEdHR4Hsa03TtIK6T13XSSaTPPzww7zuda9byG2eVUgBKJFMYC7j3EqNAEYiEdrb2wmFQmzbtg23213w+/mIAOaLN9M02bt3L319fWVZysymCcSyLPbv309PTw8XXHABO3bsKHvvpxNFUaivr6e+vh4hhFM/ODw8zNGjR1EUpcBu5lSk3RZjBHC617zX66WxsZHGxsYCQ2X7mgEF6eK5TMY5nQJw94koB/qiNFV68LqykaglIQ/HR5I8vneQa9bXoavKjBFAyzQJijivW6PwnacP0zdgYlSvxOPWuXpNLddtXIJbV/H7/U6ZQn5TTmdnZ0FTzsRrOF9TQH7zm9/w6U9/mueee44TJ07wox/9iBtvvHHK43/4wx/ywAMP0NbWRiqV4rzzzuOee+7h2muvnfNe7rnnHg4cOEAgEMDn8zk1qrZXo6ZpjI6OFnxRlswNKQAlkjzsqF+pKd+JzCTchBB0dnbS0dExbTOEpmmOzcxssfcSi8Voa2tD07SSp4jYlJsCTiaTtLW1YZomW7dudaIUi0ngTIeiKM4ov6VLlxZM2+jt7eXAgQN4PJ6C5ohyZiOXcv6FptyGlImGysX881wulyNkyvVsLLUGcCiW5tkjI3QOxqnwuXhBawVrl5QXJRuOpTEs4Yg/m4BHYySRIZ42CXv1AiNo0zBIxsaJR0dJRMdIxMZIxmMgBI3Amzb7Ga1aj+UKsqYuwLr6yXsq1pQTjUadulXbg7CyspKnnnoKVVXnPG4SsqnkCy+8kNtuu41Xv/rVMx7/m9/8hpe97GV88pOfpLKykq997WvccMMNPPvss3NOy37jG9+gubmZFStWMDQ0xPj4ONFolHg8TiKRcDIrUgDOH1IASiRM9vabjfgDpjWCTqfT7Nixg1gsxqWXXkpFRcWU68xXDaAQgmeeeYalS5eydu3asiMp5aSAh4aGaG9vp66ujo0bNzoRkjNJAE5k4rQNwzCc+sHOzk527dpVMK5uOnPlM4W5PlfF/PNGR0eJRCKOZ6Pf7y+ouZxORJdSA9gzkuRLvzlC13ACXVUwLMFvDw1x88VNvHR9bcl7rw26cWkqiYyJL08EZptBvHhUQWw0QqSvm+RIL/GBo6TisWnXXLFiFc0rV5W8B8hew/y6Vdv3srOzk29/+9vs2rULXde5/fbbeclLXsLVV1/tmCeXw3XXXcd1111X8vH33Xdfwc+f/OQn+fGPf8z//u//zlkArl27lltvvZW/+7u/K/p7O/o3MVsimT1SAErOeSzLYmRkBJfLha7rc/Icm0q4DQ8P097eTmVlJdu2bZsxajRXAWhZljMyadOmTc54tXIpJQWcH9Vcv349S5cuLbh+i1kAlvs867pObW0ttbVZUZFKpRy7GbsWLn9c3XR1XPkspuuTP9lmPtA0zRHItmfjyMgIw8PDkxpK7Akl+enVUlLAj+7q4+hQgpW1fqdR48Rokkd29LJ5WZiaQGmiYWNjiLVLAuw8Pk6tX8VtJRgbHYF4lAvDPvY9m01vD/YcpqqqGjfTR6NcHi8NLatLOvd05Pte/u53v+MLX/gC3//+96mrq+Pzn/88b3jDG3j++ee58MIL53yucrCjvfPR2X/jjTdy4sQJkskkLperwIxcURQGBgbwer1npfn1QiEFoOScJX+c23PPPcfGjRudD/bZMrF5QwhBR0cHnZ2drFu3jmXLlpXcTDJbARiPx2lra3NExVwe00ziLZPJsHPnTsbHx6eMai5mAThXPB5PQS2cXcc1PDzszJLNrx+caaLLYkkBn8p9TLRLGY3G+dOhXg50jeE6dJxat0ll5ckmnJnm7sbTJruOj1MdcDniD6A+7OHwUIL9fTG2rZxeABqZNInoGPHoGDc2jqL0dNDZOUbCyOBz61y8LMx5tSc/Li1LoJZwjZau3oh2CuxyLMuitbWVf/3XfwWyBusLYQr9mc98hmg0ys033zzntd7+9reTSCSm/BtpaWnh97///Vllfr3QSAEoOSeZ2OgxX35w+eskk0l27NhBMpnksssuK5hpOROzFYB9fX3s3LmTpqYm1qxZwxNPPDGnxzXdPsbGxti+fTvBYJCtW7dOmZopRwAuhACaL3FarI5rbGyM4eFhjh8/zv79+/H5fI4gzPfSW0wC+XSOgescivONZ7vpHkliCRWPXsV5S7y8vMrN+PgoXV1dTsNFd3f3nBtKANLJBInYWK5eL1u7l0mlCo551foKRpYHSaQNqgMufHphTaAQFqo2fVSysq6BcPWSWe9zOiaOgausrDwl55mOb33rW3zsYx/jxz/+sdMdPhfs2tupcLvd0v5lnpECUHLOkT/Oza71m652rxxswTQ4OMiOHTuora3l4osvLts0t1wBaFkWBw4coLu7m/POO4/Gxkbn/nM1ci4mTuxarpUrV7Jy5cppP5DLtZJZTHNo54KqqlRWVlJZWcnKlSsxDMOJDtqpz3A4nB0btojSWqfr+iczJt/8Yw9dkSSt1V50VSGaMnmuJ0ZzTZC/vOB8hBAcOnSIoaGhgmaI/Kiq3+NhU1OIpw4OU+k7GQXsHUtRqWdo0MY4fqQ/K/ii4xiZmW2adJeLakUBX/G/25nqEjXdRdOK9bO7MCUQi8UWdArId77zHd70pjfxve99j2uuuWbB9iGZG1IASs4ZphvnNp8CMJlMsn37djZs2EBzc/OsPkzLEYCJRIL29vaCzlt7DZhbdGmieMu3k7noootKSi+X8/jPFvFXDF3XC1KfyWTSsZvp7u4GoL293amXm48uz9lQ6nOQNiw6h+KkDIumCi+1wfKK8/f3x+iOJGmp8uLKRdNCXp1Y2uSPR0YcqxS3200wGGTTpk0FDSU9PT1OQ8kGb5C9WozDnX24rCRmchyvleQFKysY6xpirIx9aZqGaWRQmPoaCEugqlPbwDQuX4vLM326fy5Eo9HTMlGnGN/+9re57bbb+M53viPn8p7hSAEoOSeYydtvPgRgIpFg3759mKbJ5ZdfPqdv6KUKwIGBAXbs2EF9fT0bNmyY5E0212aS/CYQu7ZQVVUuv/zyGevZbOZiJn2qWUix6fV6aWpqoqmpiVgsxh//+EeqqqoYGhqio6PDiXSd7lm8pQjAw4NxfrD9BN0jSUxLUOHTuWJVNS/fUFdQhzcdibSJKQQurfB4r66SzFikDAu3rhY0gWiaRjgUxKVYhDwq416Fgf4TRAf2cGF8jM6YQdTSqQy4WddQwZrG8iOrQohpxR+AaVlT1gAGwlVUNywt+7zlkEgk5iUCGI1GOXTokPNzZ2cnbW1tVFdX09LSwgc/+EF6enr4+te/DmTTvrfccguf//znueyyy+jt7QWyoxenczWQLE6kAJSc9ZTi7TdXodTf38/OnTuprq4mHo/P+c15pv1YlsWhQ4c4evQoGzdudMYllbvOTNgp4P7+fnbs2EFzczPr1q0ry+qknBrAszkCOB12121LSwstLS0Fka78Wby2IDyV4+pmeg7Gkwbfee44J0aTtFT50DWFoViGx/YOUBNwc+nyypLO01jhxefSGEsaBbN2I3GDNUv8+N0qyXiUseF+xkcjHLbiJGLjZNKF9Xpel+4I6QtyY/6isRjRkT52DvXg9/kJBIMEg4HclxYFwcnIuBAgECBA1XRMI5W9TQgU5eTv7ZewEIKxeJJILEE8YxXcrqgqwaXr6OkdcM4hhCAY8FNTWXoN8ExEo9Fp6+VK5c9//jNXX3218/N73vMeAG655RYefPBBTpw4QVdXl/P7//iP/8AwDO68807uvPNO53b7eMmZhRSAkrOWfG+/mca5zTYCaE+9sGvvKioqGBgYmOvWpxVuyWSS9vZ20uk0W7dunVZszrUD175/e3s7mzZtorGxsew1ShGLdq3X0aNHCYVC1NTUUF1dXbKNylxYyAYMWyCYpollWRiGmRMbgkAwhD8QpGnpUjLp7Cze4UiErmM7SaVThENhKiorqKysJBAIoqhKbj0gt26h0Mn+LprKcGQoTixlUB1ws6zKi6Yozl5GRkfpHRrh8LHjBffLriPY0T3Gvo5emiu9jAyOkTshI6NJ/veZEXypRkdQCWcf+WvkOvCFoM4cYvuBEbyawCXSRMdjuKwUatTLQz2/wbIshoaGsCyLmppasNeZIMgEoKrZ1K2mqViWAMVPRhj0D8dJHo+QTCQA8Hi9+LxefD5fgR2TomoIYUJuXV3TMKZ4T+gaGMfyDqNrhR+hlbUNmD2DwODJdRXYunnTHF4lk5mvGsCrrrpq2tf/RFH35JNPzvmcksWDFICSs5Lsh6lR8ji32QjAeDxOe3s7Qgi2bdtGIBAgmUxiWdacI1lTCUDbbLm2tpZLLrlkxuaSuUQAU6kU7e3tAGV3MeczUwrYNsiOx+Ocd955Tm3ckSNHsgJUcznGwi6XOytuyBMXUwgdW7CIAiGSfz9yEbZefJUdUwoW+7m08s7nHDvD+uSOsclaD4kCAQNZUX/o0FEM9/MzXk/dF8YScY4NjrK3s5toNArgdCAHQyHcbnfR11/vWIpnDg8zkjARQqBrCksrvWxbWeVMv4iOj3N8IELoaE/R8x/pGSM2FiGKF1VTsczcuMFEhp5UlBMDU9cCCiEw0inSqQTpZIJlZpyYOcSxwRixdJoKj4sVtT4CQpBIZu+TymTN2TPTTMZRVA3LNNA1HdM6+Xfscum4XGHCOeeQVDpFMpkkHk8QiURQNRWvJysG/X5/wZeVqcSf/TpTKfxio7s9VNZN/oLU2tRAMDC/4wPnI8sgkUgBKDmryPf2K8fQtlwB2Nvby65du2hqamL9+vXOB4f9/zPNCp2JicIt30+wmNlyqeuUSiQSoa2tzanrmWuX6lRRBttKJhQK8cIXvtDprrRHiu050MHzu/YRPdBJIpHA4/EQDIUIhYIEAsGSoovTRXLGxsYYHh2nd2B42r07UaU5oOsahjnFc1FiFNKlaWRME7fHQ43HQ01NDfb84uj4OCOjoxw/fhyXy0UgGCQUChEMBtF1nYxh8eyRCCMJg4YKLwqCVK6Ro8qnc1FLZXYriGkr4MJeHRWFtGnhzh0oEMQzJmsqT75OTNMgk0yQyom9TDJJOpVAWIXPxepqN8srdUxLoKsKk17WYqYospIT2UqB+CuGx+3B4/ZQEa7AEoJ0KkUikSQaizM4NIRL1/F6fQT8PtweT9HzOqPyJtQ61ja1oEw43uN2sXJZ+RM6ZmKiDYxEMhukAJScNUxs9ChnmoGmac6syekwTZN9+/Zx4sSJohM2nPmgpjlnAWg/jlQqxY4dO0gkEmVH4mZjwXL06FEOHjzI2rVraWpqcrwEZ/t4ppom0tPTw549exwrGaDgOUimM/QNj2WvcUMDpmEQjUYZj0bp6e4hk8kQCAYIBkOEQiG8Xu+k53s68QdMFhtFcLt0MsbcGoQ0TcWYYY2ZtjKSyNA5NMbAeAq/S6Ol2seyKm/B/OIl9fW5+c9Rxsej9Pf309XVhdfrJab4GBg1aKoO5qrgwKOrBNwah4cSnN8cRtfUrBad5sIsrfLSXOnh2EiaoFtBVWA8lsBDmibdordrhHQygVmC3YoQAlVXUYWFqhU/p8ACphaA2SikmfuyU7pIVxUFr9eL3x/AskwsYZFMJEmlkgxFImTSadxuDz6fF6/Pi9fjzUWCs39P+a+1YGUNvsDkv8u1K5ah6/Nbq2kbjktDZMlckQJQclZQzNuvHEqJAEajUdrb21FVlW3bthUtwrZF0nzM8bUsyxkhV1VVxUUXXTQrP8FSa9wMw2DXrl1EIhG2bNlCVVWVc03mo47QxrIsR0Rv3rzZsUXJP0YIwe6DnZh511HTdSoqK6morEQIQTqdJjo+zng0K3RURclGB+00qMs1Y0QIYLpHpirKjMJtJhTm/noYjKb4w5ExIrEUPrfGUDTNsZEEFzaH2NhYKDxUVSUUChMKZW83DIPx8XEiJ0aJxWP0Z6J43G7cHjdutwddVTEsgWEJdG36JhA7ffuCWgs9NkzPwBhmOkmlR2N5jQ9PMumkbkvB7XGTSWemPUZYAkUvvh9V07BME0VVMU2rJEFfuDhOil5VVHx+P4FAgKpcXWYimSSZTDA0OIRhmng9HtweNygKQmR1sqq7qK6f3PVbVRGisa6mzA2VxkL7AErODqQAlJzRTOftVw4zpUqPHz/O7t27aWlpYc2aNVOmpOyo43wIQCEEzz33HGvXrqWlpeWU+glGo1G2b9+O1+vl8ssvd6Z62OecLzPpZDJJW1sblmWxdevWKTsZu3sHiIyOT7umx+PB4/FQU1uLsCziiQTj4+MMDQ1xrLubgN+Hzx8oK11c7DzWHJtEdF0nnkwzEE1jWIKQV6fSpxc8nzOd4eBAnJF4iqZKj2NRMpo02NcXo6XKT9A79Vu5rutUVVWxzhOkMzEEVgY3Jql0mlg0xnAaloY9xEYjqKFQtm7RMknExkinkqQTCTKpvPStkt3wmqDCcp8Pw/Li0VVKdH9xUFRlRvFH9lTFX/u513Y2+SvKF3+AqmcFpI1LVTFyr3VN0wgGAgRzqdZMxiCZShCPxkEIjnV14fV5aVy+mkwmg6ppebNrYcPK1vI3VCKyBlAyH0gBKDljmcnbrxymigAahsHevXvp7+8viFbNZq1SSafT7Nq1C4BLLrlkToavpQhAW9y2trayZs2agmto/3s+IoDDw8O0tbVRV1fHxo0bp0wpJ5IpDnQeK+8cqkogEMjWRTU0gLAYHR07mS42DAIB/7Tp4oloqloQgZwNmqZyPBKjvWeMSMxAIPDoKq3VPs5vDqHlidKp9pPKmPSNpQl59QJ/urBXo3csxXA8M60AtKkNeVld62XX8QwZVcftdWEINzVailZ/iq7DB4iNjyIsE8s0SI0N4PN40SaMPNNUFcPIjkJzMdnHr1RURcWkhAitKC7uVLLpWH2Wz1O2ceTk+RUUR/wVI9tQEsJAp2s0RUVFJYGgD1NoHDx0KCsYc404561dNe+NHzbZFL+sAZTMHSkAJWcklmXR19fH4ODgJNEyG4qJtvHxcdrb23G5XGUZH8+l83ZkZIS2tjanvmeudT7T2cDYqdjjx49z4YUXFp3naUc052qVMjg4yL59+1i3bh3Lli2b9vnafejInISXAqCoJaWLdV2f4rGdrPUSQjCezNqzBD16yUbHCEimDdq6xxhNGCwJu1EVhXja4EB/jJBXZ1VdwDnHVLhdOqoiMCccYpe7zTCSNnusZRJLxFgTMlAqEhztHyURT1Dntmiu8FGl66B7CPtqiYyMEIsZjERGGMik8Xg8eL0+fD4vPq8Pw7DQdB3LnLordyZ0lwsjM3P0D8g1yBRecyf1qyize60I539OrqnCVD06Ngf6Y+zoGSWRAi0aQ0838OKaSi47bznxeDxbozo2Sl/3UaKRgYK5z/mWM3MhHo8jhJA1gJI5IwWg5IzCTvlmMhkSiQRDQ0OsXbt2zuvmC0AhhDNmavny5axataqs9GF+A0ep5DdfrF69mpaWFh5//PF5qyWcSCKRoK2tzbGwmc5Udi6C1q4/M03TqSucju7efoZHxuYk6DVdK6jbmy5dPDo6Sjqd5sD+/QXdxW6XjmEKIvE0+/tiDMfSCKDS52LNkgBLQjNP5XC5NHoGE4zEMywJe5zJEX63TjJjcXQ4wcravHFvRR6zpiqYpsWyKh+7jo8TcGvoarbrdSiaptLnojZ4ci+WaZJOJ7Mp22SCTCpBOpVEmIYjlKoE1NS7sEx10ilVVcXt9pBOZ2hsqMcwTRKJJMlEnIH+MYQQeP1+PB43Pp8ft+4qO/WqqBrmNJYuE7GEQFXy/v4UxYncKaqCmKiMS2Bi6ldTFcwZGkj6oynae8YwTYFPB091A+OKzq8PDLEk7GFVbTb6d8G6VdRWhRkZGWF4eJjOzk527dpFKBRyxOBcjLzj8TiATAFL5owUgJIzhonefi6Xa17m98JJAWgYBrt372ZoaIiLL76Ympryi7g1TStLMGUyGXbt2sXo6KgjkuyI0KkQgIODg7S3t085Pm4is40AxmIxtm/fjmVZLF++fEbxl039dpd9nnwmdtsKIYilTCwBQY+GqioF6eJgIEB3dzf19fWMR6N0d/cgLAuvz4vuDbJv2CJhKVT5skJnOJ6hvXuMS5dXFkyvmLQPVSGTMciYOZPiCSrJpSmkMhaWEGhTKiiBQAVFYV19kEg8w4mxZNZ30LIIaAZrQxAdPE4kJ/SMIp236oQ6RlXXEaYxpXDLt4HRNY1QMEAoGEBVFZKpDIlEnGQiwWhkFEVV8Hm9eH1+fD4v+kyiRs3WCs4ktgr2I0RBAFBRVITIdf3OFLLLEU0b9I6msYSgNuihOv/7jpjZhUdRVY5GUmQslYBHxbDcKMEawigMxVLsOj7OqtoA1RUhGuqyJRu1tbXOrOxUKkUkEiESibBv3z7S6TQVFRVUVVVRXV1NKBQq+UtmLBZD1/XTNhpQcvYiBaBk0TOVt5+u6/MmAFVVxTAMnn76aXw+H5dffvms32DLqQEcHR2lra2NQCDAtm3bCpov5jrGDQoFoBCCw4cPc/jwYTZs2MDSpaXNK52NAMwfHZdMJkuKduw+2DmtZcvMiAIbkNFEhkMDMSLxDAgI+3RW1voLImYAKIqTLkYI0pkM42Nj7O8dpasvQbUHopmsDUiNz0t/zODEaHIaAXhSuIW8Gi5NIZkxHaNlgGjKZHmN72QNYJHr69J1kslsNC+TSrIxmKAqPUY0nkSx0lR7XWhRldHoTFflJJpWQuq2SM2dooBpCtweD26XTkU4jCUglUqSTCQZHx9jcHAAl8uFz+fD5/Xh9U720VOVbESzLMTJ+kjV2f/JFP1MdAzG2XV8nJSRHdum6yrLq71ctLQCVcn+bJgW5P7msg84d2crK9IRFqm0gYqJYimIYL1zkKooRFNZQb1hVfHGD4/HQ0NDAw0NDY5voy0Iu7u7sSyLyspKJ2UcCASmjILbY+Bm09QkkeQjBaBkUZM/zg0Kvf3m2myRf47+/n7S6TStra2sXLnylEzxmHjOY8eOsX//fscHb+I550MA2uItnU6zc+dOYrFY2V6C5ezDHul25MgRZ3ScPS1lOrp7+xmKjBbcZloWowkDwxL4XRoBjzbt86JruiMgkxmTXcfHGUsaVOaidyMJg90noly0VCPsK/7Wp+s6KAo1tbVUZjzUmVEqPQqpZJJoNMrw8DBx4eKYSNAcEEW7i/P3Ue13s6zKR8dgHJ/LxKUqRNMmAY/Gylq/c80ymTTpRIzRwT7SqSRmJms/Yk14fVe7dCqCClDal5P8RhZF1TBNY0a/QcffJA9VUUFXEHn7URWyI9W8XqqoxLQsksmsIBweHiJjmng8bvxeH16vD6/f54yNK4dsRFLJdv3mxKumKZglpH5HEgY7esaxRLb7GkUlbZgcHkpSG/Sxui6AKaysqXOu+3ki9pWo8rs4FklieoLgPvncmZagqcLL8uYGAv6ZGz/yfRubm5sRQhCNRolEIgwNDdHR0eF0btv/+Xwn141Go/OS/v3Nb37Dpz/9aZ577jlOnDjBj370I2688cZp7/Pkk0/ynve8h927d7Ns2TI+/OEPc+utt855L5KFQQpAyaLFjvrZ4mPiB+18CEA7/RqJRFAUhVWrVs1pPZi5BtBOMw8PD0+bZp6vCGA8Hufpp58mHA6zdevWsovRS40AZjIZduzYQSwW44UvfKFTpD7T/RPJFPs6ugpuG0sYHBqIMpLIds66VY3GSg8ravxFmzB0TS2IHg6MpxlJZKgPe1BzH+G1ATe9Y0n6xlMnBWCe0JloGu1zawgUPB43Xq+HCiqwLIuuwShezaS7uwcj110cCoUJBYP4/P7slxXHDkThwqVhQl6do0NxUskES9yCpUEFK9JDd1+KTCpJIpFgdHCAIW/2Na4Vee7VnIArFVXJRrYUJZvCRFgziz9seXbySFVVsJRC8VcMTVUJ+P0E/H6gmoxhkExmH9t4NIowTTw+Xy5l7MM1Q/3gUDzDsUiC3kGDunSCVaqbSq+WfVzGDJ5/ioKiqBwfi5O2yEVrFbBMvLpC2jA5OhxlVa0XUeLf2IoaP4eHkgyo1bgMgZU2iKdNqvwuLltZw4qls5v4oSgKoVC2O72lpQXLshgdHSUSiXDixAn279+P1+ulqqrK8SGdjw7gWCzGhRdeyG233carX/3qGY/v7Ozk+uuv561vfSsPPfQQTzzxBG9605tobGzk2muvnfN+JKcfKQAli45Svf1sATjbubsjIyO0t7cTDAbZsmULTz/99Jxn+Nr7mkq4jY+P09bWhsfjYdu2bdOmmecqAIUQxONxRkdHWbNmDStWrJjVYyvF13B8fJznn3+eYDA4SWTOJAAnpn5NS3BoIMpowqDa70JTFRIZi6PDcXwulebKCVEWMbmmLGlYqIriiD8bt64SS00QUSJb8zbRNLo+5KHCp9M3nnZqAEcSBtUhPxcsryTs1UmlUkSj44yPR+nt7cXl0vF63HjcLty6C6wM6VQKfybFGsUgoxvoigIxmJi5tXdazH5G1TQsw5x5XIjzkASo2VSuQja6Veq4uXzbFQFYIiucysWl67hy4+hAkE6liScTxOMJhiMRNE3D6812Fvt8vgK7me6RJNuPjZIyLMwMjEUy9MaGuGRZmKYKf3Z/ipKNTKqA8xjBEibZGdAm6YyBIiwUYYGiOddPVRTShiirgzjg0bj+so38tjvDsZFsreWGhhBXra3hheetnreJH6qqOpE/yH5hHBkZoaenh09+8pMcOXIEj8fD+9//fl760pdyxRVXzEoQXnfddVx33XUlH/+Vr3yFFStW8NnPfhaADRs28Lvf/Y7Pfe5zUgCeoUgBKFlUlOPtZ9eVmaZZ1oQMIQRHjhzh0KFDrF69muXLlzsp5nLXKsZUwq27u9vpLF69evWMYmwuAtA0TXbv3s3Y2Bj19fXOqLXZMNM0EdtHcMWKFaxatWrS45pOAHb39jOYl/pVFIXRRJqRhEFNwOU0T/hcKmkj63vXVFHo4edy6WQmdJV6dRVLCCxEgQhMGxYBz+TnVysyMs7v1ti8NFzQBVztz3YBh9wq6WQCI5VEszIEXOAN6IyMRBgajJNIJEmnU7jdbrw+H36fH7fbhT6lZ8vJ6zNRlCiqijCtksUfZGcGG1a25k3R1LIFnNMEomqYJdba2VgCRhMGFoKwR8ft0lAQuN3ubI1rbg5vKpUkkUgyNjbGwOBA9lp5vbg9XvaciGFYggq/TiJu4PWqjKcFeweSNFQGUHLzfy1hMp2VYJXfBQqYQkXD7vIHw7KoDZYXCdfdHlpblhLw9hNLumhsasbv1qipDDuNH6cCXdedhpL29na+8IUv8OCDDzI8PMxb3vIWjh8/zp/+9CcuvPDCU7YHgGeeeYZrrrmm4LZrr72Wd73rXaf0vJJThxSAkkWDZVmk0+mSJ3rYQq0c0WbXwkWjUV7wghdQWVkJzN8IN3ut/BSwaZrs2bOHgYEBLrroIqczcCZmKwBjsRhtbW3ouk5jY+Oc/cemEnCWZbF//36OHz8+rUn2VPcvlvoFyFgi20ZRpHM2Y4qCzllNU0lnMpNeK7VBN5U+FwPjaacGcCxpEHDr1E+wcFFVlYxhTFpDWBZBzWJTrcKoO2uv4sYgcbybI0ahh50tSGy7maoqsEyLRDJBMpliYLAfy7Twerx4/dk0qNvlniTqNE0taJJQlFxtWhl1c/mGxlqu47ccRK4GUFFVzFJaZPMYjGbY3TvOWCJ7ffxeDxvr/TSE3AUpW1VRspE/rw9RlT2FLQiP9Y8wHLPw6ZBJZ2sGFQQBN4zHUozEU1ROUcM5keZKL7WDHgaiKdyagoJC2rQIeV2srJna+qgY1Q3LUHJ/kz6Xht+toSoK61e2lLXOXPF6vaxYsYL/+q//chq7WlpO/R56e3upr68vuK2+vp6xsTESiURBnaLkzEAKQMmiwTTNssa52ceVWgdoz9WtrKxk27Ztk9KU9h7mSr5wi0ajtLW14XK52LZtW8lm0vY65e6nr6+PnTt3snTpUtauXcvBgwfn/JiKCdFkMkl7ezuGYUw70g2mFoB7DhXv+vW7NFyqSipj4XGdjJjF0iYNYbfTOauQmxNb5LXic2tsago5XcBCQGWuCzi/AUQICyOTJhEbx0hn6/Ey6SSZdCprqZLXECGEIDXVNSrSlKBqKsFQiGAwiLCqyRhZ78pEIsFIZARVVfD5vHi92ZSmqhbvkC23A9s2NFZVrWzxlz1h9tpqqoZhlGjWDETTJs93jxJPmwTdGoqqEk2k2N6d4bLWSmpD3pxJd/Z/hBAIYaEIgaKSNZr2ebHcfjxjQzhPvRAkk0mEqmFYCqaRAaGXFBHVNYUXralh74lRuoYTWAJWVPpYUx+gokQRCeALVuAPVuS2Y6Gp2S+Mrc31JTV+zCf5TSDzVbcsOTeRAlCyaLCtT8qpUyulESTf/mSqSRSKosxbV7Et3EqdHzzdOqVGAC3L4uDBgxw7doxNmzbR0NDgrJEpdeLCFEwUcJFIhLa2NmpqajjvvPNK8hGc+Dh6egcYGB4tenzIo9EQ9tAVSeAzs8bHsbSJx6XSWHHyw1bXNTLG1M9Xhc/FxcsqGE8amEYGFwZWeoyhvhRGKkU6nSQZizLY24tPmeyfl9s8ML0I01S1qHBzonc5HzuXy4XL5SIcDmfFZCpFIpFgbGyMVCqFqsBwJILf68Xj8aDpLqwyU7d2/aCiqiU3NwDE01lj6r7xFJlMiiUBF6FUCk8pY0ZynBhNEUsLqvweFCWb1K4OeBmMJekeSVATdBUbwDFJyFX73YS9LkaSJpVeFSOTxu3xMBrPEHYLxof6SYxo+Hw+vLnpJOoU+1RVDZcwubA5zAVNYQSgq2rJFjKQ9R2srj9pmWSZFrruwutxs3LZ7Bo/5sJCjYFraGigr6+v4La+vj7C4bCM/p2hSAEoWTTkW7yUiqZpTv1eMVKpFDt27CCRSMxofzJfAlBRFAYHB+np6ZlyxFoplCoAU6kUbW1tZDIZtm7dWvDhMB9j3GwBJ4Sgq6uLAwcOsHbtWlpaWkp6vibuIZlKs+/w0enuwKo6Pz63Rt9YioxpsSTszo4s82ejtqqqZAv88wSakYvaZdKp7L/TWTFjmgZmERFsez/OsPlphVS2SaLI9VWmv6+iKHi93lx3JySTCQYGBrFMk4GhIRDgdrly6WIfbperpIiXZUcsrdLtVhIZi+ePjTAcz+DWVdIZQcdQiiRjXLysAleu61rk9q04EdiTz6vAIpkxULBQsAAVVZhYKFnrm2QZ3csqbGoM8dyxMSJxg0xGkFEFIb+HLS0V1ARcJFPJrBn1yCgDmQHcbk/WksbnxePx5mxdsjvLH7Qym7nB4ZoluDwnI/dWrlFs3Ypls57mMRdisdiCTAHZunUrP/vZzwpue/zxx9m6deus1puPhjvJ3JACULJomM2bwXSibXBwkB07dlBTU8NFF100Y53gfAjAeDzOiRMnnBFrc/lmXMpEETutXVNTwyWXXDLpMc6XlYxpmuzcuZOhoaGSRrrlMzECuPvg4aKROwFEx8dxud14PB6WVflorvBma/5yPm2ZZIJ0OokwDFKpxEmxZ6SLCl1V1SZ56dnnEkVmzOZtekbxB1MLCkXRinrKFT2VqmBZAlVVqa2tRVW1XD3cxHSxLzeT92THrGFB71iSwWgaRVGo8es0VvrRldJFf/dIguF4hiq/K1sjhyBjmfRHDQaiGZqrfNlUux3NzD0ukbtM2QCngt+lZ6dqKGqu61YFS2BYgpBPdyKi2euj4Fx9Qd5t2R+aqwMEvDrHhuMc78/QvCRIS7WPoC97jmBuiosATMMgmUiQSCQZGhpGWCYerwe/P4TP68Llchd8CdFUteDcdrTSJl+Y6C43tfXNqDmhJ0S2NrW2qoL62lPX+DEdsVis5Dri6YhGoxw6dMj5ubOzk7a2Nqqrq2lpaeGDH/wgPT09fP3rXwfgrW99K1/84hd53/vex2233cavf/1rHn74YX7605+Wdd58M397HvnY2BiQnX1eU1NDdXW1Y4ovOXVIASg5oyk2DcSyLDo6Ojhy5AgbNmygubm5JHE5VwHY29vLrl27CAaDWXuLOaZFphNv+Z3MU6W1Z1qjVOzr6fP52Lp1a1l1jFAoAI/3DzAyFsWlaSc9+ITAEhadnUcZHxvFMC08Hg+hUAifz0NqdIhMOolpZmv5UASKULMGwQogsqPXhMgW+QNYwkLXdEzLzEZpcmlYe6qYAlhkDYVVhZMTOZSTkS4hBEK1e4jzawHzZKOSq0XFeSiomoplmbnuafsakBM3SuFtOesSTVVQFQVNdyFMA48n2zFbWVGJZVmk0ikS8YQzccPjduP2ejk8CoMJM/v4LcHxMYXBWIbzm8Loau6BCk7+QwCaAiJ7PgEMxw10VUUlNyYulcSlQtq0GImnaapwO4914ivMfiwCQVOll8PDcUZiKUIeHbCyqXtdZVmlr0Cgn4wcTl5MUbKR2aBHY/2SAL7kEK31/lwDhig8MdkuaV8ggC8QAJH1o0wkk8TiUYaGkigKeL0+ggE/Lo8H18QvgsW0cm79mromTAFm3hcWwzRY09pc5E6nh1gsxooVK+a8zp///Geuvvpq5+f3vOc9ANxyyy08+OCDnDhxgq6uk01aK1as4Kc//Snvfve7+fznP8/SpUv5r//6r7IsYGzxd/jwYR5++GF27tzJwMAA4+PjxONxNE1j6dKlXHrppbzqVa9i06ZNcuLJKUQKQMkZzUTRZjcnZDKZAjPiUpitWLK7YXt6eti0aRPJZJJIJFL2OqXuJ392cH4nczFK8fCbjoGBAUZHR6mqqmLLli2zejO2hWkylWbvoaOTon+pVIrDhw+jaSqr1qxFAaKxGCNDgxza/TyZVDInqL34fX50lw7TRbhENvKXnqL2MXtNsuLRtASWOGm9IrBtV4p9ERAF/1JsFZmHWlCSkLdHMeEfAvqiKQaiGRJpA58m8AqyDQ4Fh2XVpt1dXEklpmmRTCboGorSM5zCowpcbh3d5UYg6B1LsyScZllV9guIyDu3sCwnPWxrKZeam7aRN2nDPl7XSo/K+9wqW1qr2HV8lLF41gYm5NFZ3xCkKlBiJ7odmrPTtqqSE54lvu4UcLldeLxehBXKdRenSCUTjIyOkU6n0XUNr8+frbX0eU+K/wl4A2H84cmR7vrqytPe+JFPPB6ftumqVK666qppy0MefPDBovfZvn37rM+pKApf/OIXefTRR9F1nSVLlvDyl7+choYGPB4PY2Nj7Nmzh+9///t87nOf46/+6q+4++67aW5eOMF9NiMFoGTRMNsUsP2B29/fz86dO6mvr2fDhg1l1+fMJgKYSCRoa2tzUr5+v5+urq557ya2GR8fZ/v27fj9/oLZwdOtMZsaQCEEHR0ddHZ2EgqFqK+vn/U3cVuE7jnYOUn8jY+P03n4MFXV1TQ3Nzu1hh6XBpkoTQ312YkSiXh2WsbIKKg5C5FcfVxBA4AARSue9s39GlVRUPIEpCiIJpWWutUVhXjGRFXAlTu/puklT+o4Mpzg8FAM0xK4VJWBjIFqWtTWGtN3p4ps80soFMYaV/AGXFT7dFLpNEYmhZExSBoKXb0ZKrQwPm+hwXIxGsJeToymSZkCt5oVh4mMgtulUhcoPQ2nqhpVPrhydY3TeR326pTzslE1zWl80VSFdDp3Pct4a1DznkNFITuOzuejotLCsiySyRSJZILISITMgIHb485Z0njxeL2OyXRN/eRZ2V6Pm1BNxYLU/tnM1yi4haKiooLXvOY1vO51r5v2cRw9epS77rqLD37wg3ziE584LVY35xpSAErOaGwBuG/fPo4dO8Z5551HU9PsOvPKFYC24GxoaGD9+vXOh0IptXulMFEA9vT0sGfPnikNl0tZoxTskW7RaJTLLruMjo6OOTWSKIpC/9AIhpbnvycEff39nDhxgmVLl1JTW5tNBQOx0QhDJ45mOzWVrNGzyxWmqqoSI2ORTGXrvfIbAPy+rBj0+H3TjixzFTF8zm0SFLUk8TeWNDkyFGM8lRWANQE3y2uDuClN/GU7buO4VRWfV0Mo4NFgYCxNVyTOBYFKcvM7nLo5K3fNhLBy/2+iYqFYJggNj9uFx52tjzPGU+gajI2OMTCQTRd7fT6nQWKiv2JD2MOKugBdQzGiliCTsfBoGqvrAk7Tzcwo2bR3LrpajsWKs4KiZIW7na0W2WClUiz3PBUia9OSj65rTpe2qqr4/T78uQieYRgkkimSiTgDg+NYlsDr9VDbsBRTgD6hUWHdimV0HjqwoGnJeDxeVmZjsfH//t//c/6dyWRQVbXgi6r979bWVh566CGi0aisBzxFSAEoOaMRQnD06FHcbjfbtm2bkz1CqQLQtlzp6uoqKjjn007GsrJRi71799Lb2zut4fJ0a5SKHWEMBAKOV+Jc08gZw+RwTy8tLa1A9vodPXqUaDTKmjVrCp6zseF+ho4fY2LGT1UUDMMCFbw+H16fjyqqMA2TRCJJMhmnfzCaNVvOGS37fL6Cei9FUUhmDEaTBinDwqUqeFUrV96nlmS5Mp402HMiSjJj4ndrWELQPZohnh5lU2No2pSpENnu5WjawhAaIZ+eNbzOPT6PpjCaMMhkTFxatj5vkmNK3vI1ARfHIknSlsCdC0ilTQtVV1lWF6Yh7MF0zKgTDA4OYZlmtvvYl20mcbtcaJrGpkY/jSEXw4kMsbFxaoJummv9JQsvVVVPirfZNHaKXOpdyT4HuqZhWGZ2TF8ZmQFVmxzBLWbRY6PrOqGgTigYQOTqB1OZDLj8HDx0CE3TCAaDhIJBWpc1U19bzaH95oJGAGOx2LykgBcS2++1mBdrOp0uEHxncrRzsSMFoOSMpbe3l4GBAYLBIC984Qvn/KZcinDLrzHcunVr0Ten+Wi8sNdJpVL84Q9/QFGUWXUVl2MDc+LECXbt2jVpVN1s08g2h7qOY+RSv/n1fuvXrz/5ASAEQ309DPf3TLq/yKsLM63sODddU3BpCpquEQoFCYXDWKZJOp0ikUwSjUUZGh7GpevZ7lmPF93j5eBAnJFExnk8Xg3CilKy395ANE0iY2Y7ZpVst6/HZTASzxBJGCwJe3JRu+zxduNr9nzZ6J2KhbAMLFNB1bVsV20uauVE/UqgvsLLsoRF93CUaO7lpiqwtNLLkty0E01TnY5ZyDVIJBIkkglGIhFUTSPg8+H2eqnw+agKuBgQMdxutXTxp+lYppGdYjLL172q6079oaqcnGTiNPqUskaRCK6uqRjTCMB8FAXcbhdNy9cQrKxBWBaxeJzo+DjDkWFCbnj22RiZTIaxsTGCweCcx0aWixCCWCx2RkcAbfG3Z88eIpEIl1xyidNY9uijj/Lb3/6WNWvWcPPNN09r2yWZO1IAShYNpX7wmabpjCCrq6vD6/XOyzfymSZvDA4O0t7ezpIlS9i4ceOU55zNBI9iJJNJ+vr6aG5uZsOGDbNKO5UiRvObWIr5Fs4lAniif5Dh0XGEEIyPj9PR0UF1VRXL8jwEhRAM9HQSHRkuuoZLV8lkLPrGU/RHU2SMrC1MbdBFU0W2xk1YZq7eK9csUVGBZVkkkkmSiSQjoxGOjRqMGBpVfg9ejwtFVRmOGcTTFqvF5NFzNkJkHU00VWUkaeF2adk6M6cDOWsrkkwbYLkKLUXyr2Pu/2uCHgIenbG0oELJ7tsUgpQpWBnyZLt3S0ARCuvrfNT5NYbj2eaRar+LmoAbdYo/pUIzasgYGWKxGGNj2e5it8uNJaycmBLZJoxpN5FN2yooJzt0y0RRlMK0vYLTuSIsQUkK0OnKOYmmqmQMq2QBCeDxBwlW1mS3oaoEg0GCwSArljayvLmeSCTC7t27OXbsGB0dHYTDYaqrq6muriYUCp2W1HA8Hj+jo2L2Nbr33ntpamrisssuA+CnP/0pb3rTm2hsbOTzn/88hw4d4p/+6Z9k+vcUIgWgZFExU8QqFovR3t7uRMSOHz9OPB6fl3NPFQEUQnDo0CHHVmbp0snF4RPXmUsE0D5fb28vFRUVnHfeebNeayYBOJ2JdP4as4kAptIZ9hw6ggIMjifZebwDPVBJ3AgihhMsrfKhCIu+Y4dIxsaL7x8FwxT0jac4MpzArSt4XCqGKTgWSWEJlZYqT/H7qioBv59gIEDKMDmWGiGUMbDMDCMjWcsJTVGIGjCeMKkKepyInY1AQK5zVgBeHcYTFngslJzgsXWPXoJyU1UVLIs19UH2nRhjOJ59bizDpMKj0FJVWoRX01QskY341QXd1AXL/5BUNRWv5sHtdlFVVenMLo4MR4jFYkSjUcfOyOsrYkadS50LTDRVdaJ25aKgYmE3fhRGEYUQjrXP9I+lMPWbrR8sPXpoU1O/bNJt2YkfjWiaRl1dHUIILr74YiDrwxmJROju7sayLKqqqqiurqaqqgq/339KjI4Xygh6vvjjH/9IKBTi17/+Ne985zvp6Oigvr6ej33sY9x8883cf//9PPHEE7zxjW/kne98J42NjQu95bMWKQAlZwz2aLVly5axdu1aVFWdt3o7yAq3iWPTUqkU7e3tpFKpkm1l5hIBTKfTtLe3k0gkaG1tJZlMzmodm+kE9cjICNu3b6e6urqoiXQpa0zH7oOdpNIZjvQOsX8wTaiyhkDARzRlsqNnlLFYgqp0L5lUovgC2ZZdTNOiP5rCrSsE3Nk9unQFFJOBaJIlIRfeCeJL5GrKsj59CsIERdPxuzzZ+wKZdCo7Y9Yy6O7pJh7wOGLH4/E4UTSF3JcDy2JJ0MNgNE0saeJzZ70IxxImAbdG9QwNE4JstBU1210baKlkMJoiYwk0K4OWieN1zSwis4bJSslG00XXUDU0hWydXQ5VUwkEAkSjUXy5pppEMmtGHYlEsoIxZ0Tt9/nQXW4sy0BTlVmLP1XVsSwj97iytjz5ZO1pphdRyhSp33LS0UJAuLoOt29ybd36lS1OtN8xk9Y03G43zc3NNDc3I4QgGo0yPDzMwMAAhw4dwuVyOWJwvoyNTdMkHo8vyCi4+eLw4cNAVjxHo1GeeeYZLMti586dXH/99XzlK1/B4/EwMDDAD3/4Q/x+P//f//f/FdQLSuYHKQAlix7TNNm7dy99fX2TUpTzLQDzBdfQ0BA7duygurqaiy++uOR6n9lGAEdGRmhra6OiooJt27bR09Mz5+hmsQigEIJjx46xf/9+1qxZQ2tr67SRitmkgE/0D9J9oo/DHR2cGDcQmptldSfFczSa4eC+3ayt9RDwFE+l63q2YzdtWGQMgceVi0Sq2YJAt64xlhRkhIpfyzZUIEBYVu7fFpqiYhgmLgUCLoWReJoqlxdhmbhcLhIZgVvPsLKlCTOTznaD9o9lo33ebOdsfsF9bcDFqroAXcMJRuIGChDyaqysDUwSoROxZwarKAhh4nepTsQvGouRG4YwLYKc0fQ0M5BnRAGwJomt/JMoioLL7cLlzqWLLXLTSZKMjY0xMDiIx+XKWvH4fHjd3kmNO6VsxBZ/QPa5mjij1+4Cnm6VnMA/uWrp6ejjoyn29I4xlBB4loS5JDrM1pWV6DnrnNqqCpbUnPQCtN9rJqZ6FUUhFAoRCoVobW3FNE1GR0cZHh6mq6uLPXv2EAwGHTFYWVk5q7KVWCwGcEbXAL70pS8FoKamBsuyeNGLXsS3v/1tmpubuemmmxBCkEgk0DSN888/P/talOLvlCAFoGRRMTHaFI1GaWtrw+VyFW2CKDYJZLbYYlIIweHDhzl8+PC0UzamotwmkHxBtnr1apYvX46iKPNSSzhxL6Zpsnv3bgYHB7nkkkuorp55nFW5+0ilM/zh+Z0cPHiQUEUlik/gEzHn90YiRmbwCJlMikTGlROASu4xg1AEmqphCgtV1XHpJqqmkjYFmqaiWAAWGcNEVwQa1iT/vdwkNycKpCjQVOEllkkyHE3g1lQypsCyLGo84Pe4wONyukGdZpJolMhwBE3X8Hl9BIIBmsJuagMuYqls/V6F18UMVnu5a2ih5TU7FFBiqZtL12eeXzwDqqqhIjCmiepOFF2KCl6fF6/PSxWVCAti8RiZZJKBgYFs97XP60QOXSXMLs6+Nm1BpWSbNSbcR4jpL4yqapNsfyZGJBUlOxJFUW2f6Wye/1gkwe86hrMNSuFG4knBL/cN0BdN8ZrNDWiqyvqVhd5z9t/STLV+mqY5tYGQjexHIhGGh4fZt28f6XSaioqKgvrBUt5j7C+EZ3IK2HYxuO222/jP//xP+vr6+NWvfsVb3vIWLrjgAgB++9vfsmLFCl784hcv5FbPeqQAlCxKhBD09PSwd+9eWltbWb16ddE33fmMAKqqSiaT4bnnniMWi3HppZdSUVExq3WEEE6323QYhsHu3bsZHh6eJMjma46vvUY8HqetrQ1VVdm2bVvJI93KSQELIXjiN0+z/8ABli5dSk1NDftHjjGeexjp6BjRwWy9lFA0VM2uoctNp7BMTNNC0U9+2GoK1PpdHBtJouTsUjJmdsxYfciDb4q0qaqomHkRpZqgF01R6I9qjKcMQl6NSg9kxgqjrPnNJDXVVWQyRraZJJVmYGAA0zTxerz4/Nl08Ux9EnYXsKppxcVfiShTeRiWgarpIKzJkbY8pp2RTG6+MibhUBArEKCKmtz4tVy6eDibLvZ5s9fH75tg1m2vYadtbb+bIqfMzt4tvG0sYXBoIEbfeBKPy82KGi8ra4OoqpKNIlpm1tA755lod1iLvNNZwM6eUQzDIuD3Y4Vr8CkKiYzJ7hPjbF1RyYvOX4XfV/g3YlmW8+WsHNxuN/X19dTX1zsRLrt+0B63ZkcHq6urp+z2j8ViuN3uM7oxwn5fvPPOOxkeHub555/nla98Je9+97uBrFj+8Y9/zN/8zd8s8E7PfqQAlCw6DMNgz549DA4OctFFF007+Hw+BaA9wm3JkiWOB95ssFM7MwlAO7ppexh6PIXNDPNhKG2LN7uDubGxkfXr15f1AVZqCtg0TZ763TPs3n+wwN+vMezixLBgbCRCeugYlhCMJzME3Doh9+S3ID1Xb5dPU6UXC4XBaJKxjEBXFepDHmfc2UQ0TS3wf1Ny0aYKn15gUpxKp+kt3n/iRBBVVSUYDOH3mVRXVmbNg3OTSSKRCKqqOlNJfD7fpNFiuq5hCpG1e5mW6TwEBbqiTBu1mwnbaHmmp94eP1d8jex1tGe62scVposFyVS2+3psdDTbXez24Pf6slFErzc7ki7HJPsYYUdws/OiVU1H1TQQMBLP8OTBYWIpA03TGE0kGBhLMDie4gXLK0/67jB9ADKVsRhNGrh1FStY70QZvbrKSMJgIC5YsbRh0v1M05xzp6+iKPj9fvx+P0uXLsWyLMbHxxkeHqavr48DBw7g8XgcMVhVVeW8F0Wj0XlrLvnSl77Epz/9aXp7e7nwwgv5whe+wKWXXjrl8ffddx8PPPAAXV1d1NbW8trXvpZ/+Zd/KXs2uKpmZz1XVlby2c9+dtLv3W4399xzzxnvdXgmIAWgZFExNjbG888/j9fr5fLLL58kiiaSPwputgghOHLkCJ2dnXg8HjZv3jynN1hbAJqmOWXdYG9vLzt37qSlpYU1a9YU/VCZjwigoiiYpsn27dvZuHHjrGZqltIFnEgk+OMf/8TejmOsX7cOV16EornCQ5caY+h4H4aZteUIuDVaqn1oE8I7iqJgGlZB4X+2CSPb7VsfcpE2LFyaOnXDhAJWgfjLdoiW+4xmmwusk/e3xU5uMkk4HMYSkLInk4yOZidveDyOGPT6PLnHPLcPbLfHTSZdfLZxSeSaYlRVzNgcIcQUlkx5UbpiIt1GUZVsKjhn1m2ZFmPRGAf6ohwfH8MQKg0hjbV1QWorAtlubE3L6jaRq98EhDBzzR2Wk+bdc3yMWMog5NVzkUGdlGFxdDjB2voQVb7S6up0LTtd2NB8aJ6T6VS7dHBV69KiNXqWZc27CbSqqlRUVFBRUcGKFSswDIORkREikQidnZ3s2rWLUCjEo48+SigUmhdh9N3vfpf3vOc9fOUrX+Gyyy7jvvvu49prr2X//v2TbKAAvvWtb/GBD3yAr371q2zbto0DBw5w6623oigK9957b8nnTafT9Pb2OmPdDMNACIEQwhG5iqKc0SnuMwkpACWLiq6uLpqbm1m5cmVJH5pzrQHMZDLs3LmTsbEx1q5dS09Pz5w/rO37FxNv+Z57F1xwAfX19dOuM6cJHJkMe/bsAZh1OruUfQwNDdHW1sZowmBlkRF16fgY4cQJWpc0kMhY6KpC0KujTxB/E6NK2dsK58N6dBXPTM0WealfRVHAssoWf/l2JBNHi+WjKuTmyPqgqgrDzE4mSSTijPWPoioKXq8fj9eD3+9D18p/y1U1dW7iD7KG08LCNKeO7uWTf4hpQTxt4HW5cCnZa2lNiNihKqh2kZ2q2CoSBYFlQftAhr5xgaZ5UC2T7jGT4fgoGysieF0qvlz9oHfC7OJ8Gxgh4MRYEpeuZDu8c8+LW1MYNyxOjCao8pUmHFyqQmu1j52pWlRT4NIUTEswljSoqargZRe2Fr3ffEQAZ0LXdWpra53MRyqVor+/n/379/Pb3/6WaDTKX/zFX/Cyl72Ma665hgsuuKDsPd177728+c1v5o1vfCMAX/nKV/jpT3/KV7/6VT7wgQ9MOv7pp5/m8ssv5/Wvfz0Ay5cv53Wvex3PPvtsWec9ceIEt99+OzfddBPXX389y5cvL3qcYRiMjY1x5MgRLMtiy5YtZZ1HUhpSAEoWFZs2bSpL9MwlBTw6OkpbWxvBYJBt27YRjUadepy5MFUDRzKZpK2tDdM0p/Tcy2cuKeBoNOpEUmFuXYNTRQDtMXwHDx6kekkDmdHJHcvR0WGGjnchgIBHJzBNQFfXJ9jwCPsalP78qsqEdKKiOEKhOEXUUC71KwQoWta3r1R0TSMUDBAKBtBUhWTaIBYdJxbLWoTouckkfp8Pj/fkXF7BFH53ilKSD950KKqGaRjomgZKCSnkvOf68GCCQwNxEhkLTVNorvSxeWkYTQFFWHaszplPDEDe0yWA7pEE/WMpgm4NTddRRNbDcDxpkPSEWVbtKoigut2eXATRe/JLQfZSZJtFDAVl4nOqKJOiyTOxdeNyxnpcdEUSzkMOenU+cOOlhL3FPxpPRQRwJjweD8uWLeM73/kOP/jBD/i3f/s3rr/+eh5//HE+9rGP8ctf/pKtW7eWvF46nea5557jgx/8oHObqqpcc801PPPMM0Xvs23bNr75zW/yxz/+kUsvvZTDhw/zs5/9rGCubynU1NRw/fXX8/Of/5zHHnuMlStXcskll1BXV0c4HEZVVSKRCNu3b+cnP/kJyWSSb3zjG2WdQ1I6UgBKFhXlRt+yqaPSGi5shBB0dXVx4MABVq1axYoVK1AUZd4tZfLF29DQEO3t7dTV1U07RSSf2aaA7fTy8uXLaW1t5de//nVZ12cixZpA7G7ioaEhLrhwM7s7Jgvn6Ogwfd2duZ9mEh5KrmZPcY5VdS07X7YMTqYPs5HDmevuJm8t20hgoc3i/A6KgkDFpWtUVlZSSaUzmSSRSDA0NISR10ziWNdMQNd1jEz50b+0adE7liKRsfB7dJor3JiWnVrP/jfpT02QFYiKgqoqHBlKsKN7DAWBx+3CMA0O94+TSmV44crKkmXpcCyDADTdhZITibaY64+mOb85fHK2sz27OJFwuotVTWNsbAyfz0dLpYd9fQkMS0VXs6/LhCFwadAYnr5cpABVo6l5GW9s0TnYH6NvPI3PpfEXW9awZf3UUfm5/B3NB/F4nLq6Ov7+7/+ev//7vyeTyZS9n8HBQUzTnJR9qK+vZ9++fUXv8/rXv57BwUGuuOIKhBAYhsFb3/pW7rrrrrLOHQwGefe73811113Hww8/zBNPPMHPf/5z5wvz6Ogo6XSaCy64gPe+97289rWvLWt9SXlIAShZVMxGAELpqRnDMNi1axeRSIQtW7ZQVXXS42u+RrjlryWEoLOzk46ODtavX8/SpUtLfozlCkDLsjhw4ADd3d2OX6L9eOaSSp6YAk4kEmzfvh1VVdm6dSv7Oo+RzhTWYY6PDNHfcySXCmTGGkJVyesGFgJF08sWX3pel6ymT7YHKQVVUbKNH9ocxB+5GbRG4TW3J5ME/H5nDFsykcjN5s36Tw4ODaK7faguNwGvF6apb82aXWftcxTs1LnCSCLDn7tGGUsY2YyssOjw6VyyrIKwT4c8kTx5UbJ1eAI6BrPWPUG/B0WYuFUNXctOZRmKZagNlNYkpee+6+TXUaqKihAGrgndwRNnFw8ODpFOp52Gm0rFRYVbMJoysYWsW1O4oDk8ZdSuGBU1S9Bc2TrV9Q0h1jeAz+vhojWTJ4HkczpSwNMx0QT6dPnjPfnkk3zyk5/ky1/+MpdddhmHDh3ine98Jx//+Me5++67y1pLCMH69ev5yEc+wkc+8hH27t3LiRMnSKfT1NfXc8EFF5z2KOu5ihSAkjMa+43CMIwZ3wzHxsZoa2vD5/NN23Wbn3aay77S6TTbt29nfHx8VjV45QhAe2JJOp0uSC/bH1ZzEYD5KeDh4WHa2tqcecj9wyP0DhTO8B2PDGbFX46ZruXEjl1Vd5U95UJVVTKGmYsszU78CQFCOdk0MltUVcWwbG+T4igKuF0u3Lm5vGNjY4xFo3RHBd0jEVKGhdet0xz2sKGpAq/HczJiZ6deLYFip1/B1s7s7I4wFstQEfCgYiGEykjcYPeJKC9cUTmj36AQgrQpSKRMPC41G0VVsmLTBcSFRSxllCwAG8NeDgwkSBoWPpeKgkIykxWnSyun7yDVVDVrx1NTjRCQSiYJ+eN0ReJEEgY+t05zhYeGsOaMxpsJVXcRrp4c5cuf+DEVC5ECzmc+xsDV1taiaRp9fX0Ft/f19dHQMLnzGeDuu+/m//2//8eb3vQmAM4//3xisRh/93d/x4c+9KGyXQXsrI2maWzYsIENGzYUHLPQkdZzBSkAJWc0paRuhRB0d3ezb98+VqxYwaoijQpwMp08HwJQCMHu3bupqKhg69ats/LtKlUA2hNEKisrJ00sma4hpVTsCODRo0c5cOAA69evZ9myZaTSafYf7kJXT34gjkX6GTzRVfDmranZKjZVVYuEnZSc15uCYRoMDAximSY+v4+Az4/udhWVUfl1cZawsh/8WnY0oGWapbkqZ++SsxxR0DQFS2RrBvPrzkohljToGkkyGE3jdbuoD+o0V3pzDQ12ujUv7Zp7UFlhLVBVhd449KUEuttLwAfJdIbOoQTxRIyWAHh9Pnw+Pz6fF5euI4qondFkhpGEQdCroSm5aKqqEPRoDMfTRNMGFd5C4TY5Oqvgdqm4dJWUAR795HGmJVAVFa9LK3pxil2uJWEfG+vT7OuLMpbMRjRVFZZX+1hR45+hxjF7bRQUVF3LNYt4WVJb7aSLE4kEgwMDCGHh8Xiz18jvxeVyZQsKJjy8qrrmSc04NdUV1FVXTrOPLAsdAYxGo3MeA+d2u7nkkkt44oknuPHGG4Hs+8MTTzzB29/+9qL3icfjkx73xPF45WC/b0+8v/13J8Xf6UEKQMmiYjbCazoBmO8pePHFF1NTUzPtOjD3N/nu7m4SiQSNjY1ccMEFsxaTduRtKkGaL2zzJ4hMtc5sseecHj58uCBtvu9wF4lkyjluLDLIQF7kz8YSYOW+8U/eG1iWIJnMdjp6PG48Ph/xeILh4Qiapjlmwl6v13le8uvlNFXNWq2oWtn1cqYFIymInhgnZVhU+nQawl7HXNrK2afYIsUWco5ZnYDxZIbt3eOMJQ3cLp3oeIKBMRhLGmxsCJbUdZsyBH0xC5dHIeB1gbBw6xq6bhJDEK4JIjIpxsfHGBwcxOXSnbnFPo/Xsc3JTjcR2SiosFBQsvWQKliGwDCzz8V0CGGhKgrLa4PsPj5CMqPhdWlkTIvxlEFNwE1twF00h1x8ZcGGhiANYQ8D0QwZ06I26GJJ0JO7hFPvJxvVy451sUyj4FK6dB0tly4WQDqdTanHE3GGI8OoqlbQXaxrKi6vn0BlNVbeOVVFYd2EiR9T7mcRRADnYw7we97zHm655Ra2bNnCpZdeyn333UcsFnO6gt/whjfQ3NzMv/zLvwBwww03cO+993LRRRc5KeC7776bG264Yc7XYz48DSWzQwpAyRnPVAIwGo2yfft2x2h5JsNSW1yYpjmr2pr8mcXBYJC6uro5vbnlp28nvsmapsmePXsYGBiYUdjOxU8wkUjQ0dGBZVlcfvnlzjXsGxzmRP+Qc9zY8AADx49OsYpS9CNeVVViyQyxWJToaITKqipCwSBCCCrCYYQQJJNJEvFs/Vcmk8Hj9eLPecwJVad/PM1ANIWq6dT6NBrCHlxavo8MWfWjCBTUkwIi97wcG43RGVXwiQwaMBDN0BfNcH5TiIA7d7w4KReKaaeuoRhjyQw1QU/WN9DtIpmx6BlJ0lThpdI/89ts0rDIWBB0uVAQznm8LpXxpEEGndpKH5WVlZiWRTKRayYZHMIyTTze3Bg2twevx0UinSbsdTtiL54y8Xs0Qt6ZP6ztiOyaWh/JdIZjkSQjiTSaolIX9HDxsvCMo+9sVO3k6Lsqv4vqgLusLyNCWNlRbopS0MCcb9MDWY3tcbvwuF1UVISxLOHMLnb8Gd0emlauy4oovz9rJQOsWNaI31taA8lCRwDj8fi01lGl8td//dcMDAzwkY98hN7eXjZv3swvfvELZ+2ursIo/oc//GEUReHDH/4wPT091NXVccMNN/DP//zPc96LZOGQAlByxlNMAPb09LBnz55px8hNRFVVxzi5XPLHrF1++eXs3LlzXub4wmQBaDdhKIpSsrCdjQC06/1CoRC6rjvnSaXT/K79AL0jWdsXT3qUVOT4lOsoRfJwkViGY5E4A6NRMhmDpuoQ9b5g/iAHFEXF7/PhD/gBFdPIEE8kSMQTDI+MczQKCUvH49bRdZNIVGE0ZbKxPpiddpFrQEFY2fo4zAIhGk2bHIvEcauCGr8LLBMhVIbjaY4NJ1jfUEKkRcBALI1HV3NiJXuz16UST5uMJTIlCUC3lrUxyRgGunLyuc6YFrqm4NVPilpNVQkE/AQCuWaS3Bi2ZCJBMjJCFSrdaYWBjIHXpZMxs8bHa+oCk7wXp0JRNTQVNi8Ns7rOz1jSxK2r1PhdJafFlVzULn/fM5lQT0QIgaJO7uaeaR01z4waqnJzhnVU3UNXVxeWZREIBKirqaaucn3JZR+LIQI4XybJb3/726dM+T755JMFP+u6zkc/+lE++tGPzsu5ISsyvV5vUePpdDqNrusyFXyKkQJQsqiYbQrYngaSH4XbvHmzM3i8nLXKFUv9/f3s2LGD5uZm1q1bh6qq8zLGrVgDhz3SraGhgQ0bNpT0BlnOLF8otMlZt24dPp+P/fv35/Yi+PaTO3h2fy8pw8IYH0KN9tFc6aWxwpszclZzos9+HBooKqqa7UAdT5ocGIgzPDaOWxFUhsMMJwUHB+JsqPc73nhO3NASgImmqoQCAUKBAOlIAiMxTthlYRpJrLSJqml0DyWpdMPS6pnF21jSIG0K3KriCAxFAZ9bYzCawrICM45Ng+ys4rSqFqQnT4rYme8P4NEUqr0qI4aFpii4dYW0IYilTJZW+QgUGZlnr+92u3C7XVSEwyiKRl1snIpInKNDCWKpJCGPRkuVlyV+1fZnnh5FyY1q09BVlaBHJ+iZxUeFojoDeLM1nlbJ18MmawRd+NrVVQ2jzCYdXddoWrkel8eHEIJUMsl4NEpV0Mvzzz+Hy+VyRq9VV1dPmQFY6OaE+UoBLyTpdBq3281nP/tZLrjgAm6//XZM03TepzRN4wtf+AJbtmzhyiuvnJeabElxpACUnPHY00BisRhtbW1omsa2bdumHKg+HeV4AQohOHjwIEePHmXTpk00NjY6v5uPMW75Kel8O5kNGzawdOnSstYpdS/5qWW73m9wcNARkH860MMze4/hd+uErHHixjBxReFYJEnQ68paceRsRGyEyI7ysqysSD8+NMrAcIQqv5tQ0I+iqPhcgpF4ikjcVVKUaSxl4spZhiBMLNMiY2SIj6c51jeEFRvKTujw+/FNmC6RtzFQ1EmTPoSgdFNhBZZWB9ndM0JG0XHpWZEVTRl4dZXaYGnNP6qmsbpK53jaTd9YmmjawqWqNFV62dgYLEk42d3L4VCItX4/a5vBNMxs1DSRoL8/2/XpzY2p8/m8k0cVChBWNnKqqSqZWYi2/L1ArshfKeI7WOI6+fdTFaVs8QcQrKzF5cm+HyiKgtfno6W5kc0b1zj+c8PDwxw9epTdu3cTCoUcMVhRUVHwtzjVeMfTwXxGABcCIYTTEPeHP/yBtWvXAkyKqn7ta1+jqqpKCsBTjBSAkjMeTdOIRCLs27ePpUuXsnbt2ll/Sy9VAKZSKXbs2EEymWTr1q2T3pTny1RaVVXS6TT79+9ndHT0lNrJJJNJtm/fDlCQWra7gDOGwW/a9mMJgdsYJzbUA4DfozEUTTOaSBf1YssOBMvVosXiHOuPEPC6CYdOXjNVzTZUJDMz71NA1gRY0U5GmDQVj+bBa6gsqfaxJKiRSCQYy6v/8vuzwse2/6kNefH2xxgzwXaDtIQgmTFZWesvKfqH8v+z9+dBkpz3eSf+ed/MrMq6q/o+5sBcGGAA4iaAgUTJkimRK0o2IyybIckmzZC4EWtBSwprB6mVDWmlXdMkZQV0hRk66CMkLiXZ/tEKyaYOeGmKIkiJmAPAAHPfM93V1XV23Xm8vz/y6Ko+q48BBnA9EcB0V1dlvZl15JPP9/t9HsnejEG5bpJf6uB2vPWYuuTeyQSxyACG38KzrZFC8eieDLW2Tct2iOkaaVMfkDiJcOij11JH0zVSqSSpVBKloNvt0Gq1qNeXKBWL6P4wSSwWw4yaSF33Jof9Y7Ht824Pqd4oN3jDPRL4JWSPMCilUNtYkJAa2fHpvtukENzrD35omhaSPfA+2+VymVKpxJkzZ3Ach2w2y8jICN1ud1sXlruFRqOxo1SftxIBkfuVX/kVqtUq+Xyeb33rW0xOTmIYRki68/k8nU4nzAse4s5hSACHuKuw1Ss913Wp1+u0220efvjhHTdID0LcyuUyp06dIpfL8eijj66pCOyWqbSUktOnTxOPx3nmmWe2ZSczSKbwSn+/XgIdTBG/cfEarU4X1WnQaPT3/Elg3d31jaAr5TLVSoXRbJpqt/8uSnnEztgk5xfA0DRGkya3qx3alovpT+y2ui6aFIwmIpimjmlGyeWyOL35vLUaALGYSSKZZH/W4Ewdis1uSFRHkxH25gY7yRuaxFIuD82mKTY61NoOmhSMJw0SA5VNBQrXI8C+TUwmppPZ4lezkBLlOsgVnop99xFerFg0Gg2HSTqtNs1Wi8XFIq5yiUaiKBTKdT0CuKVV+M+j9fswbof8efukoVzlDYGwfSKZGZtE0/tLuhsNfkSjUaamppiamkIpRaPRoFQqUSwWKZVKVKtVWq3WpuXiO4FGo0E8Hn/Tnm83ERDAN954g5MnT3L9+nW+8pWv8I1vfIN2u41lWViWxdLSEn//7/99HnroIWBoCXMnMSSAQ7xtEQxeWJbFnj17dmU6biPi1pt9e++997Jv3751CetulIDn5+exbZuJiQne9a537dhOZi0opbhx4wbnzp3j6NGj7N27d9XzCCEo1+q05SIZ3aa5cI1ITPNJCziOQgkvR3W95wBYqi8xNTND2tE4c7tKvWOTiOi4yqXWdkhENXLxjU+mQggcFLmYxp6cye1Km2bXG+6IaIL9IzGysf51aJpGMpkgmfR6pzqdDl2rS7VShW6HA2lwdRCGTi5hMp5aMUm8DjSpYdm+AilhPBVlfIvijJQSgeevt10E5VZNrk/+1oImJfFEnHgijnIVtuvQbDTptFvMzc+HNirxWJxozEQbqN9U4jpOSBy3M/jhbccjkQoVuO1s6xhpRmSV6XPcjHJgz/Q6j1i5DkEymSSZTLJv3z5OnjxJIpFASrlpuXi3EZDRt6sCGByXX/iFXyAajfKJT3yCv/f3/h733Xcf9Xo9LK9nMhnuueeet3ax/5NgSACHuOswyNBCPp/n1VdfZWZmhmw2u2s9IuspgBtFyK23HWsbGa7gqZoXLlzgxo0bGIaxpfi4tbAeGV2r328tOK7L1VsLHDKTiMpNsjGdctOffAW6tst4MspIYrU6ads2+XweoWBmegYjahJ1bA6NJ7hZblFpWQgBaVPn4HicqC5x1yExSikv7s03fj48Fmc8GaHashBAJmYMFAeWSCSIOlFSqRSddoe5+TmSCUGzVcOu1qh0Y5i+f9x6/V5CaqGJ83Yhgz653omZLSMY2Njc328jaIaBcATpdJpqpczM7Kw3XdxqUa5UsAsWkWjEN6P2yuhrviN77FqkFNsif17LYOCU7X0f6NskkrmJ2dDuJcB9B/dtm6S5rks6nQ4TMzqdDqVSac1y8cjICPF4fFf715rN5tu6BxAIp34/+9nPEovF+vYnn89v6mowxO5hSACHeFshyLu9ceNGOHhx4cIFOp3O5g8eAGtN7wZ+gqZprhkhtxa2WwLudrucPn2adrvN008/zcmTJ3esJK5VAl6v328tXLx2i1a7xdy1C2jC5chEgoW6TqlhIYG9uRjjyeiqGK5Wu01+fp54PI5jWRiRaGgLMp0xGUtEaHQdpICkaSA3yQwOyB89SlDG1MlsIQNWaP2vi6ZpCARj42OgoNPt0G61qdfrlIolDMMIyWAsGgPpqVxSKRy1/ddF+D17mtRweiaQt7wdv/S7XaXNe14Zvi5eJrNCSNljo9IzTNJuseSX0c1YzBu08YdJej3/VPi/rUPTdZS/HVcptG1OEEdiCeLp/ouaiZEsYwMkfqyHlVPA0WiU6elppqen+8rFi4uLXLp0KZwuHh0dJZfL7bhc/HYfAoHlY/jFL36Rffv28YEPfIBIJMJnP/tZ/uiP/ojR0VF+9Vd/lf3797/VS33HY0gAh3jboNVqcfr0aRzH4ZlnngntEHZr4GKtbd2+fZszZ86wf/9+jhw5MvDV/HZsYKrVKidPngzj4wIfrN2YJu4lVuVymZMnTzI+Ps6xY8c29DVbKJa5OZenunCTTNSbPI7okj3ZGHuy6/fJ1ao1isUio6OjZNIpLtcbOI7dd/wMXZJd1fOnvLLfGvqSQsAOj4UmwF7BTMIkip4euUw2g+u4tNttmq2mNwntKkzTJJ6IY0ZNdGP7X59CSoRysR0nLHFufRuegrhdixUIBqGXFxCoiCs31TdMgqd8tXuHSSJGSAbNqEcIne3kKQvRl8OslAtyexPEucl+5bx38GO72MgHcGW52HEcKpUKpVKJq1ev8tprr5FOp8nlctsqFzuOQ7vdftvbwAT7/JnPfIZf//VfJxKJcPr0aZ5//nl++qd/mr/8y7/k//g//g+++MUvbqvneYjBMSSAQ9x1WKsEXCgUeOWVV5icnOT+++/v+xK+EwTQdV3Onj3L3NwcDz/88JpmpRthqwrgzZs3eeONN1ZFuu0WAXRdd6B+v15Yts1rZy+xcOMyltVd9359UFBYLNBoNJiamSZmml6Ml+t6f9zWWAEYhrHtknoAXdexe4yJN4PUlnvk8A2X250OzXqD4qI/QWvGiMW9CVoxoHVMoJRpK61RtsJyAq8+/5But8qo6cuqna5JOpb380b5vAIwo1HMnmGSbteiUa+zuFj0MnkjUS/CLx7bkuolhewjgJ5SOtjOKSC/1OFasYUTSXEwbvHwrOPlFgMH980MnPixHraSBKJpGqOjo2FKT2+5+LXXXsN13ZAMjoyMEIvFNvw81ut1gLdtD+BKLC0tcfz4cQB+7/d+jx/+4R/m05/+NJcuXeL48eNvqeH2/ywYEsAh7mq4rsvFixe5du0ax44dY3Z2dtV9dpsAdjodvvWtb6GU4vjx49uauhtUAXRdl9dff518Pr9mpNtuEUDbtjlz5gwLCws8/vjjoeXFRnj94lWuXnydbqe1dgbaCriOw/x8Htd12bNnD7quY+g6XcvyJ4G3R1R2g/xJTdueIhVAQDRmEjWjngrmx7E12+3+OLa4VxY1DGNNriv9cuuqnrYt9u8JIVHKQdO2X/r1+geXjZot212WIrfwQumajmZKYj65ch2beqNJq9WiUin3DZOYMXMVgXJdWKh36DowEtNI+SV9IcD101UUAVkWoaegCDKZ/QN96maVV27WsBW0U2O8cjrPt65W+OjTe5nMJrhndmqbx6l3rdtPAllZLq7X65RKJQqFAhcvXiQSiYRkcK1ycaPRAHjbl4DB6w1OJBKcPHkSwzD48pe/zP/9f//fwPKwy5AA3nkMCeAQdy3a7TanT5+m2+3y9NNPr3vl25sEslN0Oh0KhQIzMzOrlMatYBDi1mq1OHXqFMC6xtW7QQBd1+X69etEo9GBouPAK/2e/Pa3aDWWCJnMBgJep9thfm4e0zSZmphCCi8Nxep9XbYxpCA1uWPyJ6QW+tqt/uOA2xAC1VNmFVISS8SJJeIwMhIOTLSaLSqlMlLTiMXjxE0TM2b2DCIIpBA7mvqVUsN1HT+20N2uqBr2D/apiGq5HL4ZurZLs+sQjxoEdoe6lNjopNNp0uk0ruvS7Xjeg5VqFau4SDQS9YhyLE7DlvzV5RLVto3rKiKa4NB4nMf3ZTG8plCEEMtDIV6mX2gbFKDUsHj1ZhWBwkyNEEkmcFzFXKXN/7hQ5PkPDZaasxl2KwtYCEEqlSKVSrF///6+cvGVK1fCcnFACFOpFI1GA9Ncw7x7G/iN3/gNPve5zzE/P8/DDz/Mr/3ar/Hkk0+ue/9KpcLP/uzP8p//83+mVCqxf/9+XnjhBX7gB35g22v46Ec/yic/+UkOHjyIbdt84AMfwHVdvv71rw89AN8kDAngEHcdhBAUi0VOnz7N2NgYjz/++IZfekESyE6glOLy5cssLCyQzWZ58MEHd7S9zVTJYP8mJiY2JJo7JYDlcplisUgikeDJJ58ciNBats3/99X/j0at4q0h5H9r9+Y1GnUW8gVyuSxZf5K4937Bz1vmf0IgEeyI/kqJFN6Je7tEyZtElUhNeZmyq9YJRsTAiBikM2mUq2i327RaLUrlEnbBwTQ938GIYRAzo8t9h8FTqAGX1zPQI4XAEVs7qEpBy3JBCGKGZ9fSqyIG6xIQ+u+FO+kv0FWKM7eXuFho0nEVhoR7RhM8PJNEF6Kv51RK6ZG9uHdxY1s2Lf/YFEsVvl2AtgNmxMAwoOu4nJtfIhmR3D+V9M2oNz8yNystbNclFtGx42OAl+aiaZI3yi6jua2Zp6+HOxUFt1G5+JVXXuEnf/InyeVyCCG4ePHilvqRV+L3f//3ee655/j85z/PU089xQsvvMD73vc+zp07t24u7/d93/cxMTHBf/yP/5HZ2VmuXbtGNpvd9v7qus5zzz0XDs387u/+LolEgmazyYkTJ/h7f+/vbXvbQwyOIQEc4q7D5cuXOX/+PPfdd99AFig7LQF3u11effVVGo0Ge/fu3bHiBOsTN6UUV69e5eLFi9x3333s3bt3W9vZDL39foGSMKia+Zdf+xqL+bnlG/zjvxYBLJVL1CpVJicnvV45747oEX35OG5nOAGvJ822d17aV2oAlWwDddNLx3Cx7cHUNiFFD+kZwbJsOu0OzXqdSrcDQhKLmcRicWJrlETXguUoqi0bXdfIROWKEnKgkPnb6fm8iB6LmWrL4dTNKoWlLiiXbCLCgzMpplPRPrInwk2seN/5XPO1mzXOzNXRpCCqS2zH5dxcFce2efKefqK18qOrGzopwxsmqReadPMlYjrgOnRtz97HdeHs/BJHx73eSzkA0QkEVTeWA7l8WpNCYKTGNn38IAj6aN+M0mRvudh1XX7zN3+T3/7t3+aNN97gXe96FzMzM3z/938//+yf/TMOHz68pW3/8i//Mh/72Mf46Ec/CsDnP/95/uRP/oQvfOELfOpTn1p1/y984QuUSiW+8Y1vhGXp3fDpGx8f51d/9VcB7zu41WoRj8fD24a48xgSwCHuOiSTSZ566inS6fRA998JAaxWq5w6dYpUKsXx48e5ffs2xWJxW9vqxVpDIIGXYKVS4d3vfvdAV9DbIYBBX2HQ7zc/P7+pr2KAN147zRtn3+i7LSTgrgIt+NFlIb9At9tldnYPRmS5X0k3dKyutYosrVS9NoKmazg7JH9S05CAvV0FVXnbcB3bIyGDlosVKL9frdiwKDctNE1ncmSCZFSGCli1VmOxuEjUNBEINKkhpEbQ2ib8vsmri01ezy/R6iqkcEmbOo/uSZMLM5OD4+qG6w53wf+5Zbl8/UKRWtvGjOhIYHGpzTcvWbznUI6RpOHff+NGzY7lcmmxhSYF8WgElIMhNaRwuVZqct9UYiAvxmBNQgqMSMRbu1K4rotuOTTbFleu30BDUW/UiccTGMb6GdHT6SivSo1WJEcw5qFQqFiW7zgyvitefKHy+iYnU0gpOX78ONVqlddee41vf/vbfO1rX+PP//zPt7yWbrfLyy+/zM/8zM/0bf+9730vL7300pqP+aM/+iOOHz/OT/7kT/Jf/st/YXx8nB/90R/lk5/85I7IcKvV4g//8A/52te+RqfTYWRkhOPHj/P+979/R+riEINjSACHuOswMTGxJUK3HQKolOLmzZucPXuWQ4cOceDAAYQQuzZQsnIIJPASDPrwBrU32Oo0ceDvFwywxGIx8vn8piSy2rIo3LrGX730zVV/W1nCtS2Lufl5dE1jz+ws0j8JdGwXKTWkY68iSyJgMxtAKVhqOTgK0tINNxFykkDNUgIh/Xxh1R8faLuKhaUOHUsRj2iMJgwMffVJSgiBAjTl9dRJqYW17o7lcHmxye1qG6VgJmuyfyRGoi/Xt7cJTS2TW19JVC6cvlXlZrmFjWf5Yhoa900mODAaIxaNQtYrt7daLWq1Km3LodVqhP57sViMhbrFqZsVlAuJqIZSknLT4q+vVfjuI6PEjMEIwI1yi1rHJh3zyB9CEtUl5abN5WKTkWSm51ivT5YaXYeu4xLRJSgbL4NYEdEl9bbNUtsZmABmYhrgmUVrEvA/f66tGElE2DOdZm5ujlarTaVSRfOHSULlVFve94lUlEP79/JqTdBpe4RdSY19eyf5sXevHhzbDoLP0Fs1nBDEwMXjcd7//vfz/ve/f8vbWFxcxHGcValJk5OTnD17ds3HXL58mf/+3/87P/ZjP8Z//a//lYsXL/JP/sk/wbIsfu7nfm7b+/LLv/zL/Mqv/AoPPPAAmUyGCxcu8O/+3b/jb//tv81/+A//4R0x7HK3Y0gAh7jrsNWr9YC0qQH7hRzH4cyZMywuLq6avN3NDN9gO0Fqyd69ezly5MiWrtq3ogAGGcWjo6M88MAD4Ylqo326XWnzlxcXuXD1BrfOfBPdtTyyY+rLxM/PY5WapNPpMD8/TyqVYnR0DCFhqWVzpdik3LDQNMiaBgfG4iQieqhmSSG8bUjZ4xIcUjwqLZtz+SWKS21sxyIVNTg8mWI6bbJ8uIIBBW8KIHylg6i5js2rt+pUWpZXqpOCjGnwrtkUyWj/STscKXAclOt4QxXKK7W+fK1Kod7BMHSkcjk/V2Wh2uLJe7IDE65rpRbXSi1iUYOU9I5fvW3z+nydkYQRmlcbuo6RSmHbDq7jkEgmaDVbVKtVFguLXKhrdLqQTZhI4Q1upKJQa9vcqrQ5PD7YhPpS2/ZeB6mBcsJjoGtQbva2PGyc/xszNDQJtos3pIH3/upaXgbyoMcHYCYTYzTZZHGpTUT3ejW7jkIiuG8qEZYbJycmQAg6vnJaqVQoFCyi0Ug4dR2LJ/nh7zzGoZt1Tt+s0bIc3vPo/fzYdx7e0K9yKwg+Q7uZ7LEVvFUm0K7rMjExwW/+5m+iaRqPP/44t27d4nOf+9yWCWDwHf3yyy/zhS98gV/6pV/iH//jfxz+/Vvf+hY/8RM/wWc+8xl+8Rd/8Y71XA7hYUgAh3jbIxgQCbIkN0Kj0eDUqVPour7mROx2DJzXQkBKz58/z7Vr13jXu94VxkdtBYMSwOvXr3Pu3Lk1M4qlXHuSttTo8p9O3uLWQhFuvkK72aTRsWl1LN61J4Op++VIoZBCUatUqNaqjI+Okc6kEUC9Y/ParSr1rkvc8CjjXLVFq2vz6L4MUV0DFFIKpFRo/rRpYOuhFLQtxeu3qxRrTTQcYrqk1mhz8kqb9niEqWzSj2Uz+iLCFMuekUopzi940XK5RBQNF0dBuWlzYaHJE/vTrFnD1RRSCG99QnCr0mSxYZFNRpF+IkY86kXf3a60uXdy+QS8PDCx2rfydrWNlGDqwiPQCBJRnUrLZqHeIWMa4VbCMq7AU7hME8hh2w6vv7GAxKXdbKDwhk0CEt2yBr9Q8V5LCa4TznN4+bp4RL1nrzZigLGIZG8uwaWFOhJJRBNYjqJluUxnzU2znHshpeC7DuV4+XqF29UOtlIkIhrHppIcGI2HkYBCSIRk3WGSWrVGPKdwb93icDrFo09Ns2dqgofv31pv3GYILGDeSgK4UxPosbExNE0jn8/33Z7P59f9fpqensYwjD7l8/7772d+fp5ut7sls+aAAF66dInR0VH+8T/+x9i2jWVZ6LrOU089xYc+9CH+x//4H8CdG7oZwsOQAA7xtkfwxbQZAQyUuD179nDvvfeu+cWyWyXgQJHM5/McP35821fugYffeljZ77eWv996JPL1uSVuFWuM1i9yrVoloksiWoRio0O+1mFPzgwtN1ylKFcrTE/PYJrRcABhrtKm1rYZS0RCIhORglLTYr7qbwNwXYVtu2ja6nXcrjTJl5ZIRCGdTIFSpOKw2OhQaktitRoLhUUMwyAeZNGaZl8/2FLbpljveJFyuLjeoCuJqGSx0aHaskhGV783HMfFVQrXVSihKDc99VAoNzxuAm+idLHR5dCaZHx1abvreOVwpZS3nZ7eOu/lXH5MECksVkSC6LrGSCpGw+n4BsYKy7LpWhYdy6WzVKNUcsJsXtlbJgd6mdzeEZMLiw1qbZukqYNStC0XTQruGY0hhSQor0t/+hoR6LQ9Q0AKHt+XwXYc5qod6h3Pi3A6Z/LMPTk0KVYTpDUGbBSeGpmWgu85Okaj49B1HNJmBE16u2ErFykFmp8WE2xCINCiEjMaIZvJoBsRctMHqNfrVCsV8vk5UrrLhQvKS6LJZHalbPtWk5HdUAAjkQiPP/44L774Ih/84AcBb79efPFFnn322TUf8x3f8R188Ytf7Nv/8+fPMz09ve2kjmg0SqPR4PXXX+fYsWPh93an0+HSpUuMje3O4M4QG2NIAIe467DVK2wppe+JtjZxc12XCxcuhPnBGylxu0EAg0g3gCeffHKg7OD1sJEC2G63OXXqFK7rhv1+a2GtZBWA+UoTNf8GhaUCVrDPAjQhaXY80ulYDnP+RPDk5CTmiiSFWtvC0CRSLuf4Sj+6q9FZJq79wwrL6HYtbucLIDUy6QS4vq4mBFFdx9U0pqfHcVyXdqtFs9ViobCAUoR9cvFYDNsFF4FQLl5gr7d9TXjkdS33lrWgSd9oGPqOu+sqDG3w9+V4yqSSXwLDCMmfbXs+gtnY4F+7B8ZT5Gse0YpFJEidrg1jaZ0DkyaO1aZQqKEUmH4qSTwWQ/eV1wCZeJQn9mU4eaNKveNdnJi65IGpJNOZKK5atoFRCNyeHsfe4R0hdXRsnjmYo9Z2WGp3iRk6IwnDN25Wa/d6rrpJ4DhWSOKTUQ3bFYAbvlaW4xH5zRTw3OgU0ViMaCzG6Pg498xOkk2YFItF3njjDSzLIpvNMjo6ysjICPF4fFsq3m55AG4Xu6EAAjz33HN85CMf4YknnuDJJ5/khRdeoNFohFPBH/7wh5mdneXTn/40AP/b//a/8eu//ut8/OMf56d+6qe4cOEC//Jf/kv+9//9f9/ycwfH7z3veQ+HDh3ix3/8x/nEJz7B1NQU0WiUL33pS3zzm98MTaGH6t+dxZAADvGOwHrErdPpcOrUKSzL4umnn970CnqnBDCIdDtw4AAXL17c8RfYeiXp9fr91sJaJFIphb1wnlppEbfT7Pubo1yihqTT9vr9YrEYVtda8zniZoTFehfXVeHJ3CvJQqS3H0yIVbyg2WySz+fJJJOUHGd5AMEnEZbrkvDJsyYliUSCRCKBUtDteubCS/UlisUiQteRrqTZ1dC1SKgWNbsOcUMjEV3n+KwgAtPZOFdLLRr+4wDatosUgqn05gba3gGAA6Mx5itNKk0bw/DKwLYLU5koE6m1LgjWMqkWTCQ0Htmb5ly+QaPj5QaPp6I8PJsmF9eBVN/xqC8tUVosohsG8bivlsZMpOuwJ2syk44xX2vjohhNRFb17HkluvV2TOC6dvAjubjhD3JsHd57cjmFxHZWl56VqzaN1zOiceLpXPh73IxyeP8epJRMTEyglKLZbFIsFikWi1y6dAnDMEIyuFbixnrYSQrIbmC3COCHPvQhCoUCzz//PPPz8zzyyCN85StfCQdDrl+/3ve9tXfvXv70T/+Un/7pn+ahhx5idnaWj3/843zyk5/c1vPbts3evXv5xV/8Rf7Fv/gXfOpTnyIajVIul4nH4/z8z/986AM4JIB3FkMCOMQ7AmulgZRKJU6fPs3o6OimZtIBtjsE4roub7zxBvPz8zz66KOMjIxw8eJFHMfZUhbqWutZSd5u3LjB2bNnOXLkCPv3799UzVhrG/PXLpB1qjQbdbpWUBb0evpihoaJze3beXIjObKZLFevXV3FUYTUGItrzGmSpbYdkqxa28Y0JOOJZaIjEH0Pr1RqlEpFxsfHiZhxKnaVcqPrl2kVTcshomnMpFeTJSG8ElI0yKJ1XDqdDkt2jQuLbRqtNqau4QqJoevcMxpD3yynVymE1MiYcP9UknP5ejgcYeiSA6NxpjODKbmarpMUNs8cHuXCQp2FWgdN19iTMzk4Gkdb55y2aoVCInA4OJZgNhOj1rbQhCAd0/tI2lrHo9Vq0Wq1KBQKgPAGJmIx4rE4M9kN9kOtb4gYJofgeTQ6g8qqq/ZTC8lfuANiDc9MNiKjHrLj033v//sP7e8jDUKI8MJh3759qxI3zpw505e4kU6n1/083Q0K4FpRmNvBs88+u27J96tf/eqq244fP843v7naIWA7CL6HH330Uf74j/+YM2fOhINlQRrJoAN9Q+wMQwI4xF2H7Xzwe5W7XrPlo0ePsnfv3oG3GShuW/kC6rVe6Y10Ez2pDdtFL3nrJZlr5Qavh5XrKOVvMX/9Is1GgwMjJldLTWo+2YlFNUY0i2a139x55aCDEB4ZmEiZHJlwuVL01C4EJCMahyYSJM0VaolSuAqKiwXqjQbT01PEEwmEUjw4neL8whKVpo2jXBIRnYNjMXKJzcmzYUTQNMlDB+KMjbS5ulin1uoSwSGrdZBNizIdYvEY0Uh0TVLRO9BxYCTOWMJgsW6hFN7U7oBlWyEkju8bmDAkj8ymUbNb96EWUkP507qOq9A1bx2DQNMkyWSCZDIBQqPTbvkxdU1KxRK6off1UspV5Hit1Upcx1MgRU85e6tQyptFCa4GtJWZyCvvvMGRi8aSxFPZ8PfJ0dymiR8rEzfa7XaYuHHjxg2AkAyOjo72tW/cDQrg290axXVd/v2///ccPXqUZ555BoAHHniABx54APDUx3g8PuwBfJMwJIBDvCMQxMFZlsVrr71GtVod2Gy5F8EX/KBf9qVSiVOnTjE+Ps6xY8f6HrMbljIBAezt91svN3ijbQTkrV4tcf3Cq1TrLebLNSbSUXKJCPW2jeu6NKtFcB2m9vSbO/efh337DyGwHZeZrMlYMkKt7SmwmZixql9OCE9Bmbt9G8d12TO7h2jUxHFsNClJx3Qe25ej3rawHZdkVF9XKevfrsR1bS+D1nWZSkeZSkdD70DHcWn65GcpXwOC3sF43zHUNAOlnJCQJKP6mkMjA6zIT9JYJsyD86TlMYfgsRsSpE2gEAilPPXPjHrDLo4bTs8uLhZxXMefPI4Ri8f9yeo1VtabLrLOfQaB1LRQRVSKDTORXaU2TAHJTiyrYZqU3Htw41SdtWCaJjMzM8zMzOC6LktLXkvB7du3OXfuHPF4PCSDlmW95Qrg25UABhfUf/Inf8Lv/M7v8M/+2T8DvO/ZoH9b13V+/ud/Hk3TeOGFF3al3D3ExhgSwCHeEdA0jXq9Hn5pb8VseeV2wCMrGxFApRTXrl3jwoUL66qMu2EpI6Wk2+3y0ksvDdTvt942XNel025y5fUT2JbNpduL4d8NTZA0YG4+T8SIMDE91WeyC76KqFyUwvub43hmzP4uR3TJWHL9462UZ0IbNaNMT08hdQPXtTH8KDHwfJiTphEqTZuh17TYXkEkgsdrmiSVTJBKer2DnW5n2WdvsUAk4sWgtVpNEnFz22QLfHLjODsibQBC01CujRTesdku2dKkhuvafaV3qUkSiTiJRBylwLIsWq0WzWaLUqnsv+6KZrOF6auDQi6Tth3tm/L6+gLo2ibb2iCVJJZIY8aXydDBfTOeufYOIKUkk8mQyWQ4ePAglmWFWdpvvPEG3W4XXde5cePGjoZJtovd6gF8KxAQwD/4gz/g+77v+/jABz4ALPf4BWXhf/pP/ynPPfccJ06c4D3vec+wFHyHMSSAQ9x12M4H3rIsLl26xMGDBzl06NC2vzSCL6SNlLsg0q1cLm+oMu6GAlgul1laWuK+++4bqN9vLQghsK0ul197Gdvqcn2hTMda7pdsNvxhjEzGs5FZSwHyPUE0TUe5NtpmJ+8eNBpNbMcmmUgyOTkZlo+lX0rcTlYwgNS3RriEADMaxYxGyeWyOLZDo9mgXCqTn59HaiJUBmOx2JbUHiEErrNcst0qQq4jveg5r/i5eQ/c+pDhwIbhq6Or1wyRiEEkYpDJpHEdl0q1St0frHFsh6gZJZFIYJqmf5Le+r6FK9KWe//EAOQ28HlcC73qXyJmsn9mcs377QSGYTAxMREOk1y8eDEkhDsZJtkums0mqVTqjj7Hnca5c+d4z3ves24/9rFjx8jn87RarTd5Zf9zYkgAh3hbI+iLCxqktxqMvhKbxcE1Gg1OnjyJYRg888wzG1q87EQBDPZrbm6OWCy2o/B1IQQL18+T2DtDrdFmvuSVQlFQrpSplCuMT4xvXF4SAiGll4srxUDKlFKeJU6pVELXdFKplB/pBrjelb3aJsERUsO1d6a2abpGKp2mVCpx4J79tNodWq12mMLhJU14hHAjNVkp/8JBeZ542x2O8NyZPdK3kyELCErQPvlfY8J2LUhNEolEMHSDqelpbNum1enQatQplUpEdJ2IaXoE2TRXqcSbrKjvszBIGVm5a6s/ifQIEXM5AeW+g/vueGlWCIGu6ySTSY4dO7bhMMno6Kj/Xt9d5aperxOPD5b8crfCsqywvaFX3Qt+7nQ6FAqFVQb9Q9wZDAngEHcl1vOu60Wr1eLUqVMAjI+P79qXxnrK3cLCAq+88sqGRtIrt7MdAtjpdDh58iSu63L//fdz+fLlLW+jFwvXL9CqVXDcKS7eKgDeyXWhsEC71WZmZoaouXH5TAqB49h4nWVyOZFjHbgKFgsFms0m0zMzLBYKvimy7vXsaXJbShngWcr4x1WpHZAkqeFYlrdvrsI0TUzT9NVBm2YriB6rIqUIp2jNmNn32uu6HhLjbZM2/9iAGyqj2+UPQiwPkAhAbfJarViGR/aFp4AZhk466ZUdm80W7VaLcrlMwbKJmlHisRimT5A3Wm/vBPGgpF2tGUsnyIxNh79NjY1sOvixW+jtC15vmKRYLG46TLIdBHY2b1cFMCB6jz32GP/tv/03fuInfqKvlSX4+4svvkg8Hg8taYbl3zuLIQEc4m2JQqHAK6+8wtTUFPfffz9nz57dlQQPWK3cBeWfq1ev8uCDDzI9Pb3Bo5exnRJwpVLh5MmTYb9ftVrdUR9h4dZVKgu3cZXL9bxX+rUtm/n5eYQQ7NmzB03frKdwOd1B17RNT96245Cfz+P6wx6676cn/J40AdjO6vKmFxHsevsr8NMoxKr7SelNpG7aQ7bhLglQri+6rSZImq6TSiVJpZJe72CnTavZolypYBcsotGob7qcQBm+wLb96ihI0UNmxaYEez0ovP2C7fbrqTD5QwY9hH6aSTweIx6PMYIXxdb0rWYq1SpCiHCyOBaLrVAHRUj+YPASuacK9V9kpbJjGFEz3L97D2x98GO72MgGZqNhkrNnz5JIJMJy8XaTSd7OPYDB98ezzz7L3/pbf4tPfepTfOxjH2NmZgZd12m1WiwsLPCJT3yC7/me72HPnj1v8Yr/58CQAA7xtkIvGXvggQeYmZkBdi/CbeW2ut0ur7zyCs1mk6effnpLV+BbLQEHJtK9/n7bVREBaqUCty6/AQIaLYulUo12q818fp5EPMHY+PhAZdzek/lmhKLT6TI/P0c0ajI9PR1ajEh/WjcgE2IFW1KAct3QUFrRnyrh2Y9IpK7hOs7AZej1EPQhavrKlax1X5bVQXJeabSH/EghSSXjRKJeju92ypEB6drpAEk4+LHJhO16UCooF2thD+Fa72Pd0EkbKdLpFMqFdrtFq92mUqlSCMvnHhk0Y/Ee9U/DcQf7nCqlEH1e4hqZseUUn4P7ZjCj24si2w5c1x1osGytYZLAaiZIJsnlcqFCOOgwSaPReNsqgAEeffRRfuEXfoGf+7mf44//+I956KGHSKVSFItF/uIv/oL9+/fz/PPPv22J7tsNQwI4xF2JtUrA3W6X06dP02q1VpExTdPodDq78twBAazVapw8eZJUKsXx48e33OQ9KCndyN9vuwSwVa9x9Y2TYSrHzdISSVtSXCwyMjJKJpMeqC8sGPrAz4HdCA1/mCSbzZLL5ZaTQcAb8VVgaNqqgQSP/CmfHApA93z5/LUr5frqoMLuWD4pCJoJtw5P2fKGUKxtlGx13etnzGRzOLZNp9Om2Wz2lEZNTw2LxzAMY9NVCn84Qkpt+2VxoHfwY/vqqPLJ9nKim+tsPKgjJB7Zi8dgJIdt2Z7VTLNFrepb78RjJOJxIhEzVIQ3X0q/D2AqN4ZmeATsTg1+bITtGkEbhsHk5CSTk5MopWg0GpRKJRYXF7l06RKRSCQkgyMjI2sOSFiWRbfbfdvawPTi4x//OPv37+cP//APuXTpEo1Gg0gkwv/6v/6vPP/882Qyb05Jf4ghARzibYJKpcKpU6fIZDI888wzq74kd1sBXFxc5Pbt2xw8eJCDBw9uqxdlEPIWRNXZts3x48dXNXlvhQC2ug5n5mpczVeoXznJRBym0lFuFaq0OxadYpGp6alNPQSVgo7toGs6urL9oQQNZ51+O6WgUilTLleYWGOYREo/l1apdchfr/G2d5xFX/lXhn938U7CtuMQ1FwDdXCQl0gI6RFKpUCKbVJI/wLFtREoErE4Mb//1LJtWq0mrVaLcqWMpmnEYnGvV24N02UFXsMknvq3kzpyMPixI/sY1W9CvR1FUjd0UoZXPgdJu92i2WhSq9VotwtEotEwwzkSXduYGzxrn7m6y5xVI2FGeObAePi3+1YkfrwZcF13x88phCCZTJJMJlclk1y+fHndYZJ6vQ6wKwTwN37jN/jc5z7H/Pw8Dz/8ML/2a78WJnBshC996Uv8yI/8CH/37/5dvvzlL+9oDR/84Af54Ac/iGVZOI4zHPp4izAkgEPc1VBKcePGDc6dO8fhw4e555571iRju0UAXdel2fROVo888gjj4+ObP2gdbNYDGPT7jYyM8OCDD67ZFzRoH+FS2+aLf32DM3NV3NtncFtVTENyOGdw68plQLFv735PxQwPn/CJFmEUxWK9w6VCg0rLQhMwmYpxZCLut+MLT+5Ryw36rutSKBRotVrMzMxgmp4Jc7FhUWx0QGpko9InFv2vm+uxv1XkbxmKesehZTnEoxEShkLXPZVM06SnGvoZHsFQyHq9g13bxVUQi3hk0tB07AFLkX1r9p9GNyTKcVb1RBq6jpFKk06lcV1Fu+MNkpTKRWzL8dTBeIxI1ETTdKJRI7TEcTcZeloLS22bjq1IxyNEpIOrtm4f4yooLHUo1C26nQ4jEW8d2yGSN0ot3pivU2raJEydo+NxjkwkSMRjOK6LY/sxde0med+Y2+wZrtH9ftR62+bFy3WWOg5S2HTMUb5Zv85HntrDu++dZTSbHnxRu4Q7kQTSO0xy5MiRVcMkgXlyUO3YaWn093//93nuuef4/Oc/z1NPPcULL7zA+973Ps6dO8fExMS6j7t69Sr/9J/+U97znvfs6PlXwhs0urP2OUOsjyEBHOKuhBc3ZXPmzBlKpRKPP/6451G3DoIkkJ0gSNtwHIf9+/fviPzBxj2AQb/fRqQWln0JN1MfvnWlxGtzNabtPEQ7EDUp1Fr86bevcG/O+5jruuYNGvTwjL583pbFqesV2pZDIhpBuQ7XFpdodjrMRJVHsnwVUOCVxObn5gDYs2ePr8oKzi8scXmxieUowEWTGhkdHkwHaiC4KKSrQPgnVCFCexj80uwrt5aYq3awHBdDCqZSER7Zm/GUMgFKgl8jDvsFXVRf72DLcjm/0CC/1MVFkDU17p1MMLGBafVaqHdtzucbzNU6KCGZSRkcnUySjKzPjqT0BiPisRgwgmXZLFbrvHxjiYVmBZCMxSUPzKTRlULbgh7Z7Lp8+3qF+WoHVykiusaR8RgPzWbCWLtB4Ljw0uUy10stXBSOKzCEQ1dvcHQyuSXyd6nQ5KUrZY+gS0GpYfHNepmljs3j+7yynqZLkqkEyZRnzN3tdGi2Wiwt1VhcLGBEIsRjcb51u8NSx0GXoBsRnOQo1bbN/3tijg9931ODL2oX8WZkAa81TPJnf/Zn/OEf/iEAjz/+OO973/t4//vfz3d+53duebr4l3/5l/nYxz7GRz/6UQA+//nP8yd/8id84Qtf4FOf+tSaj3Echx/7sR/j//q//i/+8i//kkqlsqN9HOLuwVuXazPEEBugXq/zzW9+k3a7zTPPPLMh+YOdK4ClUomXXnopzKFcz6h0K1hLvXNdl9dff51z587x2GOPceDAgQ3Ly73RdBvh1M0q8W4ZqrcAaLXaFOfnsJVExgZTS26WW7Qtl9FkDFMXxCI6I4kIi/Uu1Y5LL13sdjrcvHkT3TCYmZn1lRtFsd7mUqGOocFY0mAsESEREeSXLPLVDq7rYNsWrm3juo5fjnVRroNynPDnMzcrXF+sY0hF1tQwNMXNSotXblUIysmB0iWkQNMkUtPQNQ1d17xjrxTfvl7lSqmNC0gU+brFyzeWKLe8njtN0xFSIqT3eM3/T0rN/12n48BLV2pcKraxlcB1FRcX27x0rUbHBanpSE1DaJr/s758m/RuE5qO0nROFxzyHR0jYqIbBvNNxV9dqbJYa1JvNKkt1bEd13t+qSFEz3/S+w+h8Y0rFa5XOggpiRoGlguv3W7y+nzDu5//mHA7a/wnpcaFQosrpTaarhGPGMQMga0kJ2/XqbRdpNTDbXj/6X3/Cv9nJTRO325gK0ksahAxIsQi3nE4W2jTtFixHe84x+JxRkZGmd2zh/333EM2m6XesZmrWWEzgBXNIqXE1CU1keSNhbfGJPjNzgIOhkl+8Rd/kd/5nd9hZGSEn/3Zn6VYLPLhD3+Yv/iLv9jS9rrdLi+//DLvfe97+57jve99Ly+99NK6j/uFX/gFJiYm+PEf//Ft78sQdyeGCuAQdyVu3LjB+Pg4R44cGeiqW9M0bNve9H4rsVak25kzZ3alnLySlG7W77cWehXAjWC3GrgLFyCmUVtaolSqgNQwIlpYWXXdYMhibVRaFhHD6FP5/AAQ2vayXUqjXmdhoUBuJEs2m+vbRqHexXEV8WgE/BKraXhrKDQs7lWKoN68HvFtdh1u19rEIhqmoYNyiekaSsF8rUOzaxOPrP7qEsGCAU0T3K51qLRsMqZH5oTrYOqCcqvL5cISGTPjKYWui3JclFjRgae8368VG1QbHTIxj9R569Gp1NtcW6xz72Si9yGrEFR2rxUbVFpdMlHdI3LKIRGJUG1ZlCydkYSk2WhQKhbRdT20VYkGvYP+dvK1Dov1DgldoGsSoVwMAxpKcWFhiaMTcYKPzEZVZQVcXqwjcYlICUIgcYlpinbX5lpxiYy5+cWDAqpNm2ani6kJhPKOpVAuUV3QbFss1FrER9fvPQ2SUBKJOB1lIGXbazqQOm09hbIsbwAkmuL2YgV3b/pN7wF8MxTA9RBMAP+Df/AP+NCHPuQPd22tZWBxcRHHcUKPvQCTk5OcPXt2zcd8/etf53d+53dCv9Uh3lkYEsAh7krcf//9WyJh21EAe0vMTzzxBLlcbtvbWgtSSizLArxEjBMnTmzY77feNmBjAujYNtOdq1xrdXGaLSyrC5qObdkYGmRjBosVCBv91kHcMKi32xDxenKEWE5vMKQ3lV0ue8khE5MTa/YjKaVQQvoDEgIpPcVMCm8fPK+79ckfQMdysF1ImHpIRhGCiC6pt23alkt8gApureVPxOredhQCISGiScpNC+Wq0JLEUx4lYo3ze7FuIWWQ9uF6ps3CG2wuNqzNF+Kj3PTuKyQQGDUL7xhVOy6maZLJZnAdl3bb6x1cLBZxHQczZoZG1PWOg+sqjIhcTlIREl26dGyXtu0SjwxGVDqWZzztHQT/PS8FwsUv4Q8GQ/P6SV1/CEX4udHeZDfo2uC15HRMJ6pLWl0XEiMYkQigIDWB1AWycpOvfe0quVwu7J/bbLBpN7AbQyDbRb1eJ5FIhJ8bITb+DO0GlpaW+Ef/6B/xW7/1W4yNjd3R5xrircGQAA5xV2KrX25b7QFsNpucOHFizUg3KeW21MSVCErAg/b7rYXgi34jAnjj/CvsjducsOssdgSgsVRvISXsH4mRjkUoihWGxwLP1iWU+RSzOZNCvU2jY5OI6tiuS61lkYoajMZtWs0GrqvYu3ePf7w82SY0QRYwmopypdjEccHQPdLoAkpIoqpDIb9APB4nnoj7FinC71nzJlEEkDINooaGZTlEoroXCQZ0bUVElySjOlIuP6/q2Re/hRClwDS8wQrlOggpQlXMURCPGCilKBQW/ElUf9ra9ZVE4REaISFqeCS293V1fYuaqD74axnVvQUoJAI3tDpSCqI9BElqknjCO0ajCrqWRavZpNloUiqVaToauNCxJRHd9VU+F9sFU5dEtxDRNpmKcGmx6e2vf+wcx/thNDF4n2QiqjGZjnCr0kaTwp/MFrS6NqmoznRq8ClPXRM8NJPmm9eXaGhpIrYL0SSRSJy/+8gUP/i9B2k0GhSLRRYWFrhw4QKmaYZkMJvN3pFSreM4b2oJuBe7YQI9NjaGpmnk8/m+2/P5PFNTU6vuf+nSJa5evcoP/dAPhbcF30O6rnPu3DkOHTq0ozUN8dZiSACHeEdgK6pdoVDg9OnTzM7OcvTo0VVX9bvlKSilpFKpsLi4yKOPPrrtq+iNrGAWbl7mxpUL3Lxyme88kKXsxjlx8TaZnMl4MsJYctlmo69ipILkDe9/UmpMJCMcGU9wtdSk1OwiFCRjOveOx2iW8oBg79493rEO19OvEo0nTabSUW5X2miaR3BsRzGVifPAdALH6lBvNigUi+i6RjwW9/N2zTD1QdcEe7Ixzs/XUMoloml0HIeO5XJ4PElEl32ELFyC6t/P6YzJ+YU2tbZF2tRRClq2l/4xkza8nOV4zHtdgkESFLjexlzlIpRgNh3lWrlDq2sTi+jepHjXRZOSPbkYUsg+Qh3SWQUIhVDegMu+kTiXih1aHZtE1CMSLdtBk4LppIYupW8FI/zHgRKCmCaJx0yUq7znbjW5Xq9QbNvYXYWuC683EcmRyQQRwyOowifVvbqv6iHaroL7ppLcqnWpty106ZlHO65iKhNlT2ZrAwZP7s/yYrdMrdnxI+gEMUPj+MEcW+VNx6aT2EaS1xoGdVswPTPNDz++hx9992yflcr+/fuxbZtyuUypVOLcuXN0u12y2WyYvDGo0fJmeCsVwEajsWMLmEgkwuOPP86LL77IBz/4QcDbpxdffJFnn3121f3vu+8+Xn311b7b/vk//+csLS3xK7/yK+zd++alsAxxZzAkgEPcldjqF7amaZ7atMGXtFKKS5cuceXKlb4UkbW2tZP4NfD6/W7cuEG32+U7vuM7dhTivh4BrJUXOf3Xf8mtm7fYu3cvuZERXrl0i4f3rO7bEgRRY2tZzXhGxELAwfEEe0bilBtdNAkxTVHI55FSIx6Pb6iABNt5aE+G8ZTJ7UoT11WMp6LMZk2vFzAWJZ1Oo5RLq9mi2WqFvUmxWJx4PE4imfD62HC5WWnTshwMTXDvZJKjk4OrIEkzyqN7kpy+VaPW9tIxIrrkQC4CzSLpTIZsNhsYCYZHRkmPCHrVXpeJVIT7xk3OLzSpNLuAV0a+fyrJRDKC2ztZvbJqGrBsBdmYzsOzSV69VaPaslB4yt99kwlGtRaOUpt77gmIxeP8rftjfPNykcV6l5blokuHiahNyq5SWLSI+72DfWbcPT8Fv48kDP720TFeu1Ulv9RFYnNPxuDdh0bRddnzEN8rKLQMEsjlHwHIxiP80INjXCu2qba6xCM6B8bixI3lPtRgS31r8hnqshuRQI8YPHpPku9IJnnk4Xdx776Z5VL1Cui6zvj4OOPj42FmbmClEhgtB2Qwl8tte8DrzR4C6cVuxcA999xzfOQjH+GJJ57gySef5IUXXqDRaIRTwR/+8IeZnZ3l05/+NKZp8uCDD/Y9PpvNAqy6fYi3J4YEcIh3BIIvZtu214xrsiyLV155hUajsWmk2057AKvVKidPniQajRKNRndE/mBtAthpNfnan36Z0uIiR44cJpFMci1fotVZpyetJ9mh/3bpERgfupSAy2Q6Sr1eZ2GuQG4kh207G04UhCVUQBOwJxthNmOwXr+fEJJ4IkE8kUAphWVZNJtN6vU6xeIikUiE6USc2b1JXKkTMzQi+hbUFz9BZCpjMpmKMldr4yrQ3Q6tWpnxsXGSqbUVlcCT0HOokQghuX86zf7RBLerbQDGEzop08B1XW+KeIDrFalpHBqLMZuOMlfz7FsmUhFSps7CQntLwSaJqMb33jtKpe3Qthwypo6pC1otj1QvFBZQijCbNx6LrZn5LIXGSBz+1r2j2I5LuVxGCkHU6M1g8w/oit9DDdj/k5QaunQ5OpnAdpd78pwV1kNrYsXfM9lZFqsNYtEo9+6dXpf8rYQQgkQiQSKRYO/evaHRcrFY5OLFi7TbbbLZbGi03NtXt+HyNrm4vNPYDQUQ4EMf+hCFQoHnn3+e+fl5HnnkEb7yla+EgyHXr19/y/ZxiDcfQwI4xDsCAQFci7gtLS1x8uRJEonEQJFuOyGAt27d4vXXX+fw4cNEo1GuXbu2re30YiUBbLVa/Ol//iLtRo377ruPSDRCvdVhbrG27jaEWIMBKt/Xuaec6vj3KZVKVKtVJqcmicfjlEolLxJs3e0v9xhqfk7vZsMevWuLRCJEIhFyI6PYVpd2q0Wz2aRZrQLQ9UvF8Vi8L5t4PWi69xpKAY4QzGRMSqUyS/Ua09NTmOZgQwNCauA66JokZUqORHVAeSVo1W9CLfwDIVaYUAfwEk8gHtU4MNb//FuZ6JRSx3VtdF0jFxf0fo0nkgkSyQQo6HQ7tFot6ktLFBc9Uu2V22NE/QQOhW/ELeVyX+W2yqUC17H9Psztp5kA6HqERGaUQnmJw/tndkRIeo2WgT518MqVKxiGEZLBXC637ndDeHHzNlcAAZ599tk1S74AX/3qVzd87L/7d/9uV9YwxN2BIQEc4h0BIcSaxO327ducOXOGAwcOcOjQoYEIyXYIoOu6nD17lrm5ubDfb2FhYcelZOgngNVqlf/+X/9/CKfDvffei9S8friLtxY3JBFCBMMWy9B0HcdZHnbRNUnXsiksLNDpdpid3UMksnxCXG/rQenXmwlRWLa7rSlFITWU6zXaZzJpEskkSik/a7dFpVKhsFAgakZJxL1ysZds0v88Qggc2/bKiVICDvmFAt1uh5npGX+qdAD0JJVIIVEoX4kS+H7W/jCIb8nR8/PycK70vQq9ffOykHcyYS69Y43A2SijVxAq0NlsFsdxPVLdarKw4F0oxONJTDNKMhEPS8+u6/oq8BZXJTVc195WdNxKZManEVKSyyQZyexu4kfcf9/s2bMH13VDdfDKlSthDFtAGJPJZPgeDr4P3u4K4BBD9GJIAIe4K7Gdpu1e4ua6LufOnePWrVtbjnQbNH4tQODvZ1lWn7/fVrez0Xpc1+X27dv8zTf+B3HdZXL2QHjyv1mo0Gp3N9mK6COI3tqWyZ8mJe12l/n5eaQm2TO7x/O8Cx4tRJ9SuHy7DMmf63qWItsifwiUG+TPBgqi97ymGcM0Y4yMjGBbNs1W01NyymV0zetNDAdJ/Bg4hMCQgo5lk5+fByGYmZndkoIjdQ3lOBi6Fq5n1X385wLCIZKV6qAQAhwLKSVd297Qi3HTNUmJ69q+vc7gj9M0uYY62KZWq7JYKBD183kdx9l6j5yQuI63pg1J6QDQjSiJ9Ai6JtkzMXpHCZeUkpGRkdBkvt1uUywWKZVKXLt2DU3Twr8H6ttbSQCHVixD7DaGBHCIdwwCAthruPzMM89suQdvK0MgQb9fNpvl8ccf7zt57sYwCXgk6ObNm+Rv32QkJkmlly0b6q0Otxerm29D9lSARf8UrRDQbLaYm58jkUgwNja+qgrolQvX1gA91ctF1yS2q7ZF3pHSM45W9E/4roBu6KSNdN8gSavVori4iO04JBJJYqZJIhGn2XHIL8wTjZqMj4+FU8aDQAiBaztIycCK1nrqYKBIgve769us9JeKNy+bCqH5RGv9qfCBICAWSxCNRhkbydG1bJqtFq1mk1a7TbvdxrItb0I7Ftu05C6FwBXBvzsr/2bGphBScmjfLAu3b7yphMs0TWZnZ5mdncV1XarVKqVSievXr1Ov1wEvE3dkZIR0On3Hffh6MVQAh7gTGBLAId4x0DSNSqXC6dOnt2y4vHI7gyh3Qb/foUOH1ox02/GJGsLhiGajzmTaQIrlj+wgpd8AAhm27ff264GX7JHPFxgZHSWzbslt9clOSg3btgCvRGq721NuwxIyoOtyXbVt1Yp6BklGlcKyHRqNOkv1JYpF77hEo1HS6ZRviTIYPNImEcLbr+2WNKUQXgSc66BFDRzH9Qhfb9mY5RmLTdfoW8xsJet3vQ25ro0mvGMtNUkymSCZTKAWCuiahpCSarVKIVAH434qSSS6YqJX4jqOT/539l4P1L9kPMbe6Qnmb157U0lWL6SU5HI5crkchw4dolgs8uqrr9JoNLhx4wZCiFAdHB0dXXPwbDfRbDaHBHCIXceQAA5xV2KrX/xKKWzb5uLFixw9epR9+/Zt++SxGQEMysu3b9/e0N9vJyVgpRRX82X++uSrRFGMGx2k6Cezg5V+PXglXNC0/r6/SqlEuVplanqSWGwjpXRlCXmZ/HkJGwKxgXK3wcJwHQd8BWlQ8rcSCohEoxiGTsTQyecLpFKeShgY38Zi3hBJPL7xIImm6yjH8UqaOyA1ngNMQPq8hAyp+Yop/r+ui+u6WLaFQnmDNmsMkkjhkWRd23mPXfC+VEKtWa7VDZ10Ok0ul8WxnXCyuFbzege94+gRQl3XQO3sOAXIjHm9f/cd2hdePN0tE6m6rmMYBg8++CCu67K0tESxWAxN3lOpVEgG0+ndj6nbzSGQIYYIMCSAQ7zt4TgOZ86codPpcM8997B///4dbW8jAtjtdjl16hTdbnfTPN/tloCrLYt//5fn+ea5OfSoiVEtcJ9Z5XvftQ/NT4wYtPTruNC1HVxASBGSP9d1Wcgv0LW6q4Y91oKUom+I2PZLmiAwNImzDfIXDlcI5alaQgxSCV0Tmq7j2jaVSoVqtcrU9NRyPJhStDsdWq0mlWrFU7XMaDgQEOkZJBEILxcYhVI7U580TcMNiWRvyX152tZ2XRYWFjB0g0Qi6S+3Xx0UCJTmhgR5R6KY37Pp9TWu8R5foSZrukYylSSZSqIUdNptWu021WqVxcUikYhBMpkgGjU9FWybazOMKInMCNPjo+Hgx91EAHtzgKWUZDIZMpkMBw8epNvthpPFr776KkqpMKZuZGQE0xw8BWU91Ov1Da2rhhhiOxgSwCHuWgRRWRuh2Wxy8uTJsGF7N75spZRr+n719vs99thjmzbLr7edjeC6Lv/mz17lm5eLHJjMkdMtrt+4zasVyUiuwuP7cwOVfl0XrhQbXCs16VguTtfhgGhy/0wM17GYm58nYhjs2bNnoLVZjsJxXC/XVy5b9kq5PfIHnhoZln53sB2BwLEdCoUCVqfDzMyKSV8hME0T0zTJ5UZwbJtm07OZKfcOksRixJNJhFLomuYNNGwXQnjRYSvIXy+6XW/oJhaLMTo25vXQ+YMkSi3byygpsGwb3Tc79+x1trcsKQRKCc/XcS2rGtS6pWghwIyZmDGTXC6L6yjarSb1ZpNyuYIQwvMdjMeJmeZAdj0BMmPTGLrGvQeW0yW8HOG7gwBuZAIdiUSYmppiamoKpVSoDs7NzXHu3Dni8Xg4WZzJZLa8T0opGo3Gjv1EhxhiJYYEcIi3LQqFAq+88grT09NhbNFuTN0GX/S9xC2wk1mv32/Q7WwEx3H4i2+d5vSNEvftHScX02ldPUMqKqk7knMLbR7drzFXqtDpukh/2sANLEhYth+5WKhzNl9Hl4KIJmgqyfmFFkqVSDpVUqk0udzIphOpi/UuF/J1CrUmjutwSNY5MmoSNbznlsLL1h0EluNiOS6moaFJuVz63YAkDQJXKebmbiOAqelptE2IuabrpNIpUumUN0jSatNqNimWy+QXFkjE40RNk0QigbHN1AghJChnXZLearfJ5+e9Ums2F76fgkESBCAlLgrlKiKGjm07YekYfHVwQBNq7/69/XrrHG81WPuFFBpoDql0ingysawOtny7HsvC9CeLY6HKuva2DCNKPDPCoX2zRHuUaDeYoL4LMOhnWAhBOu0NKR04cADLsiiVSpRKJc6cOYPjOH3qYKhSb4JmszlUAIfYdQwJ4BBvOyiluHz5MpcvX+6LdNM0zS9N7gy9ptJSyrDfbzt2MsBAZeB2u82JEydYrCniqRy5ZIzuzVfBsRBAVCja3S4L5Ro388U+YiF6/xUSy3G5Vu4Q1XUSpndCdawubQfOz1f5rkOjjI2kN622lhoWf321TNtyMPzy4+s3ihQrUZ45NEY8FhmoZ8+yXd7I17lRbuE4inhE496pFPuyUb/iOPhJ3lGKSsNCKcglDEBx+9YtIpEIk5MTW9oW+IMkca+nbUxKOp0O7XaLRsMzDI4Yhm8zEyMaNQdLpJAS5ffrrXV8Go0GC4UCIyMjZNIb+9xpUgfhe9BpGts1ofY2INAYYFhjkH0UoIvlbfWpg+SwLZtWqxUSQk3TwlQSc4U6mBmbJp2Ms29msu8p7tYS8FZgGAaTk5NMTk6ilPKTbork83nOnz/vqb8+Gcxms+uqjMMewCHuBIYEcIi7FmuVgINIt3q9zlNPPUW65wS60wi3AFJKhPBitU6fPk232+Xpp5/e8hdwcMLYbE3lcplTp04xNjbGdx49yN+8eInK3BWizQrgHYe27TISl9wulDcuiyuXeseia1kkTR0v0NbFdWw0VyGMKBG/lBR45gkRTAkr/5h7J/QrxRotS5GLGyggbkbodDos1Du8dvkGUykvWSKRSGAYxppqjVKKl69XuFlpE9Ulhi6odRUnrpURZDkwGl9fjVqB+Wqb07dqLLU9kh8zBFNGhwPjaSbGRwfeDkpRbFgs1DsIBNOZKLmEiXId4maUaCRCJp3BcV1aTc9zcHmQJEY8nvAGINY4WSulEMork3uG2P1/r9ZqlEolJsbHN38/+QMyhi6wnQ1MqINSca8J9QoyKIQGjrupTUuvifW6y/Kntjfakm7opIxAZYW2TwbL5TKWbRMzTWKxGKlMlng6x32H9q96/7xdSsCDQghBKpUilUpxzz33YNs25XKZYrHI2bNnsSyLXC4XDpPEYrHwmDQajV1RAH/jN36Dz33uc8zPz/Pwww/za7/2azz55JNr3ve3fuu3+A//4T/w2muvAfD444/zL//lv1z3/kO8/TAkgEO8bRBEusXjcY4fP77KekHXdTqdzq48l5RyS/1+a0EIsekkcDBFeOTIkXB45b4cvHzuImlTJ6pLal2XrqMYNxXd7uYKZ0RKdE3QtV1MQ9BsNryTqW4QMXS0Xu855feb+RYxavkvlOptojpI74CAconHYnRci9RIkkzC9w+cm0dK4VmyxGLEYnFvnsNVlJoW87UOiahGRNNQgKEpam24uNBgT8ZEDGCMXG3Z/PXVCm3bIRHRcR2bSsOmbegc3JcamPx5hLTK5WKD4GV57bbk2HSSB6aT9Ap2mpQkk0mSQSJJt0uz2QjtUaQeId/RyTe8yd09WZP7Z7KYuKD1l2aVUpQrZWq1GlNTU8RW9Kq6SjFf69C0HLKmwWjCQEgNTXOx16mxhybUUq42oXZd77X0B06k5kW9bRbTtqmlkFeDRpeDJ5oIgWcjE/fKnYGZd6vVoiuixPO3WZjL4nS9ODbN73W8mwjgdhXAjaDrOuPj44yPj6OUotlsUiwWWVxc5OLFi0SjUU6cOEEul8O27R3bwPz+7/8+zz33HJ///Od56qmneOGFF3jf+97HuXPnmJiYWHX/r371q/zIj/wIzzzzDKZp8pnPfIbv//7v58yZM8zOzu5oLUPcHRgSwCHeFpibm+O1117jnnvu4fDhw2uqTbulAN6+fRvHcZiZmeHYsWM76kNabxK410rmscceC7NKHdviydgCnZk0VxYbVFsWhhTsywqS2mD7lohqTKSiXC22abeaRDSJEhpty+XgSJREdOOPfUABooak2bVBGCzHTrggFLqEZCJBMpHAVYpOu02j0WBxsYBjO55SlkhQbYOtIKXrfYQkaggalsJGEpGSgIyi1va5u15q0rIcsjEdy7axbJtsPMJS1+VaqUkunhno2FwvtbhUaGBokoTpndBbtuLMXI2JVJTx5Np+bkIIzGgUMxplJAetTpcXzxVYbLQIaEGx0eF6qcH7Hpgi1vOecZWiuLhIq9ViZnpm1YVLpW3x9Qslyk0LV7loUjKdjfMdB7LEIoOpToE6uGTZvHKzxo1yE4Rgf87kodk0cWws35RaiGXld52dBaBjuVwqNFlsdInokgOjMaazcYRyvdL2Vj4WCuaXOizUOhi6xj0jSUbHJpg99AAPHt7LUq3GhQsXaLfbZLPZMJ3jbsFuKIAbQQhBIpEgkUiwb98+HMehXC7z5S9/mV/5lV8B4B/+w3/ID/7gD/L+97+f+++/f8vfS7/8y7/Mxz72MT760Y8C8PnPf54/+ZM/4Qtf+AKf+tSnVt3/937v9/p+/+3f/m3+03/6T7z44ot8+MMf3uaeDnE3YUgAh7hrIYToi3R7+OGH17xSDbBTAtj7XMFk306b0Ncyg+52u5w+fZpOp7PKSubmxdfQVZfvuXeMJ/ZlaVkO9fIiF27kEUQHft5DuSiFxTJNdDoYOG6XyVSEY1PJDc/bnnedwlWKvVmTUr1Ly3KI6QIXWGrbxA3JdHpZwZLB9GcshlLKM69uNakvLVGtdbC7grZwiUSjSOGpZa5rE5ESTbiwUr3ziUpQxlQKGrZCSI2u5WA7HsHUpMRwHZbaLsLP6lWbDA5cL7VwFUR1n7ZJScxwqbbhRqm5LgFciZtVi0pbkY5FkcLrxbNcqDQtvvXGNY5OxIjH4pixGKVSEcf2LihWKsmuUnz9Yolio0vMkGhSx3IUN8otTkUkT9+THWg9APWOzZ+9vkC9Y6NJAUpxbqFBfsniBx4Yw/Cn0sPcYv9xKwdJBNDoOPzp6wWqbTtMMzmXr/Po3gyP7ElvifzZjuK/n1vkZqVDQO//+qrg/ccf4XsP7mN6apLpKS/dplcFA3j55ZcZGxtjZGQkVAffCtwJBXAjaJrG2NgYn/3sZ/kn/+Sf8NBDD/FDP/RD/Pmf/zk/+7M/y2/91m/xD//hPxx4e91ul5dffpmf+ZmfCW+TUvLe976Xl156aaBtNJtNLMu668j5ENvHkAAOcdei0+nw8ssvhxm7m/VM7YQArvT3O3ny5K7EuK0sAQdl7GQyydNPP91HCErzN6gW5sLfU6ZOytS5daNJs90lNZjIRa1Wo1QscvzQKI4Ro9V1aNdrZGI6prH+CTQYKgiIwf7ROHVbcW2xQbnp+msyeHAmta4yJYQgEokQiUTIZrKMjdssnCtQalrE7Lo3NYzEVpJDs2m0NchaSOB6/PASusLqdogYing8ifB7G23HJm2anuEyEEQBBz+IYKLWu4Wu8sqhhCdz32lPgeUuR7dthkK9A8rLLQZA04lKF1sZtDWdWCxKo9GgWCyGvV+WbSE1rW+QJL/UpdKwMA2J5q9J1zUMZXGl0ODh2TQxYzDicS5fp96xiRlauM86klrL4mKhxYMzqbVtZnpe86BEfPJGlWrLJqIvk8OOA6dvLrE/FyMTH/zUcfpWjRuVNlIKNAQK6GLw5Ys2P57of1MH3oyTk5N8/etf5/Dhw5TLZc6fP0+32+3rkXszbVHutAK4EYIUkI9//OP89E//NK1Wa6D0n14sLi7iOA6Tk/2DNpOTk5w9e3agbXzyk59kZmaG9773vVt67iHuXgwJ4BB3LYI+mJUZu+thu1PAtVqNEydOkMlkwn6/3Son95aA8/k8r7zyyppl7Hazzq3Lr696fL3VIV9p+lYvoMT64ovC+6JvNBpMT0+Hnoi5mEHRbrCRy/Iy+fN84AIF7oHJBPuzJpWmhaFLRuMGEX1wJSRi6Dx9aIyXbyxRbXTouC6aUIxFHMxWkbn5Bol4gng8vu5rbNs20e4Spi7oYmDYjqdSWQ4xXbJ/ZNlKQwR5afSrXME+TiQMFqotcCVIDaE8k2wEjCQiy69Jz2sjhPT4pGfBh1KgGwZKyJ77SV/ZdDEMjXgsTq1WC8t6rVaLhfwCCuWVx2NxYvE4bcvBUYpYQEiVQuCiS2+au2M7AxPAuVonJMHB0ZDKxQUW6h0gtdpmJlADlaLb7eLYNkrB1WILKfsOA1EJHcflRrlFJj7gQIKCc/kGAtB7iDiJMUiO8hfnFvlHT+5Z9bDgMzM+Ps7ExMSaPXKmaYb+ehtN0O4GXNfdVh/wbiDwAAzem4Nax+wm/tW/+ld86Utf4qtf/equeK0OcXdgSACHuGtx7NgxHMcZuAyr6/qWSVvg73fw4EEOHjwYPtduThTbts2lS5e4fPky73rXu5jyy10BXNfl+tlTqBXP57qKS7eLyzf4522fh3g3CVAIlOuQn89juy5798xi6IZ/fz+mTQgEKlSZgtANgUdoXNcfXPC3q/CGIFwBIwmNTMxAC57L9xsMeFawEdX7aBX8pBhJmnz3YY1iw8J2IRGVZKJ6WCpuNBosFouh5Uo8HicajXrTz50O+fl5RlMJ3jOa5JXbdWptC4EgG9N510yaXHzwHNZD43Gul1rU2jaGZgMCy3EZS0bYn+s5sfYoLEo54TEJsCetczGv6Fg2EcNAKIeu4yKEYjalc3vuNqlkilE/JjDpT3B2Ox2arRZL9TqLxSJd4e1nx8Ej1r6C2bVszIhO0lxOKdlsQjeqyX6KLwRSgED5fZarEQyStNtt8gt50pk0UdNc3YcpJMIfFNpskKQXCrzj0rNyV4siszOISIxqa+0LtsADMPg8ruyRW2+CNiCEu02SHMe543m/62E3LGDGxsbQNC2cZg+Qz+dXfR+txC/90i/xr/7Vv+Iv/uIveOihh3a0jiHuLgwJ4BB3Ldbqn9sIWyFtruty/vx5bt68uaa/324SwKtXr9LpdFbZ1gSYv3qOdqO26vbbxSqNVgeEQKnl49BLApSCrtVlbm6OaCTCzMzMcqKE8o2abU/Zc1y1KrN1TeUPz3POsp3wXpoU/qTtGid/teqH3iPgqSdSMpmK+H2dHqeJRAyikSy5bBbHcb3M2WaTBf8kFY1GabVbjORynsKj60xnY5SbFgDZmIEU9Kt1foSbR1CXUzNc5dmopGMG33N0jLMLTW4UG0gB904kODqVwvTL2spV/jEPthDEwi2Xh6czJvdNJryya6vrkS1gNmMQaVfIjeTIZDKrotWWy+MZbNvzypusVblV62JZAl16JXIB3D+R9lSzHuPnMKljpUKJ4uBEkpu1Ll1XoEuJRNGyvN7JAxNJpKaFy1lO/FA0Gw3yC3lyuREyqTRKwEzG5HqpDZp/DJWi67hIAZMpA9dxBzKhFgLGEgb5pa73ugiw4+NoyVEsBfdPrT3ZupkH4MoJ2qDcvrCwwIULF0J/vUAd3Gn/3ltZAq7X6yQSiR31I0ciER5//HFefPFFPvjBDwLePr344os8++yz6z7us5/9LP/P//P/8Kd/+qc88cQT237+Ie5ODAngEO8YDEraVg5hrHV1vZl9yyBotVosLS0RjUZ55pln1lQQasUFFm9dWXV7o93l5kIF8P0Q17E5abY8j7p0Os3o2HjPtG4/HfNKoyv+5g97BH/vLX86thOe3DeKM9sMQpOhsqn5cW/L5zERqohSylDhcZWiVCxSW1pC1zQWS2UarRbxuGczMxKP4rguSik/hWTl2lYWfj0EnW5J0+DxPSme3J/2snV9Su327mMP6VqOXhNhj6BE8OjeDPtGU9yqNFCuS0p30do1JibGPcuOUB31+Vqg4Pp1fE0aRCMRvv9dKb59vcKlxRZW18IQLnuTijFZp76kiMcTGIYeriZU51SwTRdXweGxGPlajAsLDdq2g/QV3/unksykDS95ZcWRaTTqFAoFxsbGQ5sRATy2L0t+aYGO7fptBwqQHB6PMZEyvfekf5iEkP57R/lktPcZBI/uG+HP3ijQdRVCj2Cn9+AoyX2TSb7r8NoDBVuxgBFChHY9+/fvx7btMJv39ddf70vfGB0d3VYJ880eAunFbplAP/fcc3zkIx/hiSee4Mknn+SFF16g0WiEU8Ef/vCHmZ2d5dOf/jQAn/nMZ3j++ef54he/yD333MP8/DxAeKyHePtjSACHuGux1SveQQhgrVbj5MmTpNNpHn300XX7etazbxkUpVKJkydPEolE2Ldv35rkz+q0uXHhlVW3B1m/bq/ys0JJUnjZxKVSifHxcTLpLK7bX04zepIohBQoW4WP7W387x1KCAjO8k1q1ZDuwBAC17Y9wuQniWz2mgbkr9FoMDMzgxmN+kpZm3pjiUq5iKYtp3OYUXPL7xOFFz9n24MNfPTvUkDCPOIzFheMJ9KUSmWqtRqTU5PEzNgymew1VuxbwfLPAnj3/hyP7cnQ6NrEoxqubdNqNllqNCgsFtF13SuPJ+L9+7zitTl+IMfhsSTztTYKxZ5sjNHEiveeAiGhWq1RKpeYmpwiFo/3KYzjqSh/56EpXru9xFy1TSwiOTKe5N7JhN9O4LcNKIXCz4gWXrlcIPwcbI/47s9F+b77RjlxvUJenySWGeF9x8b5ye+6B2OdvOCdxMDpus7ExETYOxikb8zPz3P+/PltZfO+lQrgbhHAD33oQxQKBZ5//nnm5+d55JFH+MpXvhIOhly/fr3vWPybf/Nv6Ha7/PAP/3Dfdn7u536On//5n9/xeoZ46zEkgEO8YxAQwPUmOdfr99toW9vB9evXOXfuHEePHqVUKq05saeU4sb50zhWd/U6g9KvD+Hbd4SPBRYLhZAkxWIx3BWmvFKKVTFkbjAUEeYGi1XHQNP1PqXIOw5bJ8JKKb9E6Nm4KLE5oXddl4WFBSzbZnZ2NiTnumGQ1HVSKU8dbDWDUrE3VBGPxcPewc1O5kJquI4NW8jQXX9bEuG6LBQKNJvNNT3+Bt6WEOiaIO1H92FEiGQiZDJZXOX277NSxOL+IEks1ncRIxBMZ2NMJCPrTwsJRblcoVKtMjU5hWmaYbkbfIVRQdrU+Y4jYyjH65UE36oxfC+KsFSOAMcNprYVgaO28I/TnkyUA4/v43v/lw8yNZrZdJBot2LgVqZvBNm8xWKR1157Ddd1w6ni0dFRotG1rZbeagVwtxS3Z599dt2S71e/+tW+369evborzznE3YshARziHYPgROg4Tt9JsbffbzMvwQDbIYCu6/LGG2+Qz+d5/PHHGRkZ4dJckb86W6H8xllSUYMnD+R48p4cxVuXqVeKq7bR7Cn9BhBiOcHBcR3m5/Mo12V2z56e/ewnmUF/1/I2ZE9CxNrkz4seWyZ7UoptkT/oJ5K6tnkJ2bZt8vk8UkpmZmbCYZVgXUIpP1tXhaVihaLb6dLoSeeIRqPEEx4ZNAyjb/gg6KXUNbntknbvtlzbJp+fx17H42/gTUmJBNYJ/EAK2b/P3S7NRpNarcbi4iKRSGR5eMY08cy613s2RbFYol6vb05YhRcQ6Gxi+icCux1fIAu8BgOVObCbOXj4CLNj6YGI953KAV6Zzbu0tESxWOT27ducPXuWZDIZksF0Ot2X5/1OIIBDDNGLIQEc4q7FdkrA0E8Ag36/drs9kJdg77a2EivX6XQ4deoUtm1z/PhxYrEYN8ot/t8zTRaaDqNpheUoTtyocOHGHI/Ia6u2oVR/6TeA9FWWSr1NoZAnFYsyMTWFlBLp57L2r12uSdwsy6LdaRNdo2zqdXgJliPh1Mr5hcEhREj+hPBybDd6KbvdLvPz817j/thYX0laahquPwnuZev2DnwIotGop9rkPBLZ9LN7y+UymqaFFjOmaXoRY47jiVM7VP9c1yWfnwMlvMGbHZAD7xjZ/WR1vfsiiEaiRCNRcrkcjuN4+9xqUp2vYug6kUg0LJHLnp48pRSLiwXa7TYzMzMYhrHhc+m6jm1Z29ofIQQExtMoIpEojzz8SN9Flff+lWseuzcjBk4IQTqdJp1Oc+DAAbrdbqgOvvrqqyilQnXQcZy3fQl4iCFWYkgAh3jHQPolx+Ak09vvd/z48S0pNFsZAgl8BLPZbJ9n4Z+eyZNv2OzLGIz4FiPFWpOvf+MlZh4eZSLVX266vVil3lpNOkstm9eLLvX5OXRDZ0ZFiHUcsgkdx+3XZ8QK1S7gcDHTpN1ukc/nEfTk9vokQfOJVgBdaqsmhgeFENK3TgmUxvXv22w2WSgskElnyGazfQRP4RGtYBJ3swsCXdfDE7qrvKniVrNFoVDAVYqYaZJKJoiasR2dzG3HYWF+Ds0wGB8f7yNZW4WQGrjuQORvLWiaFpY4QdBuNWm2WpTLZRYWFjBjZpjPXCqVcBybmekZtE0+CwpwtuGpuRKBOvjEY4+SSadQSuG6rve6KhX6dga52cG/O+kB3C6C9J+pqSmUUtRqNYrFIjdv3qTVanH+/HkmJiZCdfDNWl+j0fBf3yGG2F0MCeAQ7ygEpdsgO3iQfr/1tjPIEMh6z2M7Lq/eqpEx9b5Te6pxjVutJreriT4C2Gx3ubGi9AtQa1v8zdUy9Y4iHfdUrJuVNrWOzXcdGcPU+xUeqUTf3EFQhtMNg+zIOK1ai6Vml3bLotks4i44xOJx4rFYaMbsKVKD+y/2QkiJ8hXJzfoHa0tLFBcXGRsfJ7VGiSsgpfo2ppClkCTiCRJxr2xqWTatZoNypUq3WyASjYTqoBExBiZg7U6bhfwCyUSC3OjItokbeK+XLsG2d1iO9hExdCCGGYsxMjKCZVm0mk0azSbFYgkpBclkiq5lYWrahq9v1DDobkP9WwvpVIIHHnw4VPQC8u26btizG/wcwLbtt6zkCh4hzWQyZDIZDh48yNe+9jUmJydpNBrcvHkTIUSoDo6MjNxRj8DA2H2IIXYbQwI4xDsKUkouX75MoVAYuN9vLWzWA6iU4sKFC1y/fn3N5xFCoGkCVy3bizi1PM5SgcBXr3dba5V+FXDm2gL1tk1Sh4Q/IBDRJZWWw41ykyPjy8TJ0LVw8GPlsMdiw+Lb18rUO94+SSGYSCV5ZDqGY3dZWlpisVgkGomQTCSIBT10W52w9fdVCk8pW4sgKaUolcssLdWYmp4iZq5h2uuXkYXYvgVNAE3zSG3UyJLJZEP/vWazSbnilYqDQRIzZq6r6LVaLfKFAmO5LIlUakfkD7zytmPv3GvS25ZcRdgMw0AmEizVl4jHY6RSKVqttqeIum44SBKPxfoUQQFY1s7VvwBPPPbYmopjb/k3UAQdx8F13bCE3+12V6mDbwVc12ViYsKzKXJd7/OyuMj169d5/fXXPRsmv3cwlUrtqjo4LAEPcacwJIBD3LXY6pdot9sNEwK20u+3FjYigLZtc/r0aRqNBk8//fSaDdqaFDx1T44v5askNIXbbWIVrlBu2iQjGnt7UifWKv06jsP8/DzVlk3MjICz/HcpJUJZLPWkKAgBtrtM/nqHPWylOHG9Qr3jkDZ1pBBYrstctUUqFuGR2QzZTAbHcWi3W9TrDUr+CTgej5NIJIiaJlIIlto25xbqzFU6CAn7cjHunUxi6jLs11NKeVO2a/A2V7kUFgp0up11hxC8/i8N17WRUmy/FzF4TtdFFxLb90HUdT0sm7rKpd1q02w2WSx6eakBGeydsA1O+JNTE8TM+I7JH0qhCdgtmiWFxKVfbbVtm7m520SjJuPj436aRhJQdLsWzWaDpaXVgyTJZGLXCODUWJYDh+/bfP0+sZNS8vrrr1Or1XjooYdCJd7p6SkNiOCbRQYDhbJ3jYE6eOjQITqdDsVikWKxyI0bNxBChGRwZGRk017LzdBsNocEcIg7giEBHOKuhghsJjbB0tISJ06cQErJvffeu+MvzPUIYKPR4OTJk0SjUZ5++ukNSz/vOzbJycvznJ1bojl/GtlZIhbxrDVGElGElDTaXW6V6h55cj1PtW67w/z8PKZpMj4S58pik96ONaW8sq5p+MkVSoUmy2slexRqbWptOyR/AIaURAyNm6UGD0zFMTTpe80lSSSSfcQoUIwwTF4pONRtP3bMhjNzSxTqXb773nF0/3j1KpG9CCZ9hRBMT8+w2LCplJaI6pKZbCwsZwcTxLsxrSs1DZSLtU5JWwoZEh+FwupaNJtNaj3ESGqSTrvD9PQ0sZi5Y0IKoEcMrK61K0qRvkYGdrfrpcMkEwlGx0bpn3oRy4kk2f5BkqX5Knmkpw76JHi7REvTJI898sim/YYBXNflzJkzLC0t8cQTT4SGzSvVweA/WO77vZPqYPBc6/WNRqNRZmZmmJmZwXXd0J/z2rVrq9TBZDK55dd8OAU8xJ3CkAAO8bZH0Id34MABFhcXd2Wbaw2BLC4ucvr0aWZmZjh69OimJ5xs3OAnnpzgz75+BTdlEDXGODAaZzIVRbkuruNw8fo8jl+6E3hf9gsLC+RGRhkZyaHVutysdGm2usT91IWlVgfTkMxmvROk3kO4gpNVr82L5fil4J7zjiIgjS62q9A1z5A4uE8fMVKe9cipG2WqLYuY5v1d1zSiuqSw1OFGucmBkRgCr/S7csw2mPSNmiaZ7Ahfv1whX+v4ZW9BPFLj6QMjTKWj3gAAK5I5NoCjFM2OQ0SXRPV++xjHcbw83AFOuqKPGHml4oI/NSuEYLFQwPQHZ2Kx2A6GP5QXpbYbZUIBzgoLoHa7zXx+nmzGG6zZbOQ5GCRJJlNouqTZaNBs9gySmCaxeIyE3xYw6Aj1gekxpvcfHui+ruvyyiuv0Gq1eOKJJ/ourNbrHQyIYfiev0Ol4l6yuRmklORyOXK5HIcOHaLdboeTxdeuXUPTtJAM5nK5gdTBIQEc4k5hSACHeNtCKcX58+e5ceNG2IdXqVRWqSHbQa8CqJTi2rVrXLhwgWPHjjE7Ozv4duw2k93b3HvkyKq/3S7WWGp6pV0FlCtlKuUKExMTJBMJlOMwltB413SCE1caVFsOEpt41OChPRlyyZiX++sPXSyTv37Ck4kZGFLSsRWmHsS9aXS6HUaTEaK6xJBaWEJeCSE8u5UlW8OMRohHNBzbxnYdXNui60huLlSYikM8Fl+VTtHyp4/T6TS5bI6TN6vcrrSJRzQMTeIqRb3j8K2rJT7wrhl0lOdBuAkBVCguLDR4fW6JluWi+SXpR/dmierSL5W721IRXeVSLBVxbIe9e/ZiGBGajTrNVotisYjjOMTMWEiStzJhbkQiWN3dGbAwNB2r5/3ebDZZWFhgZGRkzdzpDbelS2xXYZoxTNMbJFm21mlQKff0SyYSmOb6KSwJM8J99x9D0zcnOI7jcPr0aSzL4oknntiUFG3UOziozcxWsJkCuBFM01ylDhaLRa5cucKZM2fIZDKMjIwwNja2Zt6vUmpYAh7ijmFIAIe4q7FeCbjb7YaKQW8f3k4SPHrR23t05swZisUi7373u31FZTC4rsvCtbNrrqfV6XI9X/bupxSFwgKtdpvZ2RmikeXpYAEcHE9iVfMkRtLousZo0iAiJcqxUdJTuVzll3yDklig0gjIxiX7RuNcXqhjORJdk3QsC0MT3DuRQJNyXfLXi4jukTUhBLphoGOgUHQaHTShWFwo4Ci3L5mj0WiwuLjI2NgYqVQK23W5VmxhaCKMAZNCkIxqLHUVN0t1Do2nBrKgubjQ5G+uVby1+eXiCwsNGl2Xv33fOEo5DLAZABpdm3PzdW5VO2gScprFbEqwZ2YGqWlIoYjF48TicUZGvQnbZrNJo9GgWCwSiUR8lSxBJBpZt0dQCLFr5E+TAqvnvbVWru+gkAJc1Z8XDautddqtFs3AWsd1icViq/olAQ7vGWd89sCmz2vbNidPngTos1AaeN2bqIPr2cxsBY7fPrBTxbZXHTx8+DCtVitUB69evYphGCEZzOVy4bGo1+u7YgPzG7/xG3zuc59jfn6ehx9+mF/7tV/jySefXPf+f/iHf8i/+Bf/gqtXr3LkyBE+85nP8AM/8AM7XscQdw+GBHCItx2Cfr9UKrXK30/X9V0jgLZt89d//dcAHD9+fMsh8oUbF7HaTdSKk2ow9auUwnYc5ufnAMGePXvQ5WqVQQARXWMqZfSpI1IT2LZH/rzePuFN/vbEegV4ZE+aVFTjSrFNx1ZMZiLcO5liOh1BCj+5a5Pmtj1Zk7lqm47lEDEkKGjZiohhcO/sCKPJCJ12x5+urbCwsABCkE6liMW8oRfbBdvtn4L29lEBLparBiJ/rlK8kV8CBYmod8wMTaBJQb7aIl9rM502WX0kVqPetfnz1wvU2lboI5kHmiLBHiG8BJKeaV2BIOJHtWUzWVzXDQ2o5+bnqHWhZBkooTOVi3NoLBFGnxm6vkv2KgqkDj7BqdVqlEolJiYmicfj29iewFUbH3evLSBBPJ5geZCk2TdIEovH2D89zp79BzGiG39eLMvixIkTGIbBww8/vCtGyyvVwd7/tqsO3qkc4FgsxuzsLLOzs7iuS6VSoVgscunSJVqtFt/4xjdwHIdarbZjBfD3f//3ee655/j85z/PU089xQsvvMD73vc+zp07t6ZTwje+8Q1+5Ed+hE9/+tP84A/+IF/84hf54Ac/yIkTJ3jwwQd3tJYh7h4INUiH/RBDvEWwLKvPj29+fp5XX32VAwcOcOjQoVVX5a+//jqapnH06NEdPW8+n+fkyZPMzMzwwAMPbPkE0FyqcOn0S9RqNa5fu9b3pXl7scrV+RLtTidMwBifmGC9U5GQGpcuXWR2dpao3xvlfWi98mZI/gaAkBq2Y6MJAJ/c9AxsCOHluwbH1ft2UChX4SiHE9drXC02vYETIYlqcP9Ukgdm0mHPnqdoFmi3WqRSKTqdDq12m4hhEI/H+eu5LqWmTcrUQ6Ws44Dj2Hz/sUmysc2vS1uWw385PY+UnvoXQClY6iqeOZjh8NhgJ82/vlbmjbklTF3DcSyPFAiNruPyt46Osz9rDkAjPZy5vcTL18tYrhuWwpMRyXcdSDE1kkZo+qZEO9wXFLerbeYqniq5fyTOSMJ7/aUQKCFQrkOl0p/ru1VomkAh+4zAtwrHcWi1WnTabWazBrP3Psrk9CxjY2OMjo6uKut2u11efvllYrEYDz300B2f6O3tFwx+Dk59m6mD1WqVV199le/8zu+8o2vsRavV4vd+7/f4gz/4A775zW8yOzvLD/3QD/EDP/ADfO/3fu+WCeFTTz3Fu9/9bn79138d8I7H3r17+amf+ik+9alPrbr/hz70IRqNBn/8x38c3vb000/zyCOP8PnPf35nOzfEXYOhAjjE2wJr9futhd0oAd+6dYszZ84AcOzYsS2TP9d1uXn+FfDjrHr9/Vodi2v5Mkt1r1w3ksuRyWbXpW9KAP4AR6DsebFtnmq3FfIXZOFqPrnzBjZWq5OsoSACaELy7ntyHBxLstDoIgVMp01GEhFsx0UpF1cp8vPzKKWYnZ1dzmd23dCUeFxvU3Sg3HCI6hoKgQMcHI2RiQ12rA3dKyF3HJdIz0NcFwQusS28ZrfKbYTAI3+a5qmwAjqWYqHWZV92MFK11LY5caOKAhIRj/A4SlG3HF65vUSnUUXXdOIJr2Rqmua6pWJHKf6/c4tcL7dAea/56Zs1Htmb4ZE9GS9mzbEHzvV1leJ6qUWh3sXUJQfH4yQiOgqFx1W3l/oSQNM0kskkDx3Zz71Hj5Ka2Mfi4iJXrlzhtddeI5vNMjY2xtjYGJqmcfLkSZLJJA8++OCbYueyFRPqlergW5EDHIvF+Imf+Al+9Ed/lKmpKT772c/yzW9+k5/+6Z/m4x//OD/1Uz818LYCsv0zP/Mz4W1SSt773vfy0ksvrfmYl156ieeee67vtve97318+ctf3tb+DHF3YkgAh7irIYTAsixOnz69qt9vLWw1w7cXruty/vx5bt68ycMPP8zJkycHSgNZify183SadQDfx8735/NLv8VSkUqlyuTkJIlNynWapuPaNkJKQPmWLwLbcf2J3cH7kqTsV3mEFKFx88BQitGEzlg6inIdvwHfK0PatkU+v0AkGmViYqL/pCkEyWSSZDLJ+LhipFDjjfk6lZaFJiUH0pL7R3Qc2xmoD0wXkoNjMV67XacrXH+YBBq2YiRuMJndQjKDcnFsFzOqI301USmF8i1kBsX1SgvbdYkZy+RTEx5RXexqfM/sBFanQ6PZIJ/PA4S9kvFYvO94vTFX51qphS5B82+3XJeTN6rM5mKMJ6OeyjpArm/HdvnKmTyFeje87dvXK3z3kVHunUzhIlBbuGhylMvlQou5WhtDCo5MJBlLRkjGIkzkkkzuPUQ0niSXy3HkyBFarRaLi4ssLi5y6dIllFLEYjGmp6cHsni6E9hokGSlzYxlWW+ZAXWj0QDg7/ydv8OP/uiP8qu/+qtbvsBdXPT8LScnJ/tun5yc5OzZs2s+Zn5+fs37z8/Pb+m5h7i7MSSAQ9zVWFpa4tvf/jaJRIKnn3560wnB7SqAlmVx6tQp2u02x48fD/uotkoAG9USizcvh78LIcNt3Fyscv7KVbqdTl85dz0IKXFsm0Djc3yVzXa23pAuhMR1bALCuLL0u9VtBXFvuuZlBrfbbfLz86RSaUZGcoAKp5OXHwgoj9AcnBrh4NQIjuPiODaddpNavU65WCQSjRBPxEnEExvGtL1rNk2j63Kj3KLTcRBSMBLXeeZgDn1Ai5ZKtUJOt6hKieo5pl3bQUOyd2SNlJJ1sP7bTnhqrSZJJBIkEl48XafdodlqUqlUKCwUME2TeDxGLB7nYsG7gNB6iIchJR1XcanQxFkaPNf3b65WKNS7aFLgXUaA5Sq+dqHEZCoaJswMgo7t8sev5SnWO+Gr8trtGu/en+Uffff9ZMdniMb7L9BisRh79+5lZGSEb3/726TTaUzT5OzZs3S7XUZGRhgfH2dsbGxbJeydYrNBkkajgaZpIRF8MxNJ6vU6Usqwh7Z3nUMMsVMMCeAQdzXm5uaYnp7m8OHDA5Ge7QyB1Ot1Tpw4QSKR6BsqWcsLcCO4jsPNC6/23eYF2yuq9QbfOnkGBOzduxdD857DK+1C0DDWt49CEsxKGJrG0lINoVLEEvH++ynCYYdQUAkHOj1/PyU8vz3/T2t69Q0Mn8gFmcHNRoPC4iIjuRHSmU2sR4S/VuWph5qmYWg6ESNFMpXCtR2arRaNZpNadQ6p6STiMeLxBGbM9J7bVy11KfnOQyOUm10qTQszojOZioRm1xtBoSj55dMnDk3SubpEfqmDSFOKFQAApPxJREFU63rldk03uG88xkRqcCVxJhPllBRYjsLQgh5Khe0q9maNPlIqEJimiWmajOSW7VYazQalUplGS3ivq+/96D3IU4CrtSXciMb09MymRMRRiouFOgLCHlMBGFJgu4prlS7HJgc/Dbx8vUKp3umZNFe4SnFqvs3f7Sge2XtwzcfV63VefvllZmZmws9yQK4KhQJzc3OcPXuWRCLB2NgY4+PjZDKZXY1UGxS96uDt27e5fv06x44dA1izVBz8fCcQWMDs5DgEZfdAdQ6Qz+eZmppa8zFTU1Nbuv8Qb08MCeAQdzWOHj26JV+/rSqACwsLvPLKK+zbt48jR470fdFudVtzV87SbTX6bpNSopTiv790At2IMjY+7vfvrae++URQ01C27fX8KZfsyCjtVpNCcRFnwSHWY7WypiKgCEvEQkqU44I33+ErijIkcrBsAB3cFtLFZYbqPUr34t4QAqEU1VqNcrnMlF/O9tbbvy/B/9UKLU9qOq5je6Xo4DZdI5lKkkwlUa6i3fYyexcK+dB2JBGPE48nPHsWKRlNxRhNxTxja8dv8A/Y01pHWCkWCgt0Op2wfPq374tyrdQiX+ugS409uQjTmfV79NbCaNLg4FiCiwt1bDc4dALT0Hh0b2bDx660W7nSLnC51MJxXMD1SK2QKAU5UzI1PTWQEbXrKhxFzwvswXufKzpbtKS5sFD3e1CX3zCaFETMGKfLGu9LrL4AqNVqnDhxgn379nHgwIHwMyZ62gIOHDiAZVlhqfjUqVMAjI6Ohr2DO41U2yoCUvrwww8zOjoK3BmbmY1Qr9d3TAAjkQiPP/44L774Ih/84AcBbz9efPFFnn322TUfc/z4cV588UU+8YlPhLf9+Z//OcePH9/2Ooa4+zAkgEO8ozAoaVNKcfnyZS5fvsyDDz7I9PT0htuqd2z+8mKRV25W0aTgif05njk4Etp7LJULlOaurdpGpeIpJkYsQS6bG4xO+L16njDoDVZEzSimaZLN5VbZb0SjEeKJhJ/UsEKxCnwU/SfWZFD6Vf2Gzeu2YvX8QYBj2YBCE4K5hQKtZovp6Rki0QjOhv1cvl6kVKgcoRSGpuH6ubjBswWtjUJK9ESCpJ9fa1ldGo0G9XqdYnERM2qGJDgajaJcOyS4yj+OAm873tN5FjP5+TyucpidnUXzp3J1KTk0luDQWALdMLC3YdUiEDxzMMd4KsKlQoOW5TKZjvHAVJxcfHAlUQrJo/tzzNUt2paXiuL4vZZpQzAV16hVa8TjcSKRjZM5DE0wEjdYbHRRQoSk3pviFkymt9AriWfjs/LZovEEUkrs1GqD9EqlwsmTJzl48CD79+/fcNuGYTA9PR32BlarVRYXF7l69WpomhyogzslRZthbm6ON954o4/8wZ2xmdkIjUZjV0ygn3vuOT7ykY/wxBNP8OSTT/LCCy/QaDT46Ec/CsCHP/xhZmdn+fSnPw3Axz/+cb77u7+bf/2v/zUf+MAH+NKXvsS3v/1tfvM3f3PHaxni7sGQAA7xjkLg37cRHMfh1VdfpVKp8OSTT5LJrK3OBCXgetvml/7iAq/crKFJgULxrStlTl6v8Oz3HEQqh1sXXut7rMIrH928Pc9CrcW+fRMDkb9gwtftsamQgRedJ+X0xZU5tu2VTBtBUoNOIpEgHo9jmlGk1HoGP5SvKG0PXjnbQbkuN+fncV2XmZkZdGPwr5HgpC2lDq6D7apV6lR4IELy6R8H3SCVyZLKZLEtm1arRbPRoFguo/sJFbFEHDNqImSPcumrrbZlk8/Po2s601NTPjFUoVIqhfQMwJXr7VPw+LDErsIKdECkgpUHd9VQPDCd5thUylMAkSjlIny+vSyObqyO5uIR/pdjE5y8VeNWqQnAgVyMd9+TA9sjwpXKIMkcgsf3Z/nzNwpYgWWQUrgKZrOeyrkVzGSi3Cy3CKi6putoeoSukebp+/sJXrFY5PTp0xw5coS9e/du6XmEEGSzWbLZLIcPH6bdbrO4uEihUODy5ctEIpFQGRwZGdnVvrjbt2+vUv7WwkoyCOy6OhgQwJ2S3Q996EMUCgWef/555ufneeSRR/jKV74SDnpcv369b23PPPMMX/ziF/nn//yf83/+n/8nR44c4ctf/vLQA/AdhqEP4BB3NVzXxdqCGlMulzl16hTf8z3fs+bfW60WJ0+eRNM0HnnkEaLR6Jr3A/irv/orjhw5wt/kXX7nr66xJxcLs2YbHZvFepfnvu8ws9ZNKvmb4eMc1+Hq1as0my26RorXz11k3969GIaBo6DY6GC7imzMIG70n7iEpuPY3ZBQCOGV2AaJM3OVS6vZotls0Gw2QUjiQVJDPIahaduKRYNgYtjFsmwKC3mkpjExObkthUMgwmnmjVXDAaC8SeulpTqtlmfG7CpFPBYnkYgTi8WRmqTb8bKI4/E4o6OjHkFctS7PJ3HV8MqKtff6JHpr8OlhSBi9KDvE1rz1lJ+yEpArIaDTbjM/nyedSTMyMtJTshd+MkczNKF2HNff54TfGuCRDgXcKLc4ca1CfqlDRBfcP53l0T0pDE34nng9B0H1rqUfhaUOf/SqV45XQDyVQdd19j3wJL/9se9C998PhUKBV199lfvuu4+ZmZmBj8EgcByHcrkcEsJgkCQghL0DE1tFQP4eeeQR73hvEyvVwd7T7FbUwS996Uv823/7b/nGN76x7bUMMcR6GCqAQ7yjsNEQSLlc5uTJk0xMTHDs2LFNv4CDEvCJ61UMTYTkDyAR1ZmvdTh97gqJxHKzdKfb5dKlixi6QXZilhsLFf9krVhsWJy4VqHatryyriE5Mp7k/umU16AvBI5t9Sd7CPp8BDeCFD1TpkrR6XZp1OuUSkXcRQfT3KRvcB143oCCTqdLoZDHNNcnUYNASImGGih+bjNIXce1LRLJBIlkApSi0+l62bWVCgsLBSKRCJbVJZVKeYrOOmqKrvfn6q6FoLdwo5dE+VKfQiF7jnNYmlYeWV+5kWXC5f3baDRZyC8wMjpCJpfrJ5P+Y6NmnKgZJzcSJHM0qFQr5BcWvNYAv19yJh1h+sEJz5bIVeCrn+7KC4Ieghl2DojlfyfTJh98ZIqXr1VZbCty6RjH79vPsz/6npD85fN5XnvtNR588MFVViK7AU3TQrJ39OjRMG4wn89z7ty5cJBkbGyMTCYz8EXKrVu3OHfu3I7JH6xvMxMYUA+qDgY9gEMMcScwJIBDvKMQkLaVCsaNGzc4e/YsR48eZe/evQOVVIJtSSlYSzhTjkV77hIczgJQb9S5dOkyuVyOsYlJXrl0G/C+5DuWw7eu1Kh3LBJRHU0ImpbDmds1YhGNA6NxlK+89Jo7SyFWn6QHOQ66jikEZjTKqJ9d22gM2De46jjoLC3VKCwWGMnmvEnfbZakhJCgHG8wYccQCNfpX4sQRM0oUTNKbmSEpWqNxWIRwzCo1ZZotdq+xYzXNxg8VhOiL+5tJ9B1CQivXL5xW6Qv9nkTtSJoYASWljyj8OmZKaJmDLUpWe5tDciFrQGezUwVKSXpZIKIaRJPJAdKI1kxaB6S2tF4hB94cJJHj8yiaxr7jz1O3HfjDhS0hx56iPHx8U2fY6foHSS55557sCyLYrHI4uIip0+fRikVksHR0dF1zbJ3k/ytxE5MqBuNxpZznYcYYlAMCeAQdzW22vuiaVp4lS2EwHVdzp49y9zcHI899tiGPT1rbctxHN69P8eJ6xVaXYeYf6KrtSxitWvsm/FOKIvFIjdu3GDPnlnGRsc4c3U+JG5CCuZqHeodi7RphDYlyYhOtWVxabHBwfEkjm31kz+5NvlbrHc5v1BnsdElpmscGItzcCy+bH8iRJ9a5J14BNnsYH2D/W3+inK5RLlSZmJi3M+B3R6U328nELgDh6utj4ixca5urVqlVC4zOTlBPJHAdZdL5IGhbSKR8MrFydSO0zDAI+yO4w7+vhXg0SoVKodL1RrFcompiQmi0ag33eyXpYOovvBnfxPKn57xjL0VmmGQ0nVSqRRKKdrtNs1Gg8XFIq7vOZhIJIjFYgMZb6/EvskcuqZhJlKkR7xUnhs3bnDhwoVNe+fuJAzDYGpqiqmpqb5BkmvXrnHmzBnS6XToOZhMJhFCcPPmTc6fP8+jjz5KLpe742vcign10tLSUAEc4o5hSACHeEchuMoOSiynTp3Csqw+c+dBEQyBvOfwKCdvVPibq5WwHBvtlHgs1+XASJabt25SLBY5dOgQ6VSK+VKNWqMdbkcgaFneCbzXo07h+cU1Og72CvLnpX6sJhH5Woe/ulyiY7sYUtDsOBQbXWpti8f2Zj0F0bee8fZBrBr80HxikEql+voG83mPFMXjHhmMxWJUqhWWlpbYMzODvolx9WbQNB2pXOxdaDsWSKyutfYArFKUymWWajWmp6aJml6fp5QyLBUrV9HptGk2W5TLZRYWC5jRKIl4glg8vqXBlr51CZDaxn2E60IpyuUK1Vo1tNVxXLVsGSSWS9D+3Vc8fvViBB5RzKRTxJNJxhS+Gtyg3mhQLBYxjAjxeIx4POb3xG5MXpOxKBNZT5Wa2HsIgGvXrnH58mUee+wxstns1vf9DmC9QZIgok7XdWKxGLVajYcffvhNIX8rsZEJteu6/Lf/9t+2RdCHGGIQDN9ZQ7yjEHyRVqtVXn/9ddLpNI899ti2vkQDBTAW0fjE9x7iW1fLvD63hHAtJqpz7EuPcuXKZTqdDkeP3ocZjdLuWlydL/VtR0pJXPPKgrar0P1JYqWg67hMJqKrPN081Wf1Gf7M/BId2yVj6uF5um25XF5scnAswUjSDNW/UFVaB/WO7aVoWA6ZWII9s2M4dodGo0mpVMSyHaSAbC7X18u2LSjPz3DHQx8+DEOja61W7JSrKBQKdDp+RNo6pFVIgRnzSI9ijG6nTaPZpN6os1gsEol4/XOJRNwrGw5iQi4ltqsQ21ESlaJYLNJoNJiZniEeM7Fdd/tk0tsoCtCk8JVSgRASXZdkMikymWXj7Wazwdx8FSmEdwHgK8JSyN5rEhRwaHYcqUkiZpzUyCSXL1/m+vXrPP7446TTmxiBv4UwTZM9e/awZ8+evtjHSCTC6dOnvdYN32ZmJ4MkO0GgDrquyyc/+UkWFxf53d/93bdkLUO88zEkgEPc1dh65JnXTH3q1CkOHDjAoUOHtm2hoGlaWI6JGhrfdWSM7zoyxrU3TrBguVw4f5FIJMLRo0fRfYJ06XZxVdlWCJhI6IwkIizWO8QiGlII2l0HqekcHu8/2Ujx/2fvvOOjKtP3fZ3pmfQeAiSEKgLSQbDBioKCJIB1dZHVta3YvpZVfxZc3RXEgop9d8UuShELICogKqAQeu8ESC+TZPrMOe/vj8kcMimQhIQEPdfn4y45M3Pmnckk587zPs99B7N+Q9ft9gvKnD4sBl1IkcZi0FHu9lPq9BNjPS4WDDp9vYbTR8tc/HrIhruq700CYq12LuoWT3R0NC6XkzCLBbPFjMfl5HBpWWjfYCOrgXq9HgkFfzPoP4NeX+fWr6IoFBQUoMgBe5qTRaRBcPtUYDSZiKmy1qkuinLzytFJOlUMWiyWqlzmGoiAubdep1e3axtKqGhtj8lkqDrH8RjBphJohwhsG+vqmHCuZbztceNyOCkpLqZQlrFYQquiKbGRhFsCFjkJqRns37+f3NxcBg4cSGRk5Cmt9XRy7Ngx8vLyGDRoENHR0TidToqKiigsLGTPnj1YrVa1dzAmJua0ZgErisLjjz/OF198wY8//ki3bt1O23Nr/LHQBKDG7wYhBPv27UNRFHr06EFGRsYpna8uU2lbUS7HDu3lwIGDJCQk0r5jB/Q6HUJROFZURrndVes8kk6HXgfDMuLYfLSc/Eo3PiGItBg4KyWC1OjjAjBYtatLtOql4x6B1Qn60hn0upApTr8s13ker19h3WEbHr9CpFkfmD6WBSUOHxtybKSZnFjDw4mPi0NvCETZyX4/TmddfYNhGM1miit9+BWF+AgTFmPNaqFU1eukNHl4pNobRF3OVbLfT35+AXq9jnap7Rp0wQ54OuoQ4iSiyO3G6QzE3QXTSKxhgUESnSHwWvX6wHtYf8JLPS9HUSgsKMQv+1XRqpMk/IKQ3r+mYtTrj09bn6T6KukkwsLCCAsLI454fF4fDmdgq7i4pIQwi5mO0ek4HA4io2MpKK2kqLiYQYMGnVF9akeOHGHfvn30799f3a4OTs8HB0lKS0spLi5m69atKIoSkkhS3yBJcyCE4JlnnuGTTz5hxYoVmvjTaFE0AajR5gnmhp4Iv9/P1q1bqaiowGw2N8tWlF6vx+v1ql/Lfh9bfl3F4UMH6NChAwkJiaAoyIqCx+snp8CGpNMFJl2lwMU9mHyhKIJIs55hnWNwuP34BURZzUgiVDCcqGpn1OvoEGthb5ETY3ArWQS2cq1mIykRgaisoJl0fZXPvAo3Lp9MuEl/fApWL2HQQU6xne7dokhIiAdE1VBBVd9gVCSRUZEhwxS7jxSwpwxcSqB/0WLU07NdFL1TI44PKeh0SIqMaIbkBpPJWKv65/N6ycvPJ8xiISEhsWH2NAIUWYB0YsEm6STCrGGEWcOIF8etVqpPU0dERGCxhGG2WAIit4EosqL2XbZrl4pOrwuIP0WoFcVTQeL4OSRJjyIaJyaNJiMxpkAPnSIrJEWZkf1+9u8/QHh8KpEJEt26dTuhl2ZbIycnh/3794eIv5oYjUaSk5NJTk5GCEFFReB7nZOTE5JIkpCQQGRkZLMlkgghmDFjBv/9739Zvnw5PXv2bJbzamjUhyYANc54nE4nGzZswGQyMWzYMH777bdGZfjWR/UKoKIo/PL9N+QcPkTXLl2JqLHdtT+3WL3Y1qwoBQRJwOpDSHrCw3ToCBj5Vkenq79qF6R3ahTlTn8g2qvqmMWgY2BatBpLZ9DrTpj4ISsi6D5y/JhfRvH70RkMRMfGAaKqAlX7PMFhCp3Jwr6jMi7Fh0kfELxur8LGwyXoZA9npcZgMJowSAoNtfL2+hX8skKYSV/rfdABPl+oT1/AKDmfqKioQBN/Ay/GBr0OgdS4CpskYTKbMJlNxMQGrFZcTidOl4vS0jL0el1gu7R6Gkk9BCqWgVSSpOSkWtvKp9b7F0Cv06nVv5BI5yYQHRFGt/QUhICcI0eJTGpPUnIKR44cYffu3cTGxqrTtY0dtjpdBMXfgAED6k3/qYkkSURHRxMdHU2XLl3weDzqIMmhQ4cwGAwhiSRNHdgQQvDSSy/x2muv8cMPP9CnT58mnUdDozFoAlDjjKakpIRNmzaRmppKjx490Ol0Dc4DPhnBKWCfz8fan38kL2c/Z511Vq2KR0FZJbY6tn6hytcPCbu9EoNBR5glLJD1S8CmRqoa/hBVHiAnqyaEGfWM6BHPsXIPFU4fJqOOtLgIwqp+kiVJwu9XTqiD4iNMGPUSHr+C2ajH5/Oj+P0okp6EcDMmqX7xV52cUhdOr0y4xUhQvpiEgsMjs7fISZivIlA9Cws7ad+gyyOTfaScnDIXiiKICjPQr30UafFW9f3RG4z45OMC0GF3UFRcRHxsHJHRDa/46iWpShidWuVGbzAQExNDRFQUIOF02HE6XRQVFlalkYSpE9U6/XGB5/f5yMvLw1KjYmnQHa/+ndz37yRrU19jYGL6VMSkBGS0i0MIOHToEKaIOIYNP0/dCnU6nWoqR/X+ucTExEYZMbck1aeUGyr+6sJsNtO+fXvat2+PoihqIsnevXtxuVwhiSQNFcJCCGbPns0LL7zAsmXL6NevX5PXp6HRGLQoOI02j8/nq9UML4QgJyeHPXv20LNnTzp06KDetm7dOtq1axdyrCkcPXqUo0eP4nG7qMzdR4f27WolaHi8fjbtO1anWBIi4O/mdXuoqKzE6XQghCA8PCLQa2UNUy+OBrVaExCFOqlqUrhGjFRNqm+PCwIm0g35id6QY2NXgR3ZLyNJAiQ9FqOe87ol0C7SVJVje2I25tjYnmsn3Bz6nrirLGom9GuH22nHbnfgcrsw6A1V06VhWCwWtVqnKIIl2wsptnvQV22D+vwyep2OEd3i6RAXhl4KmHGLqlVVVlRSUlpCYkJiIAGkEeikqpi2U6ywqf2Y6gT38Si4YBqJ0+nC6/VisVgC/ZJGI8XFxUSERxAXH6e+B8fPVfewRqPXVpU+E/h347d/q5MSG0mnlFgOHjyILCuMuWoK1oi6Bbff71eNmIuKikKMmBMSEjAajU1eR1NpLvF3MoKJJMXFxZSVlREWFqZWResbJBFC8M477zBt2jSWLFnCsGHDWmx9Gho10SqAGmcciqKwY8cOCgsLGTRoUC3/ruaqADqdTsrLy4kyCdI6tq+zOld967c6QTNqIRRMZjMJFjOIBLxeL3a7HVtZGUVFRYRZLESEh2OxWtEb9AT8/2okZUgSOqRAHq/6HggUxY9eZ4Sqi/uJ+gdr0ic1AtltJ88uoehMJESYOatdFAkRhgZnD0dYAhfz49F1AfyyQkKEBYvJgF4fSXhkJEJRcKp+g4HovIARsZUiN5Q4vJiNevRV5zGa9Di9MtvzKkmLtwaGNZCrvPLKKK+ooF1KCmaLpeYbz74iJzvz7VS6fUSHGTm7XQQZ8VaQJNWqBUU+1QJglVF3HcMaIWkk4PcFtoorKivxejyBaqAk4fF41DQS9bOlCJRTNKRWK4lUmW6fgvgz6nW0T4hi//79AAw49/x6xR8E4vSq988FjZgPHTrE9u3biYmJUauDVqu12frn6uPQoUMcPHjwtFjUBAdJ0tPTQ4RwcJAkLi6OxMRE4uLisFgsCCF47733eOKJJ/j666818adx2tEqgBptnuoVQI/Hw8aNG1EUhQEDBgQqSTXYvHkzERERdOnSpUnPF6wu7t69G0nx0y6y7qpaQVkl+48V1/n4oPiTpFDLlurVGF/VQIHL6cTt9mC2mKvsRsIxNKBSotfp1QSIYGRcXRmzNfF6veQX5GMxW0hITDjuQShJ6BqRPez1KSzZUUC5y4/FoEOSwOMX6HQSF3VPpEO0EVGXygomUzhdOBx29tlkDtklrEYDOt1xM2xvlRXOX4Z0CPQtCkFJSTFOl4uU5BRM5tpbyluOVrDhiA0hQK8DWQGdBEM6xdIrNQqhCKRm6K8zVOuvawgup5OCwkJiYmIwGoxV1UEnABER4VgsVsKsYRgNxlOa/K1eSQROuZrYKTmWypICDAY9GRkZdB9wAZbwpgkpl8ulVshKS0sxm81qhSw2NrbZt4oPHTrEoUOHGDBgQKv6EwohqKyspKioiOLiYj7//HOWL19Ohw4dWL16NV999RUXX3xxq61P44+LJgA12jx+vx9ZlikvL2fjxo3ExsbSu3fvWtuxQbZt24bJZKJ79+6Nfi5FUdi5cycFBQV07tyZ7B8X071LbTuZurZ+1a1YNblBqlf8BQn22sl+GafTicNhx+1yYzQaqzJrwzGZzfVUqwJhskIEevaOCzcJnaQ7vo0rUEWAy+2ioKCAqKgo4mJjUWPn9Hpk2V/jPCfH5vSx7lAZxQ4fQgjCjHrO6RBN96Twhpk+C8H2Y+X8llOOWXfcAken1+H1CyLDTEzsn4os+yksKECWZZKTU+pM6vD4FOZtyMWvKJgNxz8bLp+MxaDjmoEd0OmruRqfBJdHZlteJUfKXOgk6JxgpWdKJEZD1UAPDRNY9ko7xcVFJCYmEl4911UIvB4PDqcTh8OJz+clrMpepqlpJKHV26rJjyYW2cJNBkx+O2azmU6dOhEVl0SnXoOadrIayLIcslXc3FYrBw8e5PDhw60u/uri6NGjTJs2jc8++0x1LLj88su57rrrGDVqVGsvT+MPhLYFrHFGkJuby/bt2+natSudOnU64dZRU7eAvV5vSHRc7sE9eByVdd635tZvsOqnVt9qiL/AfWpM/VIV0yaB3qCvbbPicJCXn4ck6QgPt2K1hhNmsYBOQq8zICuBgQijXqdu+VU9U0BohmwjVwmRkhISE5KIjApsy6pbyrIcmB5uwNZvdWKsRi7pmUiFW8YvK0RbDVhMZnz+Bs79ShKdkyLZlu/A45MxG/UIoeDzK/hlQYLBR1FhIW6XC73BoNql1EWxw4NXVjAbQ283GXR4lcDtKTHWBlXEXB6Zr7cVUOE+PnRS4ignp9TNuD7JBFL6qjKXTyCwgrm+ycnJhNUcCpAkrOFWTBYLsXFx+GUZR2Wl6rsXSCMJDJKYzSdPI6k5uBNIlGha9U/2y8h+O2HREaSlpaPTSSS0PzVfzero9XqSkpJISkoKqZAdOXJETfBJTEwMiObw8EZtFQfFX1s1p163bh2LFi3iiy++YPTo0fz888988803bNq0SROAGqcVTQBqtHn27dvH/v376devH4mJiSe9v8FgwOPxNOo57HY72dnZanSc4vdSmnugzmpYYWklFU53lZFw1ZZbtS1fgah1ra5ZKRJCQD07XtUza1EELrcbh8NBUVEhQojjWb3WMAw6HbJ8kiqPgLKyUioqKkhOSibMGnZ8LSKwNp0uMDSg01UTsw2okgEgSURVjSHrJB1+2X+SB4QSZtJzftc4Vu8vxeWVq+LL9PRIstIr0YSttBihCGRFprS0hLAwK1ZrWC3rFIMuUPVUFKh+k6IEvj+GRmz97sivpMLtx6gP9F8CKEKhwO5hd2ElPZIjT2zUXC3Xt11KCpU+Hb/uLqbE4SPSoueslEg6xVmP2/UIMOoNRMfEEF3lu+d0Oqsi2vKOR7RVTVXXfO2SoMag1MnFaX34fX689jLS05Lp2DENSQJLeBQRMfGNP1kDkCSJqKgooqKi6NKlS0hm74EDBzCZTCFbxfVV/oGQWLq2KP6+/vprbr31Vj788EPGjRsHwMiRIxk5cmQrr0zjj4gmADXaPPHx8SQmJhJRffvsBDS2AlhUVMTmzZtJT0+na9euSJLEod0bgZoXVfD6/BwqKFXj3urq95OQkKp68yAg6ISiBARjlVbTVYnHYKFQqkqQlTju2SYQoJOIDA/EkAmRiNfjxul0U24LDJGEh4UFMm3Dw6uGSGpQFTPm8rhJbZeKsUbfnE6nC1QSg1u/Qc0XTCOp2kquerGB96MeURGwatHh8zdOAAK0jwkjq287jtlceGVBUoQZq0GQl5dLVGTA48/jCfQNlpaWUFQkE2YJU6eK9QYDSREmoixGyl2+QKYqEgoCnwIJ4Sbiw02IBg5Y5JQGbH101V6sJEkgK+TaPPRIjgp8xup6L9RcXyep7VLJd8j8sCtfra6WOSGnxMXQLnH0SQ2IlJq+fzq9rlYaicvppKSkJJBPHWbFarWqr12vl0KqwE2t/vm8PooK8xl0Vroq/gASO3Ru9LmaSvXMXlmWKasamNq5cyc+n08dpkhISAixZGrr4m/p0qX89a9/5d1332XChAmtvRwNDU0AarR94uLi8DdCVDRUAAohOHToEPv27aN37960a9cOCMS9VZYVqxFvQhz359t3rBi/rKiPr2/YQ1QXTUIKCI8q7RHI+hXH7xO4Y4Nem9lixWg2Ex0bjSL7qay0U2kPbO1azOZAPFu4FZPRiFAE+QX5CCHo2KEDRoOhqseuakigSuTpdXoUAYaq1yiCKlUChEJA8wUNWAQSumpiF5QquxqjwdAk8RfEaNDRKSFg6eJyOsjLKyGmqiIGYKkSu3FxsYFEDpczJJHDGh7OuemRrNpfjssX/P5LhJt0nN81ocHiDwK9dDUJvGaBXle/wArN9U1Fr9ez5kAR/qrklqCg8iuw/lAZXROshBl1J/T9q55GEifiOFho59fcCircJVgN0DXWQFp8OFZrOCaTscripvGTxF6Pl/z8PHp36Uh62nHxZzRbiYpPafT5mgO9Xq/2BQohsNvtFBcXc+zYMXbu3ElkZCQJCQl4PB4KCgoYPHhwg/9QPJ0sX76cyZMn89Zbb3HVVVe19nI0NABNAGr8DtHr9ScVjIqisH37doqLixkyZIjqD+b3ecnbvwNAnUpUFAW9Xk9hleFzzWGPmuIvdC2G0G1CIZB0EkpTGvMFqoiRql5ncMuw+hBJaWkpBkPgeU0mM8kpKUjVp1arJkP0On0go1epKUapdr8a/6zyJ0TIoASEroQEIpD3a9AZkHRVswcSal9koCAa2BpXqnaXg6I6cL7jYtJeWUlxSRmJiXFYrRFVr7uaSXb1RI6YGDWn2Olw4HW7GJyop9RnwoeeuMgwMuKthJkMtZJXTkRGvJUiuxdFKIEpaQn8SsBgOy0uvM7tVaEoFBQUIMuKmutb5vBid8voq4k/AIMEPkWQW+6me3JUgyd/t+fZWX2gRG01dfqhOE/GozhJNNrQ6fVEREQSZrFgsZw4jaQ6Xo+XvLw8UpMT6dW9c8haE9pntLhdS0OQJInIyEgiIyPJyMjA6/VSVFTE4cOHcTgcmEwmcnJyVKuVE20Vn05WrVrFddddx6uvvsr111/fJt5LDQ3QBKDG7xCDwXDCCqDH42HTpk3IssywYcNCrGTyDuzEXzXAUF0AyorgUH5paNUPqc5hj+NItSox+iYMWhx/rF4VCvoaNiTVh0hcThcFhQUYdHo8Xg9HjxytNUQSXJtOR5PEqAi8vKp/CzWjVxF+ahfapOOpJ6pXsoKQ5aq1BE8qsNls2MrLSUlph8VyfHtPEoHbJUmqmn0+LiD1JiMmo5GYmCgQAqfTRazDgcvpQHhdOCu9iLAwrNawKoPt4Ak4vh6EKqqEEJyVHM6RMhd5FR4QAS8ZCUHnBCsZCRG14v5Cc33bqYMqUh2fD0nSqWJUonabQX34/Aq/HipDEaAPCm8J/LJgR4nMnwel4fN5cDpcgclaoRxPIwkLQ1dHi8DBYicbDpdR6vQRbtKT2Sm0z09vMBGb1L5B6zvdGI1GXC4XPp+PoUOH4vP5KCoqYvfu3Xg8npCt4rrsok4Ha9as4eqrr2bmzJlMmTJFE38abQpNAGq0eRr7S/NEW8CVlZVkZ2cTExNDnz59QqoElWXF2Ipyqz8xELhAH8i34fPLoeLvJNUVnaQLsX3RSVRN/Tb+IiAhqT1nJ/KgqxWPVtcQSZiViKhIrBYLcpNKkaHoJKlWRm8oQdFc80VVCUMCFbbCwkI8Lhft23fAWNMCRa0WVmtTVBUbIf9vrkpZkeX4QN+gy01xUTF+2V+rb7BOJAmjUc/os5M4UOwkt9yFTpJIj7eSHmdFQqj9nBCwNCksyMOgN5CSkoxU1TepCIgLNxEXbqLY7kXSB0SkIgR+WWAy6OgYH45AUe1vTkR+hQe/rKCrEn9BIavTgcevUOzw0T4uMhBBJuLxer04HA7Ky8spKirCYjETZg1YCxlNRnblVbJyb4l6fjdGFm4tpMKrMKl/oB0irl0aujZSSauOEIL9+/dz7NgxBg0aRHh4oHUgPj4eIYSaypGXl8euXbuIiIhQDaijoqJOixBbt24dkyZN4l//+he33XabJv402hyaANT43VGfACwoKGDLli1kZGTQpUuXkF/IiiyTu39byP2DfnSFZZWUVjjq7ferC4lQ8SeCkWFNvAZIOh1CkZGg7rQPAbZyGzabjaTEJKzhVZYj1frHEAl4PR7sTiclxcUU+KsLImvdQyQnQwh0ekOjJ38DLyrwviiKj8LCQoQsk5KSoppgS9UGUALbxsrx/sQTLinwXks6CLNGBPoGY2Pq7Ru0hlmreudCT6zXS3RLstI9OVzVmLqqyd9gEbdmrq9ctc7qDM+I5dsdBXj8sjokpNNJDOsci6naMBAidAnBOMCqWh9Gg+74HaoeIKllWAmjXocOERg6AsIsZsIsZoiPw+/zY3c6cDgc2Mps6HR6Vh85vk5Jp8NoCQNg+e5iRnZPID7SQny79BO/2a2AEIJ9+/aRm5sbIv6CSJJEREQEERERdOrUCZ/Pp/oNbtiwAZ1Op4rBuLg4DPX9IXAKbNy4kaysLB5//HGmTp2qiT+NNokmADV+d9QUgEIIDhw4wIEDB+jTpw8pKbUb2gty9uJ1u2odlxU4mFeMTm9ssPgL7NER0kNX26uv4eik4xOiep1U+zyKoLikGKfTRWq71DoTMgCQwGQxk2C1IsXH4fZ4cTgdVFZWUlJc3OgkEgBDsN+yidc3RZbJzy9AkiA5pR0Go1F9raKmlyFUpZUEKofqTYKqLdXAEaNeH6iQClD3o0/QN2grK6s3p9gQ8n3ThUz+Bocmaub61iQ52syEfqnsKnRQUukmwmKkR3I4yVHWUGNwKfTlHjfSDvx/UoQJi0GH2ydXK3oqKALCzXoSoiz1VoYlg57IqCgio6JQFIWDuSV4FEfwaTFZjlvLCGBvkYOuXbpgMJ6aIXNzExR/eXl5dYq/ujAajbRr14527dqhKAo2m43i4mL27t2Ly+UiLi5OFYRhYWGnvMatW7cyfvx4HnroIf7v//5PE38abRZNAGq0eZqyBRwcApFlmW3btlFWVsbQoUPrTAVw2cspyT1Y67gQgjybE1OYHqvV0DDxB+gNoYMfOmhy319ggCJwUTdItcWfIisUFBagVA0enCw9QqfToRMKfiEwmozEmGKqBNHxIZKy0jKMVSbE4eERgVSGOl63jkANqqniz+/zk5+fh9Fkol1KMkotL7u6EKF2NdWQkAKVUqpi8qDKnzHwuOroDQa1ZzKYU+xyOUNyisOt4VjCLKowCmb/AnjcbvLy84mJiSEmOvqk2/rRYQYGp0WBFH38lTRiKCX4/Bd2jee7nYUoBCaOdbpAP+hFXeOQhKjrbamF0+HA7XKo3zadwYjRHNoj53HaCY9tncnf+hBCsHfvXvLz8xk4cGCDxF9NdDodcXFxxMXF0b17d3WruKioiD179mC1WlUD6ujo6Eb/7tmxYwfjxo3jrrvu4uGHH9bEn0abRouC02jzCCHwer0Nvr/b7WblypWMGDGCjRsDfn4DBgwI8Qyrfu79m1bjclTUOl5YVsGaTbuwV1ZiMpsJDz95dUxCCtmmFEIEzJqb+GOm1wUHP0SVr91x/D4/Bfn5GAwGEpOTGpSlGhjEUE4oFIJJJA6HHafLha6OJBIIDNv4fU2r/gWrZ+Hh4SQlJiILccq5tQB6SQq810KoptzBiePq1jWBmZLABHTI+qtyih0OJx6XE6+6TR5BWJgFg9GA0+GgsKiI+Lh4IqMa5jcXGtFWdyxgQ6lw+dmeW0G5y0d0mJGe7SKJC7c06HxqMklSMl/vLKPU4cMSFYVef/wPB7Ne4p4L2mOJTiI8PFwVRKerd64umkP8nQyfz6fG0xUXBzK+gxY08fHxGE9SFd+9ezeXXXYZN910E//617808afR5tEEoEabp7EC0Ofz8cMPP2A2m4mPj6dXr161LCFkReDxK9gLDlFweE+t53N7fWzaexRZVpAVJTSn12Qi3GrFGh5eqzp2XLAFv9bV3bPXIFQzwVqDH163h/yCfKzWcBLi4086kBJcm4TSuK1oReByu3A4AqkUwSSSyAgrlrCIqvHcxuFyBfKIY2Ni1CqLOMXcWgBDte3xBotJEfDZCw6iBMWhXgp8jnx+Pw6nE5fLjdvlwmDQ4/fLxMbFNqjyB7XFX6PWV9d6a2wVB6yF9CetKJbbyimzldEuJQWzxUKx3cvSPeXojMerf5Ikcct5aWRdPgajxUpJSQlFRUUUFxej0+nUqdr4+PjTZrMihGDPnj0UFBQwaNCgwJDLaXjO4PBMUVERTqeT2NhYVRDWFKD79+9nzJgxXHvttcycObNBf4xpaLQ2mgDUOCNoTLRbbm4uW7ZsoXPnznTr1i3kL3GvX+Grrfn8sLOQSoed5IqdDE2LokdKZECIVKVd7DqcT5ndXUuQKLKCy+nE7nTgcrnQ6/SB7cJwK5Ywa8hFWFd1vqb+gAXzfmsKCKfdQWFxEbExsQH/woaIJhEUSE2bQg6ew+vxYHc4VPuNsDALVmvg9TdkWtReWUlxcQmJiQmER0SowlanM6AoTTeRDiavBLd9dcFkk6acCwgYw+iqUlv0CAS2MhulZSWYTGa8bjd6g57w8IhafYMhVFnXVF/JqVQ665oAP+n5BNhsNsrLy2nXrp3aI2oy6OnSIZn1h8vJrXATZzUxrHMs6akpZPQZGnKKYO9cUBBVt1lJTEyss7reHATFX2FhIQMHDjwt4q8uXC6XKoRLS0sJCwsjNzcXq9VK165dycrKYvz48bz88sua+NM4Y9AEoMYZQUMEYNAa4uDBg8iyzIUXXljrgvHGjwdYsr0Qs0FHmLcEd/ERzIqbsb2TObtdJIqiUGSrZN+xkpNPm1ZtlTpdThwOB5KkU4cowiwWDIamD35IVGUKV1XFgm1s5eWBKk5iQmIgK7iB6HT6QKpHM/y4G3QSspDwejw4nA6cDidej+fEQyRVU8rlNhtJycmEhYWhk6pyelXn6FNZ03FhVLMK21jUbeQqdDo9pSXFVJRXkJySjNliCXzvXW5cLhcOpxMQWMOq/hCwmNW+QUMdQztNFYB6SQpUk2sITUnS1V/9E1BaVoq9spKUlHYhA0Ld2ieQGFM7NSP97EFExtafuV3dZqWoqIjy8nIiIyNVMRgREdEs259CCHbv3k1RUVGrir+a+P1+SktLmT17Nv/5z3+oqKigc+fOPPnkk1x++eXEx7dMZrKGRnOjCUCNMwKv18uJPqqyLLN161ZsNhsDBw7k119/ZciQISFDHzmlTv6xYDsGvY5Y63GBklNcSXqEzAPnJ1BRUszazTvwNjLSTKfTB3rmHA4cDieSEFisx/NapUZWBYI9Yga9LhA9pwhKSktwOBykJKdgsjSm4iIdr/6dInpJQki1Y9CqD5EEt8mPD5EYq7JxHaoIEUKgr6rSNYtgC/byVe/9a+q5Qj5nEiVFRThcTtqlpGA01TEVKwJ9p05nYJvc75cJC7MQER5BWHgERoNeFfABw+kmfB+ECAyh1HhZJxSTAkpKinE4nLRr1w6j6fhnPtpqoVdG7SEPszWSbv3Pb9TSvF6vKgZLSkowGo3qVnFcXFyTKmLVxd+gQYOaZTq3ucnLy2P06NH06NGD/v37s3jxYrZs2cIzzzzDww8/3NrL09A4KZoA1DgjOJEAdLvdbNiwAb1eT//+/TGZTKxcuZK+ffsSGxur3m/V3mJmLttHp/iwkApFhcuH2yfz4qSzyT12hMLiMrxuJx6XA4/LjsdpV9NB6kI15a36X0mAO1gdszvwyzJhYWHqIEUwJaI+ghd1nRRI61CEoKigEL/fT3JKykknfWui1xuQT8GqRUWIKm866YQCq+YQSbBvTe2dkiS1YheoXlW3d27sko4LSTjF6l/N/johKC4uxe12kpLSrsHvu9/ro9Jhx+Ny43a7MZvNhIVbCbdaMVvCEIpSlRAS+IZU6daAIXTNoZQq6qokwgmGSQQUFxfhcrlp1y507RLQt0sqVkttMduh2znEnELyhyzLlJWVqVvFfr+f+Ph4VRCa6hLQNZcuBLt27aK4uLjNir+CggIuv/xyBg4cyHvvvaf2Qx49ehSfz0dGRkYrr1BD4+RoNjAaZzQ2m42NGzeSkJBAr1691GpDXWbQ4WYDBp2EVxaYDVWdXkLg9csY9Toc9koKS2wBz7iwcExh4USSBIDf6wkIQmclbpcDn8eFrCjY3TImo54w43FRp9NLmC1mzBYzcbFx+LxeHE4n5eUVFBcVYw6zEGENJ8xqrS0qBGrGMELg98sUFBSg0+tol5p6UvFYGwmh1M6tbQqBi5x00u1LnU5HeEQ4YWFh5OfnoygyZrNFnbAMDw/cFma1YjCcfHjhRIRMWFf1bzb5XIaqaitVub6Fhch+mdTU1EalYRhMRhIt8fgVBdkv43I6cTgd2Gw2tWfUag1sFdfqG5SO29lUk4dVPoehgzKSJNUp/oQiKCoqxOv11RJ/AO3io+oUfwaThaiEdg1+nXWh1+vVQYmzzjoLu91OYWEhR44cYceOHURHR6tbxVartdZWcVD8lZSUtFnxV1xczBVXXME555zDnDlzQoZhOnTo0Ior09BoHFoFUOOMwOfz1bq45+bmsn37drp160Z6enrIxWT16tV06dKF5ORk9ZjXr/DA/G0cLHbQITYMg07C4fFTUOlh9FlxnB1WifeEkWZVCEH24VLW7snFYbdjkJ2khkPf1Egiwwwn9Pzz+/w4nYFtYo/brdrLWKviuYIVLL1Oh8vlJj8/H6s1jIT4hAZN+tbEZDDh9Td8gro+dBIoclXuWAOqdapFjdFIUlJiYAtcgNfrCWwV2x34ZD8Ws5nw8IgGD5FU5/iwRuBfpzJcUd2+R5EVCvLzkXR6kpISGy26j89u177F6bAHtoodToBAi0C4lbCw+tsEQqp/VZY2wbSPIAKBUASKIlNUGKi8tUtJqZX/azLo6d+1Pfo6XlNKp7NIaN9ylSu3261uFZeWlmI2m1UxGBMTgyRJ7Ny5k9LSUgYOHNgmxV9paSnjxo0jIyODzz777KTWMI1h1apVzJw5k+zsbPLy8li4cCFZWVnq7fX1VT733HM8+OCDdd42bdo0nnrqqZBjPXr0YNeuXc22bo0zF60CqHHGEfQEy8nJoV+/fiQm1m5Yr6sCaDLomDqiM7N+2McxmxtFCIx6icHpsfSLlbFXNqzvb1tuJct2lSIwEx4Tjl9R2O324a7Uk9UhGr/Hicdlx++rLbwMRgNR0dFERUej+GUcTidOh0M1Xw6zhhEZEYnD56O4qJDo6IBRc1MqeHqdHq/P0/Sp3yqC0Wo6Q8MEltfjDVjUhFlJSEg4vnYJwsIsmMxmYmJj8ftl7PbKJieRBFJR1EU2uZIoqvrrBIFexvz8fAxGA0mJiY3u3YSAYXMt2xd0KEIJpI2Eh0MCeDwBv8HS0lK1b9BqDY3l09c0/5aqiT2hhHwuhKIEjKwFtO/QAX01kRh8THpyTJ3iT28wEpvcsdGvtTFYLBY6dOhAhw4dkGVZtZjZunUriqJgNBrx+/1ttvJXXl5OVlYWHTp04NNPP21W8QfgcDjo27cvN910ExMnTqx1e15eXsjXS5Ys4eabb2bSpEknPG+vXr34/vvv1a9bIvpO48xE+yRonFH4/X62bt1KZWUl5557LhERtacYITQNpDpdE61Mz+rJhpwyKj0K7WMsJBh9bNtzoGELEILfDtuQhSAhPLCNZkaHSa/jmEOmSAmnW/tA1VH2eY/3EboceF3OkN45nUGvplEoioLb7cFeWUFu7jEUWSEsaC/SBIQiAlEdzTCNGYixo1bGbV24XC4KCwqIjokhJjomRKBICDVJQ6fTYzAQSNJoQhJJTWGk1xua3PsXjI4L5PrmE2axkJSc0iSjZr0kIct1TOrqJEJcvCUwWyyYLRbi4uPwe304nA7sQTFsNhNmDSMiIgKDwVjr9dc8n1AU8vPzAaqiDkWt9yPaaiExJgpJp6vq5aTK+ghikzuiP43CQK/Xk5SURFJSEoqisHnzZmw2GyaTibVr1xIbG6v2DbaF6d/KykomTJhAfHw88+bNaxHbm8suu4zLLrus3ttrRlguWrSIkSNH0rlz5xOe12Aw1Bl/qaGhCUCNMwJJknC5XGzYsAGj0ci55557wobyuvKAFUVBURTCjDrO75qAJEl4fT5+yd7a4HX4ZEGpw4vFEFpFMRkMKC4fpY7jwyJ6owmr0YQ1KjCIIhQlMFzitFf1E9qRq7zv9HoD1jAdPk/AWiQ2Pg6/z0dBQSAnN+i1F2YJa9BWsNlkbqatXwlZFlUC68QVUofdQVFxEQnx8URE1k7I0Ovqt8XR1xDDwSGS3LzcQE9hlfF2WJUgrilFlSZW/yRAVpTjub4REcTFxQcqnY3UzoFKqVRb/CGd1AzcYDISbYohukoMu5xO3G4XR48eQ6/Xq20CFosZSQrNJFZkhfz8PHQ6HcnJyXVWLSUgo10cIBCKTHVpKEkS8e3SG/dimwkhBDt37sTpdDJs2DAsFovquddc8WynisPh4Morr8RqtbJw4cIm/1HWnBQUFPDNN9/w3nvvnfS+e/fuJTU1FYvFwrBhw3j22WdJS0s7DavUaOtoAlDjjKC0tJTs7GySk5Pp2bPnSa0lDAaDKgCFEMiyrE4RV3/szn2HG9b3V4VRLxFhNlDqrCauJPDJgXNEWur/kZJ0OszWCMzW41VLr8dFTkEZlZUVuEuOIbvspKa2Vy07EuIFLo8bl8NJUXExQlGwhlWJIWtYne+DhISvGcSfCJoYSxKyfOIp4mDKRHJSEmF1VGyqV+xO1qsXHCIJjwgHIQJeew4nRYWFCCGIjIjEbLGor/9UJn/1Oh12h5OCgny1aqnXN+18Br2uzv5PnU5/UvEcsiaDnqjoKCKjIolXFFwuF06nk8KqnGJrRARhFgtWa1ggrzovEAeYnJxUb8W3vsEPgKj4drWygE8HQgh27NihWjcFhVVYWBhpaWmkpaWFxLNt3LgRnU5HQkICiYmJpyWNxOl0cvXVVyNJEl9++WWbqEYCvPfee0RGRta5VVydoUOHMmfOHHr06EFeXh5PPfUUF1xwAdu2bSOyjj/SToSiKJrJ9e8MbQhE44xgx44dGAwG0tLSGlQB2LFjB3q9nu7du6MoCrIso9PpQh7r9ng5cCQXWZaRFSUQ+1bPv6sbKP92qIxvdxZiMegINxmQkSize0iMNHPz8DRMhob9kiys9PDllnzybG5cHg8Wo55zO8dxfno4ftWGxoEsV1UVRcAOJ+A36MTn9weEQHg44Var2vBvNBjxncC2pqEcT+k4sddcaWkJdrudlJQUTHVsjUlVXs9BbSRJekRTcnAF+H0eKioduJxVrz+s2utvpBgwSBKVdgcFRYVqrm9w8raxPoL1DX7UtAhq8NrqSPxQ/QZdgb5Rv88POgmT0UhSUnK9NjUnGvwA6HLOcMIioxu1vlNFCMH27dspLy8PEX8nQlGUkHg2t9utppEkJCQ0e2XO7XZzzTXXYLfb+fbbb0M8RVsaSZJqDYFU56yzzuKSSy7h1VdfbdR5bTYb6enpvPjii9x8880NflxhYSFJSUmNei6Nto9WAdQ4I+jRo0edPX31EewBlGVZ/cu1pnC0mE2c3bVTg84nhMAvy8iywvABMom/5fD9jiIq3V4MOujT3sxfhranfbQFRVYC91WUkH9X/9rl9bNg8xGOlbkwCS8xYUb86Fh9sIIoq5lzq5n0+n1evFV9hB6XA7PZTGxcHL6qvrHKioqqIQoLkZERWCxhjfYKrElga1QODC/I9WyHCkFhYSEej5fU1NR6Bzf0+uZK6RCYzRbiTGaID7x+l9uNvaKSkqLGD5FU2CspLCwmMfF4qoquievT1TKQrjqu0zX6fIFqaR1bxhKEh4djCbMQFRlFbl5uVb6zxNEjR0L8Bo3G432T6cmx9Yo/a1Rsq4m/iooKBg0a1OB+Op1OR2xsLLGxsXTv3h2Hw0FRURF5eXns2rWLiIgIdas4MjLylLaKPR4Pf/nLX7DZbCxbtuy0ir+T8dNPP7F7927mzp3b6MfGxMTQvXt39u3b1+DHzJs3j9tvv52rrrqK7t27c99996m7AxpnNpoA1PhdotPpsNsDlht1+Y01FkmSMBoMGA1gMcPtI3swcVAnDpU4CTcZOCslAn0jbFp+3leCw+okJcxLhNWMxWwGBHnlbg7JRu7u2xNFEaqA9csKsiKjyApenx+XowJHZTnOygoc9nIcdjvlFeU4HW4Ky8owmoyEWQP5xA0RQzXRB42adTqoQ8AoskJBYQFCUWjfvn6fPB1SwFuvyu24qb16AEaDHp98/PFGkxGjyURUVCSyz4/T5WrwEImjsoKiklKSU5KrTZxKTfIRrJ0ecpxGn0+AUl+1sKqP1e/1kZufR7jVSnx8YMr6uN+gE1uZTe0bTEmIJyG6/sjA+HadGre+U0QIwbZt26isrGTgwIGnNEwRyOAOp1OnTmoaSXFxMYcPH8ZgMKhiMDY2tlFbxT6fjylTpnDs2DF++OGHEDP5tsB///tfBg4cSN++fRv9WLvdzv79+/nLX/7S4MdceeWVJCYmsnHjRmbOnMn8+fO57bbbmDBhQr1DeBpnBtoWsMYZgSzLDaoACiEQQlBRUcHu3bux2WxERkaSlJREcnJym+nheXflTt79LY+0uEBjf5Bylw8BvHdjf8JNDf/7zOdx46y04bKXU1lWTEHuUUpLiqm02zEajURGRREZEYXJYkERSkBcVqWMqP9WBLIikIVAkQPGw2olUxHIQkGWBV6vj2O5uej0ehJPZJVSldIRFEf1plY0AAkCJtnVhFx9W9OKrFT1DQaSSKoPkVjMZioqKrDZymnXLnTLuik+gpLgeFZzDZpS7axz67fa+VwuF/n5eURGRhIbG1dnZVZU6xtMjTJiMRqIiooiKjqKqMgo1dfQaA6j+8CLTlslR1EUtm/f3izi72TPUz2NxOfzNTiNxO/3c9NNN7Fr1y5WrFhRp8VUS2G329XKXP/+/XnxxRcZOXIkcXFx6tBGRUUF7dq144UXXuD222+vdY6LL76YCRMmMHXqVAAeeOABrrjiCtLT08nNzeXJJ59k06ZN7Nixo0mvzW6387e//Y2cnByGDx/Oo48+Slxc3Cm8ao3WRBOAGmcEDRGANYc9JEnC5/NRVFREYWEhJSUlhIeHq2IwPDz8tG9jCCHYv38/3289wsIjJpKiwjBX6xnMtbnJSLAy+5o+jVpbsd3L5mPlSEj06xBFrNWIx2XHbisl78hh8o4dpqQwH51OR3R0FNHRMUSEhwfsROpZp15vqCWI3G43+/cfIDIygo4dA75xSlA0KgqyEhCUwaqlIgSKEMiygkAKVDSrvpZriE+lyttOrnYs+Mupriqb1JBevaohEqcjkMahyAp6nY7omJhAz1818dqg89WgXsHWhExinRRw2hH1fNu9Xh/5ublERUcTExtz0vOlxkfRKTkOh9NBRXkFtnIbPq+PiMgIoqOi6dZ3CKmdujd4faeCoihs27YNu93OoEGDGhQJ1xwIIbDb7aoYrKysJCoqSq0OVv8dIMsyt912G5s2bWL58uWn3Tpl5cqVjBw5stbxG2+8kTlz5gDw9ttvc++995KXl0d0dO2t+06dOjFlyhSmTZsGwLXXXsuqVasoKSkhMTGR888/n3/961906dLlpOupb5vX7/fz73//m6VLl3L++efz+OOPN3qgRKNtoAlAjTMCRVHw+eofbAjavNQ17BHE5/NRXFxMYWEhxcXFWCwW1YssKiqqxcVgsAJis9nofU5fnlqWw/a8SmKtRkx6iXKXH0XA3SMzGH12wxquhRAs3JzPB78eodzlRwKiw4z8dXhHrugTegHz+3zkHT3MsZyDFOQeweu0E241Ex0dQ2RkRMiEn05nQKkxuWq3Ozh48ACJiYkkJ6c0ymJQpzegyA3v4QwSIhCFqOqlDEyVBNJhqkSjfFw81lXdlGWFvLx8XG4XZosVp9OJ1xcYIgm3hhMeGYUkNe5XYSCrue7s3qZUE+vL+4WAuXZeXi6xMbFExZy8Z6++wQ+P20N5RTkVFXasKV2IiY2rUww1J0Hx53A4GDhw4GkTf3Xh8XhUMVhaWorBYGDu3LmMHj2axYsX8+uvv7JixQrat296HvLvgeriLzs7G51OR9++fdXfEUII/vnPf/LNN9/wz3/+kzFjxmh9gWcgmgDUOCM4kQAMVv7qG/aoC1mWQ8SgwWBQxWAwlqo58fl8bNq0CUVR6NevH2azmYIKD2/+dIhNR8vxy4IYq5GJ/dqR1Telwc+fnWPj8a92IQTEWY0IoNThxaDXMT2rJ71T625eF0Jgs9nIyz3GscMHcNnLsZoNWE0Gwq2BIZLqvxpsNhs5OTm0T21PfEJ8498AqSrHtpmQJF2Dkz8UReHgwYP4/X66dOmiJiG4XW5Kysqw2cpwOD1YwixEREQGzJeNpmpb39Wrm8e3ymtWK5UalUulEa9XX0d6SBCXy0VhYRFxsbFERjWs0tK9Q+JJev/Sie/QVRVDJSUltaLZmsPyoy2Jv5rIsszBgwd54oknWLp0KV6vlyuuuIJrr72WMWPGtLnev9NJUMx9+OGHPPzwwzz22GNkZWWRkpKCLMtqT+UVV1xBYWEhv/76ayuvWKMpaAJQ44ygPgEYNHdujPir6xwlJSUUFhZSVFSEJEmqGIyNjT3lC6HT6WTjxo1ERETQu3fvWg3pueVuHB4/7WPCsJoaZ2UyY9levt1RRPuY4xYYQghyyz1k9U3h7pEnTgkI3t9ut1NYWEhhYSG2shIiw0xEhJmwmgzkHj1M7rGjpKd3Ijq68dOQeoMRuRlsaZpyPtkvc+DAASSdROeMznXm+uoNRtxOZ6A3sNyGvdKOxWIhKjqKmOiYwJBII6udst9Xq7+yYVvf1Y8rVFbaOZaXT3x8POEREerjTvRLOzrcQq9OJ96+7DbgQsxhxwVi9Wi2oqIigBC/vabEhymKwtatW3E6nW1O/AVRFIV//OMffPXVV8yaNYuNGzfy1VdfsX37do4cOfKHSdAI/v6sXsX78ssvuf7665k9ezYTJ06sc5vXZrNx4YUXct999/HXv/71dC9b4xTRBKDGGYEQAq/XG/J1sPIHgX6/5qjaKYqCzWajoKCAwirj4cTERJKSkoiPj2+0GLTZbGzatInU1FS6devW7JXFBxdsZ9PRClKiQhvq88rdDO8Sxz/HndXoczqdTlUMlpeXA5CcGEdibDTC78FlL8ftrEQ0ZMJVVMWNNbK37gSnQ9fAXj2f18eBAwcwmUykd0qv93tXs5oo+2UqKyuxlduoqKjAoDcQFR1FdHQ0ERERJ/0eNnW7uyY2m42cwzl06tyZqMjQacugaFRqiEZZUQi3mDCdwAYoKi6ZtJ4D6r1dCKH67RUWFob47SUmJjZoeCMo/lwuFwMGDGiz4u+xxx5j3rx5rFixgm7duqm3HTt27A+3DXzs2DHWrl3LpEmTqKio4M9//jO9evVixowZVFRUkJOTwyeffEJERAR/+9vfSExMRJZlHnzwQfR6PTNnzmztl6DRSDQbGI0zjrqGPZpLWOl0OuLi4oiLi+Oss86ivLycgoICdu3ahc/nU8VgQkLCSa0l8vPz2bFjB926dVMHJpqb7kkRZOeUowiBruo9CAxeQNeE+rcA60IIwe4CB1tzKzDpzcRJZiwWC6mpqdhsNrbvPURERARJSSl0zOiNAQW3swKXvRyXvQKPs5Kaf0/qjc1b/TPoDYFUkpPg8XjYv/8AERHhdOzYsd7PR129jnqDnpjYGGJiYxBCUFlZSUV5BYcPH0YIQXRUdK2JWvV8zST+SktLOXr0KOkZnYiOjKwleHU6CR16aEIQRnxqpxPeLkmSmtHcrVu3Wn57wan6+voGFUVhy5YtuN3uNiv+hBA8/fTTfPrpp6xcuTJE/AF/OPEH8M0333Dfffdx0UUXkZCQgNFoxOVysXbtWt59913279/PkSNHiImJYePGjXzwwQeYzWauuuoqZs+eTVlZ2R962/xMRKsAapwRBCuATen3a67nr6yspLCwkIKCAtxuNwkJCaoYNFbz2hNCcOjQIQ4ePEifPn1a1EriaJmL++dvp8juJaoqhq7C7SclysxLV/YmOaphVhs+WeGlH/bz3a5iPH4Zv89PmAHuvbgbV/QLXAxrTlTXHKIRioLLUSUIK8tx28vxelwN7tU7GQ2t/rlcLvbv309cbBypqan1bt8KIdDp9Q2rZFYtwOlyUm4rD5mojYmOISo6CoPBgF5vPJ7c0kSKi4vJzc2lc0ZnomNiT/l81bGER9G133lNfrzX6z1h3yCgir+BAweG/Fy0FYQQTJ8+nTfffJMVK1bQu3fvZj3/qlWrmDlzJtnZ2eTl5dVK9JgyZUqtDN/Ro0ezdOnSE573tddeY+bMmeTn59O3b19effVVhgwZ0qxrv+GGG4iJiWH27Nn861//4pNPPmH//v1MnDiRSZMmMWHCBJ544gm2b9/OggUL1C3j3bt306NHj2Zdi0bLowlAjTMGt9vdKuKvJkIIHA6HKgYdDgdxcXGqGNy/fz8lJSX079//tNgj7Myv5N01OezMtwPQu10UNw1Po1tSwyuACzfl8cqKg1iMEpLPDZIOtzBgNup547pz6BQf6p8Y7BkL9k3q9Xq1KlS9b1L2+3A7KtUqoctejtftaNLrbEjvX3BSOSkpieSk5BP27un0RpRTEFcetyewTVxegdPpJDwigsjICGJiYprscRf8THXu3BlreHiDt7sbSodu5xCT1DzVrZp9gwHrID2SJDFo0KBqBtttByEEL730Ei+99BI//PAD/fr1a/bnWLJkCb/88gsDBw5k4sSJdQrAgoIC3n33XfWY2Ww+YfVs7ty5TJ48mTfffJOhQ4cya9YsPv/8c3bv3t0sEW1BIffZZ5/x3nvv8c4775Camsq6devw+XwMHz5c/b172223UVpaykcffVSruqtNAp9ZaAJQ44xg7dq1rF+/nrFjx5KYmNimQsmDPXP5+flUVlai1+vp1KkTqampzZ5PWh9CCEocPnQSxIU3fsvt9o83szO/knDJh95gCFy8haCg0stNw9O48dz6t7CDxrvBvkEhhFodjY+Pr7VVLvv9uB0VgWphZTluRwUel/3Er4+TV/8qyis4dPhQgyeVJZ2u4dW/k+Dz+qi02ykrK23aEImA/IJ8iouK6dKlC2HWsGbbTg5iMJrpPmhEi/zsyLJMdnY2LpcLvV6Px+NpdN9gSyOEYPbs2cyYMYNvv/2WwYMHt/hz1pXpO2XKFGw2G1988UWDzzN06FAGDx7M7NmzgcDPXMeOHbnrrrt4+OGHm229Qgj+9Kc/ER0dXWt9e/bs4a233uLdd9/lt99+o2vXrprgO8PRegA1zgjKysp47733uO+++xg+fDhZWVmMHz+elJSGW6a0FFarleTkZHJzc4mNjSUhIYHi4mIOHDhAVFSUajzdkhURSZJIiGh6r1VxpRvF78NoNWK2WAJ6pep9rXCfWITodDri4+OJj49X+yYLCwvZs2cPHo+n1la53mAgPDqO8OjjCQInE4WGk1T/SktLOXrkKGnpaepW5AnXfIrVv5oYzWbijEbi4mJDhkj27tt78iESAXl5eZSUltC1W1csFktgyKmZxGmQuHZpLSb+tmzZghCC4cOHYzQaG9032NIIIXj77bd59tlnWbJkyWkRfydi5cqVqsvAn/70J5555hni4+v+o8Xr9ZKdnc0jjzyiHtPpdIwaNYo1a9Y0eQ01xVvQ3uXdd9/luuuuY+7cuVxzzTUA/Pbbb0ybNo3CwkJ+/vlnunbtGmIHo3FmoglAjTOCyy67jDFjxnD48GHmz5/PvHnzePDBBxk6dCiZmZlkZmbSoUOHVhGD5eXlbNq0iaSkJHr06IFOp1PzSYNVsX379lUNUAR65tpShmZhYSEJOgd5GDCbzWqxKpi725itZEmSiI6O5rBdYp/egmLyYVB8OA8dYvv27epWec2qUL2i0BnYPvY4KgKDJi57rUGToNDI6JzR8C33ZupLDKLX6ZGrzlnXEEl5eXndQyQ6HUePHaWivIJuXbthrooF1OuNtYZTTgVJpyMuJa3ZzhdElmU2b96M3+9nwIABas9fzZze4DbxgQMHWsRv8EQIIZgzZw5PPvkkX3/9NcOGDWvR5zsZY8aMYeLEiWRkZLB//34effRRLrvsMtasWVOnoCouLkaWZZKTk0OOJycns2vXriatISjegm0cXbp0Ubdz4+LiGDZsGKtXr1YF4JAhQ3j88cdJT08nNTVVE3+/E7QtYI0zEiEEx44dY8GCBcyfP59ffvmFAQMGkJWVRWZmJp06dTotYrCwsJBt27bRpUsX0tLS6n3OmgMUYWFhqhiMjIxstSrm0aNH2bNnD5aUrjy7Mg+by0eE2YCiCFw+hbNSInj56t6EGRv2y94nK8xYto8fdhXhkwO/WixGHTcNTyOrV5zaM1heXk50dLQ6Vd3QjGZFlvE47bgcgZ7C/Xt2knvkMJ07ZzT4HM29tSpJEqKeRJAQBLVi2fQGPUIRdO7SOWT9TUkSORGxyR1o37VPs50Paou/hngFyrJMaWmpasAebBc4Fb/BEyGE4KOPPuL+++/nyy+/rDNqrSWpawu4JgcOHKBLly58//33XHzxxbVuz83NpX379qxevTpEvD700EP8+OOPjTZhDlb+tm/fzlVXXYXNZiMjI4M77riDiRMnYrVa+e233/jTn/7E//73P66++uo6H69x5qMJQI0zHiEE+fn5fPHFF8yfP58ff/yR3r17k5mZSVZWVov47wkhyMnJYf/+/fTu3btRjdh+v5+SkhIKCgooLi7GZDKpYjA6Ovq0/HINZhIfOXKEfv36ERsby5ZjFXzw6xG251Zi0Etc1C2BG8/t2Kit5UWb83n++32EGfVYTYHKTrnLjyRJvHJ1bzWZJBjJVVhYSGlpqZrRHKyOnuw9EEKwa9cuioqK6N+/P0Y9uO2BLWS3vQK3s7LeLWN9A61kGoreYEL2e09+x2oIIThw4AAupwujyYjb5cYabiU6OprY2DiMJ/Dxawpd+5+Pxdp8A0lNEX81qe43WFRUhMvlIjY2Vm0XONX+WSEEn3/+OVOnTmX+/PmMHj36lM7XFBoiAAESExN55plnuO2222rd5vV6sVqtzJs3L+Q8N954IzabjUWLFjV6XQ6Hg8svv5xBgwZxxRVXMGvWLHJzc7nyyiu5/fbbiYqK4uWXX+arr77irbfealB2sMaZhyYANX5XCCEoKSlh0aJFzJs3j+XLl9O9e3fGjx/PhAkT6Nmz5ykLLEVR2LNnDwUFBfTr16/OUPaGEqyIFBQUhEzTBiPpWmJ7TFEUdu7cSWlpKf3796+1He30yhj0EqY6UjNOxp2fbmHzsQoSq4lGIQRFdh/XDmrPXSMyaj2mZkaz2Ww+oSAOxotVVlYyYMCAensrvW4nLnsFbkfgP5e9Aln2I5qxsiYhgSQ1yupGURQOHzqM1+dVo+l8Xh/lFeWUl5fjcDgxm0xNTiKpSURMAp16NV/PmyzLaqxh//79m61qF+wbDFaIIyMj1QpxU/oGFy5cyG233cbcuXMZO3Zss6yxsTREAB49epS0tDS++OILxo8fX+d9hg4dypAhQ3j11VeBwGcoLS2NqVOnNngIpOa27c0338xTTz1Fhw4dUBSFO++8k/Xr1zNx4kTuuusuSkpKuOOOO7j55puZNGmSVvn7HaIJQI3fLcG82y+//JIFCxawbNky0tLSyMzMZMKECfTp06fRAsvv96sJB/3792/WwY7gNG1QDAohVCEUFxfXLGIw2LDvdrvp379/s08p/2XOBnJKXcSFh/q/FVR6GN8nhYdHd6vnkcfXF+xLKi4urhXLJ4Rg8+bNeL3eJpkM+7wePM7KKmFYidtRgdftqNVX2FAaG3OnKAoHDxxEURQ6d+6M3hC6tS5JOvx+H5UVtZNIYqJjCI9ovBBKP3sQkbHN40XZUuKvJifzGzzZz8LXX3/NX//6Vz766KOTVt+aG7vdzr59+wDo378/L774IiNHjlQN5p966ikmTZpESkoK+/fv56GHHqKyspKtW7eqfbEXX3wxEyZMYOrUqUDABubGG2/krbfeYsiQIcyaNYvPPvuMXbt21eoNrIughUteXh7Tp0/H5XKxd+9evv76a8LDAz2+sixz7733sm7dOkaPHs2TTz7JE088wZo1a/j2229b7Hut0XpoAlDjD0NFRQVff/01CxYsYOnSpSQlJalicMCAASe9qLjdbjZt2oTRaOScc85pUZPboHgNDpH4/f6QSLqmNGB7vV42btyIXq+nb9++LbL+F77fz4JNeSREGNVkEp+sYHP6efCSrmT2bXi2qqIobNyfx/c78iirsJMRIegWAxazmYEDBzabtUiwrzCQahLYPvY4Khu0TVwzRu7Ez6Ow/8B+JOlEucSh28nVh0jKy8tDh0iiok76mTWHRdC1//nNUrmRZZmNGzcihGhR8VfX8zamb3Dp0qVMnjyZd999l6uuuuq0rLE6K1eurLPX8MYbb+SNN94gKyuLjRs3YrPZSE1N5dJLL+Xpp58OEXKdOnViypQpTJs2TT02e/Zs1Qi6X79+vPLKKwwdOvSk6wmKP5vNRrdu3ejduzf5+fkcOXKE66+/nhdffFEVgQB33HEHa9asYfHixaSmprJ06VJGjhzZJqx8NJoXTQBq/CFxOBwsWbKE+fPn88033xAbG8v48ePJzMxk6NChtQRWZWUlGzduJD4+np49e55WH0IhBBUVFapJcHVrlcTExAZdiJ1OJxs2bCA6OppevXq12PoPlzq5e+42iu0eLEY9ihB4/IIeyeHMvqYP4eaGi4YPfj3Cf37JweNXAIEiy/SOl5jc04Ds9RAfH6++B80tZoUQeN1OtUrodlTidlbi87jU+zSm+if7ZfYf2I9erycjI6P+919Q/3ZvHUMkNZNIapLauRdx7U59+jco/gD69evXatWgmn2DTqeTuLg4tm/fzvnnn8/Bgwe59tpreeutt/jzn//8h96yVBRFjcl0uVysXLmSJUuW8Morr1BZWckLL7zAsmXLGDJkCP/6179CRGD1ZI/g1q+2Bfz7QxOAGn94XC4Xy5YtY/78+Xz99ddYLBbGjx9PVlYWw4cP54svvuDnn3/m7rvvJiMjo1V/CQohsNvtamXQ4XCECKG6tkTLy8vZuHEjqampLTIQU5O9hQ4+/PUIvx6yYdBL/KlHApOHNm6YZHtuJXd8sgUFQbhRh8ftQZZ0+NFx14gMxveMUd8Du92uDg8kJia2qPm27PepVUK3oxKPowK3y35Czz6/38/+ffsxmUx0yqh/Or2x28k1k0iCQyTR0dGYzWb0BiM9Bo1Ed4p2HdXFX//+/duU/YfD4aCgoIAbb7yRTZs2AZCVlcW0adPo3bv3H1Kw7Nq1C51OR/fu3YFAj+2UKVNYuXIlV155JS+//DIQ+KPw+eefZ/HixQwbNoynnnqKqKio1ly6xmlGE4AaGtXwer18//33zJ8/ny+//BK3243L5eJvf/sbM2bMaHPZpsFIusLCQiorK1UhlJSUhNlspri4mC1bttClSxfS09NP69qUql8tuiZchF9dcYCP1h0j2qLD4/FiMBgwGY2UuXx0T4rgvRv7q/d1uVzqe1BeXq6abwdNh1saIQRel0MVhdWrhT6vj33792G1Wk9oEwSN206uSfUhkmASScduvTir39BTshny+/1s3LgRnU5Hv3792pT4q87q1avJyspiwoQJ2O12vv32W1JSUvjwww8ZPnx4ay/vtPLII4/gcDh45ZVXUBQFp9PJ7Nmz+eCDD4iKigoxj/Z6vbzwwgvMnTuXwYMH88Ybb2i9fn8gNAGooVEHiqLw4IMP8s477zBixAh+++03fD4fY8eOJSsrq032xNQUQhaLBbfbTffu3UlLa34T4JZk+rd7WbApF6tOwWg0qrYoFS4/SZFmFtxW91Rr0Hw7ODwQHh5OYmIiycnJDbKXaU7slRX8tuYXrBYjHVNT8Dgr8TjtdfYWNrb6dyJkv0ylvRJrSlds5ZUYjUa1f7Qxk+Vnivhbt24dmZmZPPPMM9x5553qluf333/P0KFDmyUr90zi7bff5uOPP2blypXqMYfDwYcffsgLL7zAkCFDmDNnjir0fD4f06dPZ/jw4XX6EGr8ftEEoIZGHTzwwAMsWrSIxYsX061bN2RZ5qeffmL+/PksXLgQu93OZZddRlZWFqNGjWpTwfdCCPbu3cuRI0cIDw/HbrerUVxBS422zse/7OXFH48QZTFiMQeqrooQlDn9jO+TzP+7rPtJz+H3+1V7mSP5xWy36XHqrXRJieWK/mnEWJsenXcyHA4H2dnZajpMUHgKIfB5XGqVMLCNXInP625W4+fohFQ69uiLoijqAEVRURGKoqjTtAkJCfWKujNF/G3cuJFx48bx+OOPc9999/0ht3xr4vP5GDBgABMnTuSpp55Sj7tcLt5//33efvttunXrxnvvvdfm/ojVOL1oAlBDow4OHjxIZGQkCQkJtW6TZZm1a9eqYrC4uJjRo0eTlZXFpZde2qoxb4qisGvXLoqLi+nfvz+RkZFqCklBQYFaFWuM6fLpJjc3l83bdvJBTgQHSr0YdBKSBF6/Qly4ideu7UPnhIaL2L2FDu79fCsFFR4QAlkIoozw4HlxnNujfbNZ7ASprKxkw4YNpKam0rVr1wa9v4os43HZA4Iw+P9OOz6vu0lr6HLOcMIiQ/0pqw9QFBYW4na7Q6L5gv2jfr+fDRs2YDAY6Nu3b5sVf1u3buXyyy/nwQcf5B//+Eezfo5XrVrFzJkzyc7OJi8vL8TLz+fz8dhjj7F48WIOHDhAdHQ0o0aNYvr06aSmptZ7zmnTpoUIMoAePXo0Oc6tLoITvy+88AI//PADjzzyCBdccIF6u8vl4qOPPuK///0vycnJfPTRR2fEH4QaLYMmADU0TgFFUcjOzmbevHksXLiQo0ePcskll5CZmcnll19+WpuqZVlm69atOJ1OBgwYUOcwRLAqFkwhMZvNJCcnk5SURFRUVKuLwcOHD7N//3769u2LLiyS99YeYdnOIrx+wdBOMUwZltaobGIhBJPf28jOfDvhJj16nYSiCCo9ftpF6Hiwb2C6ODhVfapxZMGBm7S0NDp37tzk8wSR/T7cTjueqophwK6m/pQTAGtULJ37nHvScwf7R4uKiqioqCA6Opr4+HgKCgowm81tWvzt2LGDyy67jKlTp/LEE080++d2yZIl/PLLLwwcOJCJEyeGCMDy8nKuvPJKbrnlFvr27UtZWRn33HMPsiyzfv36es85bdo05s2bx/fff68eMxgMdf6ReaocOHCAq666ioyMDJ599lm6dTvuv+nxePjggw948cUXmTVrFpdeemmzP7/GmYEmADU0mglFUdiyZYsqBvfv38/FF1/M+PHjGTduHDExMS0msLxeL5s2bUKSJPr169egYZXqpstFRUUYDIaQFJLTKQaD0XRHjx6lf//+tdJVmmpBsbfQzl/mbMSgkzAZjlf5fLKC1y946899yIiS1KqYy+UiLi6O5ORkEhISGmU0XVZWxqZNm+jcuXOLD9z4PO5ApbCGOFQUmY49+hGd0K5R53O73eTn53Pw4EH8fn9Ilbg1s6rrYvfu3Vx22WXcfPPNPPPMMy2+toakeaxbt44hQ4Zw+PDhevttp02bxhdffKFOKzcHdf1cBI9t2bKFkSNHctFFF/Hwww8zZMgQ9T5er5f9+/fTs2fPZluLxpmHJgA1NFoAIQQ7d+5k3rx5LFiwgB07dnDRRReRlZXFuHHjSEhIaLYLl8vlYsOGDURERNC7d+8mVW2q94oVFhYiSZI6PBEbG9uivofVc30HDBjQrFvoG4+Uc9vHm7EY9Rh0x99vWRE4vTIvX9Wb4V3i1OM1p6pjYmJUIXQie5mSkhI2b95M9+7d6dChQ7OtvzEEvQtNFmujP1s+n48NGzZgMpno1atXiPFyU4dIWoJ9+/Zx2WWXcd111/Hcc8+dlrU0RAB+//33XHrppdhstnqr/tOmTWPmzJlER0djsVgYNmwYzz77bJMGtOx2O+Xl5bRv317d9q1OMPZt27ZtTJo0iYyMDP70pz/x4IMP1isYNf54aAJQQ6OFEUKwb98+VQxu2rSJ8847j6ysLMaPH09ycnKTfwFXVFSwceNGkpOTQ4YNTgVFUUJSSGRZPuUUkhM9V0NyfZuKw+Nn/Bu/UenxE1HNhNrh8WM26ll0+2Bi6xkGcbvd6ntgs9nUQRqXIZK1R5x4ZYWhnWJpb/awbds2evbsSbt2jau8tQWqi7++ffuGiImmDpG0BIcOHWLMmDFkZWUxa9as0yZETyYA3W435513HmeddRYfffRRvedZsmQJdrudHj16kJeXx1NPPcWxY8fYtm0bkZGRjVrTbbfdxn/+8x927dpFt27dTigCjx49yiuvvMKaNWsoKirirrvu4txzz2XgwIGNek6N3x+aANTQOI0IITh06BDz589nwYIF/Pbbb5x77rlkZmaSmZlJ+/btGyziSkpK2LJlCxkZGaSnp7fIX/HBwYGgEPJ6vWq/XEJCwin1y/n9frZs2dLkXN+G8v7aI7z240FkAUa9hF8WSBLcNDyN2y/o1KBzBLNp56zJYf5uF4qQqlIWoE+MzL+zetE+teExd20Fn89Hdna22vN3IlHV0CGSluDo0aOMHj2a0aNH8/rrr5/WKuSJBKDP52PSpEkcPXqUlStXNqrn12azkZ6ezosvvsjNN9/cqDUdOHCAu+++m3Xr1rFixQrOPvvsOkVg8JjH40GWZV544QUcDgdhYWHcd999mvHzHxxNAGpotBJCCI4ePcqCBQtYsGCB2nSelZVFZmbmCUVdXl4eO3bs4Oyzzz5tVadgCklBQYHaL9fUODafzxdiM9KS5rNCCL7aWsDH645xtMxFu2gL1w5qz4R+KY0yqd58tJy/fbgZRQhMOpAVBb8sUJCY0i+aycM7ERsbe8ZspwXFn8Vi4Zxzzmm0qKpriCT4WbBarc22zry8PMaMGcOFF17I22+/fdoHU+oTgD6fj6uvvpoDBw6wfPly4uPjG33uwYMHM2rUKJ599tkGPya4ZZuXl8e9997Ljz/+yIoVK+jZs2edIrAuvF5viwp2jTMDTQBqaLQBhBDk5+ezcOFC5s+fz6pVq+jTpw+ZmZlkZWWpdiKKorB27Vo8Hg/nnHNOky46zUX1SDq73a5Wg5KSkk54cXG73WzYsAGr1UqfPn1O6wVdEaJJySQAM77dy9wNuYQZdChCIMt+DAYDLq9CerSee3sHfPyC2+VxcXFtdor2VMVfTdxut5rPW1paqhpwn+oQSUFBAZdddhmDBw9mzpw5rfJ+1iUAg+Jv7969rFixgsTExEaf1263k5aWxrRp07j77rsb9JjqAm/mzJmUlpYyY8YMkpOT+eabbxgwYECDevq0vj8N0ASghkabQwhBcXExixYtYv78+SxfvpwePXowbtw4Nm3axJYtW1i7di1xcXEnP9lpwuVyqZXBioqKeocnHA4HGzZsIC4ujp49e7bqQEFjeXTRTpZsL8RiAFlWMBgM6CQJl08mOcrMN38fGtI76fP5mm27vDnxer1s2LCBsLAw+vTp0+zfA5/Pp06Xn8oQSXFxMZdffjm9evXio48+Oq3vn91uZ9++fUAg//jFF19k5MiRxMXF0a5dO6688ko2bNjA119/TXJysvq4uLg49Y+fiy++mAkTJjB16lQgYC5/xRVXkJ6eTm5uLk8++SSbNm1ix44djRaQN9xwA5s2beIf//gHOTk5LF26lC1btrBs2TKGDh2qCTyNBqEJQA2NNowQApvNxrx583jiiScoKCggPT2dq6++mgkTJtC7d+82J6KC1aCCggJ1KjIpKQmr1crOnTtp164d3bp1O+MuUJ+sO8pzy/ahlwRmowFJkhBC4PIrjO2VzNPjz1LvK4SgsrJSFYNOpzNkuzwoEnbl2/ntUBlmo46R3RNIimzZZAav10t2drZafW3pz05Th0hKS0sZN24cGRkZfPbZZ6c9g3vlypWMHDmy1vEbb7yRadOmkZGRUefjVqxYwYgRIwDo1KkTU6ZMYdq0aQBce+21rFq1ipKSEhITEzn//PP517/+RZcuXRq1tp07d3L55ZczZ84cLrroIiAwIHP//ffz3XffsWzZMs4991xNBGqcFE0Aami0ccrKysjMzMTn8/Hxxx+zZs0a5s+fz9KlS0lJSVG3iQcMGNDmxGBweOLo0aNUVFRgMpno2LGjGkl3plyghBBs2r6bB5fmUeLVoZcCW4N+RRBu0vPu5H50S6rfvsbhcKjDExUVFURERjH3gI4VB+wEfwEb9Tr+cWlXrhpQf5rEqRAUf+Hh4a3yh0NDh0hsNhtXXHEF7dq1Y8GCBVqvWg02btzI0KFDWbt2LQMGDFCPb9myhVGjRiHLMh9//DGjR49uxVVqnAloAlBDo42zYsUKXnvtNd5///2Q5nq73c6SJUuYP38+ixcvJjY2lvHjx5OVlcWQIUPaTP9ZYWEh27Zto2vXrhiNRnVr0GKxqCkkbc1suDpCCHbv3k1RUREduvXm3XUFfL+rGFlRGJQew98vzKBXasNtPNxuN//7aR9vri0CBHpJQtKBXwG9TsenNw+kR3Lzxgm2tviri+pDJEePHuX5559nxIgRrFixgpSUFBYtWnRC78U/AvVV8YYPH07v3r154YUXVAsZt9tNVlYWR44cYfjw4bzzzjune7kaZxiaANTQ+B3gcrn49ttvWbBgAV999RVWq5Xx48eTmZnJ8OHDW63/LDc3l507d9K7d++QXilZlikuLlYFgNFoJCkpieTkZKKjo9uMGBRCsGPHDsrKyhg4cKDqU+hXFBQBJn3ThNSVb69jT6EDs0GHEAIhFBRFICMxrnsE/xjdvdmi+bxeL+vXr1eNwtuC+KtJYWEh77zzDq+++ip2u51evXoxceJEsrKy6NevX5v5PJxOqg985OfnY7fbSU5OJjIykldffZUPP/yQsWPH8sgjj2A0GsnPz+f6669n+vTpDB48uJVXr3EmoAlADY3fGW63mx9++IEFCxawaNEi9Ho948aNY8KECVxwwQWnrZ8qmOvbr1+/Ew6sKIoSEkknSZIqBlszeSJoUm232+vNVm4qI19aTanTW0tAevwy53Uwc3W6B71eHxLN15T3wePxkJ2dTWRkJL169WqT4g/A6XRy5ZVXIoTg448/5qeffuKLL75g8eLFbN26tcWj9doa1St/06ZN4/vvv2fTpk2MHj2aIUOG8I9//INHHnmE77//HpfLxbBhw1i+fDlnnXUW33zzDUCDLWE0/rhoAlBD43eMz+fjxx9/ZN68eXzxxRf4fD7GjRtHVlYWI0aMwGxu/qGDk+X6nghFUSgrK1OHJ4QQISkkp+uCJssyW7ZswePxtIhJ9d2fbeXHvSUYdZJ6oVeEwK8IHhjVlesHp1JWVkZBQQFFRUXq+5CYmFhvGssxm5vsHBtWk57hnePQC/8ZIf7cbjfXXHMNDoeDpUuXhpgT/9H96mbMmMFzzz3Hhx9+SJcuXXjggQf45Zdf2LBhAx07duS7775jyZIllJSU0KFDB9VPMJgCoqFxIjQBqKHxB8Hv9/Pzzz+rYtBut3P55ZeTlZXFxRdf3CwxbMEM5JKSEgYMGEB4ePgpnau8vFy1l/H7/SG2Ki11gZNlmU2bNiHLMv3792+Riunmo+Xc9MEm/LJApwtMEwMkRpqZd8sgosOOP2ddaSzBieKEhAT0BgPTv93LJ+tzUYRAAiLMeqacJXF+51h69erVZrdQPR4P119/PcXFxSxbtoyYmJjWXlKbIGgFdc0113DnnXcyadIkli9fzvjx45k9ezZTpkwJqfBV/7ff728zlkMabRtNAGpo/AGRZZm1a9eqYrC4uJgxY8aQmZnJ6NGjmyTcWjLXN2irEhSDbrc7RAw2l0jz+/1s3LgRSZJaPKFkzYFSXvrhAHuLHEgSnNc5jocu7UrH2Prft2AaS1AMOhwO1peH8+EONwBBmacIMOrhmzvPpX1M8+YrNxc+n4/JkyeTk5PDDz/80CK+lqtWrWLmzJlkZ2eTl5dXy9BZCMGTTz7JO++8g81m47zzzuONN96gW7duJzzva6+9xsyZM8nPz6dv3768+uqrDBkypFnXbrfbueCCC/joo484cuQIV155Jc899xx33HEHbreb999/nz59+jBs2LBmfV6NPw6aANTQ+IOjKArr169n3rx5LFy4kNzcXC655BIyMzO57LLLGpQX6vf72bx5M36/n/79+7fotp0QAofDoYpBh8NRp8deY/H5fGzYsAGj0Ujfvn1PyxaaEIIypw+TQUeEufFi0+l0kvX2Bo5V+NBJgqAEFAJ0Ook7LuzEHRd2at5FNwN+v5+bbrqJ3bt3s3z58iYlaTSEJUuWqBGLEydOrCUAZ8yYwbPPPst7771HRkYGjz/+OFu3bmXHjh319nzOnTuXyZMn8+abbzJ06FBmzZrF559/zu7du0lKSjql9Vbv/SsuLmbs2LH07t2bRYsW8dhjj3HvvfcCsGfPHu666y7uuOOOOjOKNTQagiYANTQ0VBRFYfPmzcyfP58FCxZw4MABRo0axfjx4xk7diwxMTG1thO9Xi+bNm1Cr9fTt2/f07795HQ6KSwspKCggMrKSmJjY1Ux2NDBDY/HExJP11b75epi4LM/4vEr6KTjW8kQEIMXdw7n6fE9iYiIaDPbwLIsc9ttt7Fp0yZWrFgRMh3ektSMdBNCkJqayv33388DDzwAQHl5OcnJycyZM4drr722zvMMHTqUwYMHM3v2bCDwM9OxY0fuuusuHn744Uavq7roKykpwWAwYDKZCAsLY968eVx77bWMHTuWRYsWAYHK4LXXXovT6eSHH35oM99XjTMPTQBqaGjUSdACZd68eSxYsICdO3cyYsQIsrKyGDduHPHx8Rw8eJB58+YxevRoevfu3eqN5263WxWD5eXlREVFqV6D9W1Ju91usrOziYqKatPDEvVx7X+z2Z5bEaj6SUCVEBTADb2sDI62Yzab1Yni1rTZkWWZu+66i9WrV7Ny5UpSU1vG9LouagrAAwcO0KVLFzZu3Ei/fv3U+1100UX069ePl19+udY5vF4vVquVefPmhVTebrzxRmw2myrSmsLHH3/M66+/jt1ux+128+9//5tRo0bxv//9j//7v/9j/PjxyLKM0+kkPz+fjRs3YjKZtIEPjSZzZv2m09DQOG1IkkSvXr3UzNJt27YxYsQI/ve//9GlSxdGjhzJ8OHD+e233+jTp0+buAhZLBbS0tIYPHgwF1xwAampqZSUlPDLL7+wdu1aDh48iMPhUO/vcrlYv349sbGxbdYj72TcOKQdQgRqfoLANLEkScRajdx+2QBGjBhB9+7d8Xq9bNy4kVWrVqmDOoqinLZ1KorCfffdx08//cT3339/WsVfXeTn5wPUqkAmJyert9WkuLgYWZYb9ZiGMHfuXG655Rauv/565s6dS69evbjxxhs5cuQI9957L99//z0pKSl06NCBsWPHkp2djclkwu/3t4mfO40zE21USON3S0s1gP8RkSSJ7t278+ijj/LII4/w9ddfc9111xEZGcm3337LZZddRmZmJuPHj6d9+/ZtYlvKbDbToUMHOnTogM/nUyPIDhw4QFhYGLGxsRQUFJCcnMxZZ53VJtbcWFwuF5HlB7htYBSf7XJR5vQBcHa7SJ6+4ixiqqaJg9W/6jY727dvR5blEJudlhITiqLw0EMP8d1337Fy5UrS0tJa5HnORFwuFx988AFPPvkkd9xxB9u3b2ft2rXcfffd9OrVC1mW+dOf/lTLw1OWZW3aV+OUOPP+3NXQaCAOh4O+ffvy2muv1Xn7c889xyuvvMKbb77Jr7/+Snh4OKNHj8btdp/mlZ5Z/Pzzz9xwww088cQT5ObmcvDgQSZNmsRXX33F2WefzcUXX8zLL7/MoUOHaCsdJkajkdTUVPr168dFF11Eamoqubm5+P1+SkpK2Lt3L+Xl5W1mvQ3B5XKRnZ1NfHw8Uy8fwA/3Dmf+rYNZMvVcPr15IN2Sak9y63Q64uPj6dmzJxdccAEDBgzAbDazd+9eVq5cyebNm8nNzcXn8zXbOhVF4bHHHuPLL7/k+++/JyMjo9nOfSqkpKQAUFBQEHK8oKBAva0mQfuhxjzmZMiyzP79+7nkkkvIy8tjxIgR/OUvf+Ff//oXiqLw/PPPk5OTo4q/4GdUq/xpnCpaD6DGH4LmagDXCITOb9iwgSlTpoQcF0KoldYFCxawatUqzjnnHDIzM8nMzKRr165tospWXl7Oxo0bSU9PJy0tLSSFpHr6RmxsbJtYb10Et64TEhKapXoZnKwO2svY7XZ1mCYpKanJhuFCCP75z3/y/vvvs2LFCs4666xTWuepUN/vgAceeID7778fgIqKCpKSkk46BDJkyBBeffVVICBw09LSmDp1apOGQACuvfZazGYzy5Yt4y9/+QvTp09Hp9Nhs9m45ppryMrK4o477mjSuTU06kMTgBp/CJqjAVyj4QSNbL/44gvmz5+vxlRlZmaSlZXValuuZWVlbNq0ic6dO9eKFwtuj1ZP3wgKoLi4uDbTHxgUf4mJifTo0aNF3keXy6WKweAwTfC9sFqtDTqHEILp06fz1ltvsXz5cnr37t3s6zwZdrudffv2AdC/f39efPFFRo4cSVxcHGlpacyYMYPp06eH2MBs2bIlxAbm4osvZsKECUydOhUI9OvdeOONvPXWWwwZMoRZs2bx2WefsWvXrpNONAcNm2VZRpZl1bLov//9L9OmTSM9PZ2VK1diMBhQFIWpU6fy008/sXLlSuLj41vwndL4I6I1EGj8IWlKA7hGw5EkicTERG655Rb+9re/UVZWxpdffsn8+fOZOXMmGRkZZGZmMmHChNM2eVtSUsLmzZvp3r07HTp0qHV7cHs0Pj4eIQQ2m42CggJ27Nhx2nrlTobT6SQ7O7tFxR9AWFgY6enppKen4/F41P7Jffv2ER4erorB+uxlhBC89NJLvP76660m/gDWr1/PyJEj1a//7//+DwhM7c6ZM4eHHnoIh8PBrbfeis1m4/zzz2fp0qUh9kH79++nuLhY/fqaa66hqKiIJ554gvz8fPr168fSpUsbLP5+/vlnZs+ezZEjRxg1ahSXX345N998M3v27GHx4sWMGTOGs88+m0OHDrFu3TrWrFlDfHy8lu2r0exoFUCNPwQ1K4CrV6/mvPPOIzc3l3bt2qn3u/rqq5Ekiblz57bSSn//lJeX8/XXX7NgwQKWLl1Ku3bt1Mpg//79W+QiV1RUxNatW+nZs2fI97shCCGoqKhQ7WW8Xm9ICsnpasQPir+kpCS6d+/eKhVUn89HcXExRUVFFBcXYzKZVGEc9IgUQjB79mxmzJjBsmXLGDRo0GlfZ1slOzubESNGMH78eGJiYli+fDkJCQnceeedXHPNNXzyyScsW7aMkpISevfuze233056erpm9aLRImgCUOMPgbYF3Dax2+0sXryYBQsWsHjxYuLi4hg/fjxZWVkMHjy4WS56+fn5bN++nd69e5+y6XD1KLaCggJcLhdxcXEkJyeTmJjYIrnBEBB/69evJzk5udXEX01kWaa0tFTtn3zzzTfR6/VER0ezcOFCvv32W84999zWXmarEzR6Li8vZ+7cuRw6dIh///vfQOD30DPPPMPu3bt5/vnn64x108SfRkuh1ZM1/pBkZGSQkpLCDz/8oB6rqKjg119/1bI1TyMRERFcffXVfPrpp+Tn5zNr1izKysqYNGkSPXv25P777+enn37C7/c36fy5ubns2LGDc845p1kSJyRJIjIyki5dujB8+HDOPfdcYmJiyMnJ4ccffyQ7O5ujR4/i8XhO+bmCOBwO1q9fT0pKSpsRfxCYQk1MTKRXr15ceOGFTJkyhWPHjvH+++8jyzKvvvoq8+bNw263t/ZSWxVJkiguLqZTp0489dRTIRXjzp07M23aNGw2GwsWLKjz8Zr402gpNAGo8bvFbrezadMmNm3aBMDBgwfZtGkTOTk5SJLEvffeyzPPPMOXX37J1q1bmTx5MqmpqVq2ZithtVrJysrigw8+IC8vj7feeguPx8P1119P9+7dufvuu1mxYkWDLUqOHDnCrl276NevX4tlzYaHh5ORkcG5557LeeedR0JCAnl5efz000+sW7eOnJwcXC5Xk8/vcDjIzs4mJSWFbt26tRnxVxNJkigqKmLnzp388MMPrFy5kvT0dB5//HEeeeSR1l5eq1DdZDshIYFHH32UgoICdu3ahd1uV29PS0tj7Nix/PTTT836h4OGxsnQtoA1fresXLkypAE8SLABPGgE/fbbb6sN4K+//jrdu3dvhdVq1IfP52PlypXMmzePL774AlmWGTduHFlZWYwYMUKdpKzOoUOHOHjwIP379ycmJua0r9nj8ahTtGVlZURGRpKUlERycnKDp2iDlb/U1NQ2Y6FTF0IIPvvsM+666y4WLFjApZdeGnK7x+Npso3MmUpw27awsJDdu3czbNgwDAYDb7zxBnfeeSf//Oc/ueeee4iMjATgpptuoqioiPnz59f5edbQaAk0AaihoXHG4Pf7+fnnn/n888/54osvcDgcjB07lszMTEaNGoXJZOKZZ56hV69eXHLJJURFRbX2kvF6veoUbUlJiTpFm5ycTHh4eJ3C7kwRfwALFizg9ttvZ+7cuYwdO7bFn69Tp04cPny41vG///3vdZq+z5kzh7/+9a8hx8xmc4sZvgfF38GDBxkzZgzjx49n8uTJ9OnTB4DXX3+du+66i4kTJ9KjRw90Oh0vvPACS5Ys4cILL2yRNWlo1IUmADU0NM5IZFlmzZo1zJ8/n4ULF1JSUkJSUhIFBQUsWLCA888/v7WXWAu/36+KweLiYiwWi2qpEhUVhSRJ2O12srOzad++PV26dGnT4u/rr7/mr3/9Kx999NFpa50oKipClmX1623btnHJJZewYsUKRowYUev+c+bM4Z577mH37t3qMUmSmqUntD4KCgoYOHAg48aN45lnniEhIQE4PhDyzjvv8Pe//53IyEhmzpxJr169OPfcc7WBD43TitYDqKFxGnj22WcZPHiwuhWYlZUVckECcLvd3HnnncTHxxMREcGkSZNqRU5pHEev13P++efz0ksvsW/fPkaPHk1RURFxcXFMmDCB66+/ns8++4zKysrWXqqKwWCgXbt29O3blxEjRtCtWzfcbjcbNmzg559/Ztu2baxbt47U1NQ2L/6WLl3KTTfdxJw5c05r32xiYiIpKSnqf19//TVdunThoosuqvcxkiSFPKYlxR/Ayy+/TK9evXjzzTdJSEjg0KFDvP7660ybNo1jx45xyy238P7771NRUcGRI0c499xzEUJo4k/jtKIJQA2N08CPP/7InXfeydq1a/nuu+/w+XxceumlOBwO9T733XcfX331FZ9//jk//vgjubm5TJw4sRVXfWYghOCWW25h06ZNbN26lUOHDvHzzz9z9tlnM2PGDDp16sTVV1/NRx99hM1mazN5v8HYuT59+nDRRRfRqVMnCgoKUBSF3Nxcdu3aRUlJScgwQVth+fLlTJ48mbfffpsrr7yy1dbh9Xr58MMPuemmm04olu12O+np6XTs2JHMzEy2b9/eouuKjIzE5XKxa9cu/vnPf3Lffffx9NNPs3jxYi666CLKysq47rrreP/995kxYwb/93//16z5yxoaDUHbAtbQaAWKiopISkrixx9/5MILL6S8vJzExEQ+/vhj9YK6a9cuevbsyZo1azQ/tZPw+uuvk5WVRWpqashxIQTbt29n3rx5LFy4kF27djFixAiysrIYN24ccXFxbaLKZrfbWb9+PR07diQjIwObzaZ6DQohVLPluLi4Vq8SrVq1iquuuopXX32VG2+8sVXfv88++4w///nP5OTk1PreB1mzZg179+7lnHPOoby8nOeff55Vq1axffv2OhNhGkN9W7Zz587lpZde4sCBA6Snp3PLLbcwbtw4tmzZwqOPPso333yjGpJ/9tlnXHvttfzwww91Dq1paLQUmgDU0GgF9u3bR7du3di6dSu9e/dm+fLlXHzxxZSVlYVMraanp3Pvvfdy3333td5ifycIIdizZw/z589nwYIFbN68mQsuuICsrCyuuOIKkpKSWkXMVFZWkp2dTceOHenSpUutNZeXl6ti0OfzkZCQQHJyMgkJCaddDK5evZqJEyfy/PPPc8stt7S6eB49ejQmk4mvvvqqwY/x+Xz07NmT6667jqeffrpJz5uXl0d8fDwmk6leEbhlyxYKCwu56KKL0Ov16HQ65syZw6xZs/j6669DxOfevXvp1q1bk9aiodFUNAGooXGaURSF8ePHY7PZ+PnnnwH4+OOP+etf/1rLB2zIkCGMHDmSGTNmtMZSf7cIITh48KAqBtevX8+wYcPIzMxk/PjxpKamnhZxExR/aWlpdO7c+aRrrqysVO1lXC4X8fHxqhhsqRSSIL/99htZWVk888wz3Hnnna0u/g4fPkznzp1ZsGABmZmZjXrsVVddhcFg4JNPPmn081ZWVjJp0iQ1XchqtYaIwLoye48dO8by5cu54447eO2117jxxhsb/bwaGs2N1gOooXGaufPOO9m2bRuffvppay/lD4skSXTu3JkHH3yQ1atXs3//fiZOnMiiRYvo2bMno0aN4uWXX+bw4cMt1jMYFH/p6eknFX/BNUdFRdG1a1eGDx/O0KFDiYqK4vDhw/z4449s2LCBo0eP4vV6m32tGzZsYMKECTz55JNtQvwBvPvuuyQlJTXaekaWZbZu3droTOggZrOZzMxMKisruf7666moqECv16uTyTXF3+HDh3nmmWd4/vnnmTVrlir+tNqLRmujVQA1NE4jU6dOZdGiRaxatYqMjAz1uLYF3DYQQpCXl8fChQuZP38+P/30E+eccw5ZWVlkZmY222RudfFX/XPQVJxOp1oZrKioICYmRrWXsVgsp3TuLVu2MHbsWB566CEeeuihNiH+FEUhIyOD6667junTp4fcNnnyZNq3b8+zzz4LwD//+U/OPfdcunbtis1mY+bMmXzxxRdkZ2dz9tlnN+p5gzYuAO+99x4fffQRVquV999/n6ioqHq3g3/77TckSWLw4MG1zqOh0VpoFUANjdOAEIKpU6eycOFCli9fXuuiP3DgQIxGY0g28e7du8nJydGyiU8jkiSRmprKnXfeyQ8//EBubi633XYbP//8M4MGDWLYsGFMnz6dnTt3NrmCU1FRQXZ2Np06dWoW8QeBGL1OnToxZMgQzj//fJKSkigsLOTnn3/mt99+49ChQzidzkafd8eOHVxxxRXcc889bUb8AXz//ffk5ORw00031botJyeHvLw89euysjJuueUWevbsyeWXX05FRQWrV69utPiD0Hi3yspKIiMj+fLLL5kyZQolJSUhlUA4XuUbMmSIJv402hxaBVBD4zTw97//nY8//phFixbRo0cP9Xh0dDRhYWEA3HHHHSxevJg5c+YQFRXFXXfdBQQa7zVaFyEEZWVlLFq0iAULFvDdd9/RuXNnMjMzmTBhAmeffXatrb+6CIq/jIwMOnXq1OLr9nq9amWwtLSUiIgItTIYERFxwsfu3r2byy67jJtvvplnnnlGEy3VGDJkCPHx8QwfPpxt27aRnZ1N165dee+990hOTq6zD1BDo62hCUANjdNAfRfPd999lylTpgABI+j777+fTz75BI/Hw+jRo3n99ddJSUk5jSvVaAjl5eV89dVXLFiwgG+//ZbU1FR1m7hfv351XvzLy8vZsGEDnTt3Jj09/bSv2efzUVxcTEFBASUlJYSFhaliMDIyMuQzum/fPi677DL+/Oc/M2PGDE3MVOO9997j2Wef5ZdffiE+Ph6A999/n9mzZxMXF6eKQC3VQ6OtowlADQ0NjVPAbrezePFi5s+fz+LFi0lISGD8+PFkZWUxePBgdDodq1at4siRI5x//vmtIv5qIsuyKgaLi4sxmUzs2bOHjh070rlzZ8aOHUtWVhazZs3SxF8N3njjDZ5++ml27Nih9usqisJzzz3HY489xogRI3j77bcbNNijodGaaD/ZGhoaGqdAREQEV199NXPnzqWgoIAXX3yRkpISJk6cqPrNTZgwgdzc3DYh/iCQQpKcnMw555zDRRddRI8ePdi8eTPXX389/fr1IyoqivHjx7fJFJLTSfX6SPC9OOuss0hISGDNmjUhk78TJ06ka9euFBUVsWrVqlZZr4ZGY9AEoIbGH5A33niDc845h6ioKKKiohg2bBhLlixRb9dyiZuG1WplwoQJfPjhh+Tl5XHvvfeyZMkSJEnijTfe4J577mHlypVtKvZLr9eTmJjIww8/THJyMhdffDHnn38+N9xwA+3ateO5555r7SW2CrIsq9viHo9HjW0cOHAgUVFRPPPMM6xdu1a9f0FBAWeffTb/+c9/1LYODY22jLYFrKHxB+Srr75Cr9fTrVs3hBC89957zJw5k40bN9KrVy/uuOMOvvnmG+bMmUN0dDRTp05Fp9Pxyy+/tPbSzxjWrFnDmDFj+Pe//82tt97KihUrmD9/Pl988QWyLDNu3DiysrIYMWIEJpOpVddaUFDAZZddxpAhQ3j33XfVadY1a9bg8/n+0BFlU6dOZdu2bbjdbh544AGuvPJKbDYbI0aMQKfTcfbZZ9OzZ09mzZrF3/72N9V+Rpv21WjraAJQQ0MDgLi4OGbOnMmVV16p5RI3A2+++SaKovD3v/895Ljf7+enn35i3rx5fPHFFzidTsaOHcv48eMZNWrUKfv2NZbi4mIuv/xyevfuzYcffojBYDitz9/WqD68ceedd/L9999zww03sGfPHj766COeffZZ/vGPf+B0Opk+fTobN27E4/EwZMgQnnnmGUATfxpnBpoA1ND4gyPLMp9//jk33ngjGzduJD8/XzOlPk3Isszq1auZP38+CxcuxGazMWbMGDIzM7n00kuxWq0t+vylpaWMHTuWLl26MHfu3BaPkwOYNm0aTz31VMixHj16sGvXrnof8/nnn/P4449z6NAhunXrxowZM7j88stbdJ27d+/m888/Z/z48ZxzzjkoisLs2bO57777mDZtGo8//rh6X6fTqX6vtOlfjTMFrQdQQ+MPytatW4mIiMBsNnP77bezcOFCzj77bPLz8zGZTCHiDyA5OZn8/PzWWezvFL1ezwUXXMCsWbM4ePAgy5YtIy0tjSeeeIJOnTpx/fXX8/nnn1NZWdnsz22z2cjMzCQtLY1PP/30tIi/IL169SIvL0/9L5iJXRerV6/muuuu4+abb2bjxo1kZWWRlZXFtm3bmm09//znP3G73erXCxYsoGfPnsyePVuN1tPpdNx999289tprPP300yEiNij+hBCa+NM4Y9AEoIbGH5QePXqwadMmfv31V+644w5uvPFGduzY0drL+sOi0+kYOnQoM2fOZM+ePaxatYqePXsyffp0OnXqxDXXXMPHH3+MzWY75RzZiooKJk6cSGJiIp9//vlp70E0GAykpKSo/yUkJNR735dffpkxY8bw4IMP0rNnT55++mkGDBjA7Nmzm2UtGzdu5Ntvvw15D0aMGMEjjzxCSUkJmzdvBo5PBN9+++288cYbPPXUUyxcuDDkXNq2r8aZhCYANTT+oJhMJrp27crAgQN59tln6du3Ly+//DIpKSl4vV5sNlvI/QsKCjRT6tOETqdjwIAB/Pvf/2bHjh2sW7eOgQMH8sorr5CRkcGkSZN4//33KSkpabQYtNvtXHnllYSHh7Nw4cLT3nMIsHfvXlJTU+ncuTPXX389OTk59d53zZo1jBo1KuTY6NGjWbNmTbOspX///vz888/odDo+++wzysvLiYuL48EHH+Tee+/l1ltvZe7cuSHi7uabb2bVqlVMmDChWdagodEaaAJQQ+M0IoQ45epNS6EoCh6PR8slbmNIkkTv3r2ZNm0amzdvZsuWLVx44YW88847dO7cmfHjx/Of//yHgoKCk362nE4nV199NXq9nkWLFqkxhKeToUOHMmfOHJYuXcobb7zBwYMHueCCC+rd5s7Pzyc5OTnkWHO1IwS9/YQQHD16lGuvvZa//OUvlJeXExMTw5NPPskDDzzAddddxwcffBDy2PPPPx8gJPtXQ+OMQmhoaLQKsiwLRVFa5bkffvhh8eOPP4qDBw+KLVu2iIcfflhIkiSWLVsmhBDi9ttvF2lpaWL58uVi/fr1YtiwYWLYsGGtslaNulEURezbt0/MmDFDDB06VBgMBnHBBReI559/Xuzdu1fY7XbhcDjU/0pKSsSoUaPEsGHDRHl5eWsvX6WsrExERUWJ//znP3XebjQaxccffxxy7LXXXhNJSUnNtoaDBw8KIYT49ddfRUpKihg7dqwoKSkRQghht9vF448/LvR6vXj55Zeb7Tk1NFobrQKooXGaePrpp/nb3/7Gl19+CQS2+VqrZ6iwsJDJkyfTo0cPLr74YtatW8e3337LJZdcAsBLL73EuHHjmDRpEhdeeCEpKSksWLCgVdaqUTeSJNGlSxceeugh1qxZw/79+5kwYQKLFi2iZ8+eXHLJJbzyyivk5OTg8Xi44YYbKC8vZ/HixURFRbX28lViYmLo3r07+/btq/P2lJSUWibkzdmO8NNPPzFgwADWr1/PkCFDWLp0KdnZ2fz5z3+muLiY8PBwHn74Ye69916+++67ZnlODY22gGYDo6FxGsjPz2fKlCls3rwZnU5HWVkZmZmZ3H333QwbNkzzDdNoNoQQ5ObmsnDhQhYsWMCqVauIjIwkKSmJNWvWEBcX19pLDMFut5OWlsa0adO4++67a91+zTXX4HQ6+eqrr9Rjw4cP55xzzuHNN99s9PPV/Fnbtm0bjz76KAMHDuSBBx4gPDyc7du3M2bMGHr06MHHH39MUlISXq9XHRTRfl41fg9oFUANjdPAb7/9RmVlJS+++CLHjh3ju+++IzIykv/3//4f3333nXYx0Wg2JEmiffv2TJ06lR9++IHc3FyysrKYP39+mxB/DzzwAD/++COHDh1i9erVTJgwAb1ez3XXXQfA5MmTeeSRR9T733PPPSxdupQXXniBXbt2MW3aNNavX8/UqVOb9PzBn7VgxbF3795ccsklvPPOO+zduxcI2NT88MMPHDp0iIsuuojS0lJN/Gn87tAEoIbGaeDXX39Fp9PRv39/AM477zymT59OSkoKU6ZMYfv27a28wrbF9OnTkSSJe++9Vz2m5RM3HkmSSEpK4t1336V3796tvRwAjh49ynXXXUePHj24+uqriY+PZ+3atSQmJgKQk5NDXl6eev/hw4fz8ccf8/bbb9O3b181QeVUXs+nn35K9+7duffee7HZbNx1111ceuml/PnPf8blcgHQvXt3Fi9eTL9+/YiNjVUfq4k/jd8L2hawhkYLU1hYyK233kpUVBTvv/9+yG1lZWWkpaXx8ssvc9NNN6lTnMGLjN/vR6fTodP9cf5WW7duHVdffTVRUVGMHDmSWbNmAWj5xBrNxldffUVmZiZGo5GrrrqKAQMG0L9/f9566y26d+/OE088USsST0v40Pi98ce5qmhotBLr16+nsLBQtVBRFEUVen6/n8jISHXrSZIkJElSK1sGg+EPJf7sdjvXX38977zzTkjVpby8nP/+97+8+OKL/OlPf2LgwIG8++67rF69mrVr17biijXOJIK2L1dccQXTp0/npptuonPnzuzbt4+//e1vFBQUsG7dOg4ePFjrsZr40/i98ce5smhotBJr165Fp9Nx4YUXAgGRFxSAW7ZswWg0qjFcBw8e5Mknn2TixIm0b9+eyZMn1xl5Jctym/UTPBXuvPNOxo4dW8v4Nzs7G5/PF3L8rLPOIi0trdkMgTV+3yxZsoQxY8bw3Xff4fF4GDlyJCUlJYwaNYoXX3yRu+++m127dvHtt9/WqtRraPwe0QSghkYLUlpayo4dO0hPT6dXr15AQAAGKxE//fQTLpeL0aNHA3Drrbeyfft2HnzwQT7++GPKy8t58sknVZPc4OP0er26TSzLsnq8OmeaQPz000/ZsGEDzz77bK3btHxijVPl7LPPpqKigmeffZZbbrmFHj160LNnT+6++24MBgP33HMPixYt4qmnnuKBBx5o7eVqaLQ4mgDU0GhBgv5s5513Xshxg8HA0aNH+fjjj+nTpw/nnXce7733Hr/88gsDBgxgzJgxXHTRRSxatIjffvuNzz//XD1fZmYm77//PocOHQICYrD6NrEsy9hstjOqWf3IkSPcc889fPTRR60STabx+0ZRFNLT0/npp5+YMmUK+fn5dOvWjW7duuF2u3nkkUfw+/0MGTKExx57jOjoaPx+f2svW0OjRdEEoIZGC1NSUsIDDzzA3//+dxYvXsyvv/7KSy+9xLXXXovL5eLhhx9GURS+/fZb2rdvz9dff01iYiL9+/fn9ddfx2Kx4PP5ADhw4ADr16/n1Vdf5d5778VgMHDXXXdRXl6uVvz27t3L5ZdfziuvvAIcrwQWFBSwZcuW1nkTTkJ2djaFhYUMGDAAg8GAwWDgxx9/5JVXXsFgMJCcnKzlE2s0GZ1Oh6IoGI1GJk+ezJIlS7jzzjuZMWMGTqeT9957jw0bNgDHB7BqDoFoaPze0ASghkYLMnbsWHJycliwYAGFhYXcfvvt3H333Xz88cdERkby+eefq+kbu3fv5oYbbmD16tVkZ2czefJkPvjgA7xeLzqdDiEEq1evprS0lMmTJ/POO+/w1VdfsXDhQn7++WckSWLVqlW8+uqryLKsDp0EL2jPPfccF198sWpz0Za4+OKL2bp1K5s2bVL/GzRoENdff736by2fuO3w7LPPMnjwYNVgOisri927d5/wMXPmzFGHnIL/tVS1t672h+pVcr1ezxNPPMFbb73FlVdeSUJCAp07d26RtWhotFU0GxgNjRakLuuIffv2YbVaSU1NDTk+atQoYmJi+OCDDwgLC1OPHzt2jLi4OI4cOcLkyZPp27cvb731FhDwxrvuuuuQJIkFCxawbNkyrrnmGsrLyxk4cCBTpkzhlltuwWQy0b9/fy655BKee+45tWewLU8Yjxgxgn79+oXYwCxevJg5c+YQFRXFXXfdBcDq1atbcZV/TMaMGcO1117L4MGD8fv9PProo2zbto0dO3YQHh5e52PmzJnDPffcEyIUJUkiOTm52dalKEqdn+max6ubOTudTgCsVqtm9aLxh0KrcWtotCDBi4miKCiKgsFgoGvXrnXe91//+he33nor//vf/7jhhhswGAyUlZXRoUMHIGAnc+TIEXVIwuPxYLFYiIiIoLCwEICOHTsycOBAunbtSlpaGh999BEXXHABJpOJLVu28PrrrwNtW/jVx0svvYROp2PSpEl4PB5Gjx6tvh6N08vSpUtDvp4zZw5JSUlkZ2er0+51IUlSi23ZB0Xe9u3b+eCDD4iPj2fQoEGMHDlS3QIOfu6r98darVb135r40/gjceZdBTQ0zkB0Ot1Je4oGDRrEnXfeyXPPPUdGRgZZWVnMnDmTI0eO4PF4+PXXXykrK2PkyJEAajTVqlWrGD58OBCYKq6srCQrK4tHH32U1atXc8455/Dtt98SERHBsWPHmDRpErNmzcJut7fsiz5FVq5cqVb/ACwWC6+99hqlpaU4HA4WLFig9f+1EcrLywFOGjVnt9tJT0+nY8eOZGZmNlsCjhBCFX9Dhgxh/fr1vPLKKzz++OM899xzwPE+QA0NjQCaANTQaCPo9XpuvfVWDh8+zE8//cTEiRO5/PLL6dixI3v37mXXrl3odDo++eQTIHDR++qrrzhy5AhZWVlAYJgiJiaGoUOHAsdtY+bPn4/dbmfjxo2cf/75vPTSS9x///0NmnTcvHkzU6dOxeFwtMwL1zijURSFe++9l/POO++E8Ww9evTgf//7H4sWLeLDDz9EURSGDx/O0aNHT/n5JUmivLycpUuXcv/99/P999+zYsUKhg4dyqeffsrTTz8NBESgLMun9HwaGr8bhIaGRptAURTh9/vrvO3DDz8Uffv2FQ888IC49tprxX//+1/xf//3fyItLU3cfPPNQgghtm/fLkaNGiUeeOABIYQQsiwLIYTYt2+f0Ol04sMPPxRut1sIIcQnn3wiYmJixObNm0+4pmXLlolhw4aJ++67r7le5hnFk08+KYCQ/3r06KHe7nK5xN///ncRFxcnwsPDxcSJE0V+fn4rrvj0c/vtt4v09HRx5MiRRj3O6/WKLl26iMcee+yU11BYWCiuueYaMXDgQDFv3jz1+JEjR8Q//vEP0b9/f/HUU0+d8vNoaPye0CqAGhptBEmS1B4kIYRaqXC73WzduhWj0ci0adMYOnQo//73v1m1ahWPPfYY06dPB2DXrl0UFBSo28HBxy9YsID27dszduxYzGYzAH369KGiooL4+Pha6xBVc2EbNmzg8ccfZ+T/b+/+Y6Ku/ziAP0F+ChYrgcMgEeIuQacIlBY6YiGMgJFDHaKOSc1KYAh5QW1kFKW4WmmN5nCVBeOHRYimURhoGAthJOUBB5qIHih0xI/ix8Hn+4ff++SFWmbdIZ/nY2OMzx2fe992t3ve+/N+v16PPYa33npLvO3aVnZS4OPjA41GI/58++234m1bt25FeXk5SkpKUF1djUuXLmHVqlUmHK1xJSYm4tChQ/jmm2/Etap/l6WlJXx9fdHW1nbb4+ju7sbg4CDUajWamprE466urkhJScETTzyBjz/+GJmZmbf9WETTBTeBEE1B14bB1tZWVFZWIiAgAHZ2dkhJSUFKSgqGhoYMdlx6enqir69P7Jahby9XXFyMiIgIODg4iLsfy8rKMG/ePMyaNeu6jw1cLfVx3333ITU11eC2axfQ63Q6g64k05GFhcV11xrq+xMXFBQgODgYAPDBBx9g/vz5qK2txdKlS409VKMRBAFJSUkoLS1FVVUV5s2bd8vnGB8fR1NTE8LDw//R41/7mluwYAFycnKQnZ2NTz/9FG5ubkhISAAAyGQyJCYmwszMTFLhnOivcAaQaIpzcnJCUFCQ+OE1PDwMQRBgZ2dnMBPn6emJkJAQhIaGYsWKFbhy5QrOnz+PH3/8ETExMQbnLCwsRHh4+KSSHfpZw6NHj6K+vh5xcXHiLKFOp8OePXuQl5cnls6wsLAw+CCejjODarUac+bMgYeHB+Li4tDR0QFA2v2Jt2zZgk8++USsZ9nV1YWuri6DGpMbN25ERkaG+HdWVhYqKipw9uxZNDQ0YP369Th//jyeeuqpW3psnU4HMzMzjIyMQKPRoK+vDzqdDt7e3sjIyMCSJUuwb98+sVQScLVlYGZmJhYvXjwtX6NE/wQDINEUJ5PJsGvXLjFo2NjYiKHr2vBlb2+Pffv24eLFi0hKSoK9vT3KysowMjICX19f8f4XLlzATz/9hMjIyBuWvdi7dy8UCoV4ORm42q7t8OHD2L59O95++224u7sjPT0dWq1WvI9+PPrNJ/rfR44cmZIFqP/Kww8/jA8//BBHjx5Fbm4uzp07h+XLl2NgYEDS/Ylzc3Px66+/IigoCC4uLuJPUVGReJ+Ojg5oNBrxb61Wi6effhrz589HeHg4+vv7cfLkSXh7e//txx0fH4eFhQV6enqwatUqBAcHIzIyEhkZGRgYGMCCBQugVCqhUCiQn59vsItcvwt/Os9WE90SE609JKJ/2fj4uLjxQ29oaEg4efKkIAhXN5kIgiC88sorgqurq9Dd3X3Dczk6Ogq7d+82ON8XX3whODk5CY8//rhQVlYmFBcXCx4eHsL7778v6HQ6oaCgQPjuu++ue75FixYJBw8evN2naHJarVa46667hLy8PCE/P1+wsrKadJ+AgABBqVSaYHTS0N/fL3h5eQkxMTHC8ePHhV27dgkuLi5CTEyM0NPTIwiCIDQ3NwtxcXGCn5+fcO7cOdMOmGiK4gwg0TRhbm4+qcDzzJkzJ7WE6+npQURExKSabcI1mz+cnJzg7u4unm9iYgJ1dXWwtrZGeXk5oqKisHr1anh6eiI7OxvPPPMMDh06hNDQUKxbtw6//PKLwbnXrVuHAwcO/CfP25gcHBwgl8vR1tYGmUzG/sRGNjExgbS0NPj6+qKkpATLly9HVVUVbG1toVarER8fj97eXigUCmRmZiIvLw/u7u6mHjbRlMQASCQxu3fvRm5u7qTC1PqAqNVqMXv2bIN2dB0dHWhoaMCKFSvE/q3Dw8OYOXMmbGxsoFQqkZ+fj8rKSpSXl0OlUgGAWGdQpVKJ6wuFO3gN1uDgINrb2+Hi4gI/Pz/2JzYyc3Nz+Pn5ISoqCgAQGxuLrq4uVFdXY+3atfjyyy+xdu1adHZ2Qi6XY/HixaYdMNEUxl3ARBIi/L+My81aXi1cuBDNzc3w8PAQj505cwZnz55Fenq6eOzUqVPQarXYuHEjvLy8AFxdr2hra4v+/n4Af6y7Mjc3h4ODA4aHh8UAeSd4/vnnERkZiblz5+LSpUt4+eWXMWPGDMTGxuLuu+9GQkICUlNTcc8994j9iZctWzatdwAb0/V6+27evBkjIyOorq5Ga2sr9u7dC1dXVzz66KPw9PTEb7/9BpVKdctlaYikhgGQSEKuLS9zIwMDA7C3tzeYAayrq4OZmRnCwsLEY7W1tRgdHRVLoADAsWPHMHfuXIOF9vpNIlqt9o4KfwDQ2dmJ2NhY9Pb2wtHREYGBgaitrYWjoyMA9if+L+l0OvELREtLCwYGBuDq6gqZTAZra2v8/PPP6OzshJubGwDg4sWLeOSRR5CRkXHDfttE9AcGQCIy4OzsjJUrV+LEiRNYs2YNenp6xMue+nWD+uLULi4uCAgIEP/32LFjmDNnDh588EHx2OXLl6FSqRASEmL053K7CgsLb3q7vj/xe++9Z6QRScPExIQY/kJCQjA0NISmpiYEBwfjoYcewksvvQS5XI77778fzz33HJYuXYrMzEy8++67YvgT/lQrkIgMcQ0gERmwt7dHWFiYGOxmz56N/fv3Y//+/eJ96urqcOrUKSxcuFAsON3d3Y3m5mb4+PgYLLxXqVRoa2tDRESEUZ8H3bn0l33DwsLw+++/47PPPsMPP/wAlUqFiooKDAwMwNfXFxs2bEBPTw+KiorwxhtvYNOmTeI5GP6Ibo4zgEQ0iX6RPfDHTIqTk5N4TC6XIyEhwaBO4FdffYWJiQn4+/uLxy5fvozDhw9DoVAYzBQS6f15pm58fBwzZsxAY2Mjrly5grKyMshkMmzbtg0jIyPIzc3FrFmzMDg4iOTkZCQnJ6O3t1csWH69dYNENBnfJUR0U9ebSXF2dkZqaqrBZofTp0/D1tYWPj4+4rHi4mI0Nzdj8+bNRhkr3Xn0r6/6+noAENeoWlpaYmxsDDKZDFu3bkVhYSEOHjwIb29vdHZ2Ys+ePWhtbQUAcWmCIAgMf0R/E98pRHTLBEGYVM4lJycHRUVFUCgUAICuri689tpriI6ORnR0tAlGSXeKHTt2YOXKlXjzzTfF15WFhQW0Wi0iIiJQWlqK0tJSLFq0CMDVWpXXdpe5XmccIro5BkAiumVmZmbX/bDVF0BubW1FYmIiAgMDkZaWBnt7e2MPke4Qvb29+PzzzzE6Oorq6mq8/vrr0Ol0UCgUSEtLQ0VFBeLj4+Hv74/R0VE0NjZiy5YtCAoKEgMhEd06rgEkon+dftfv6tWrAXBHJt3Yvffei02bNuGFF16AtbU1KisrIQgClEolUlJSoNFokJWVhePHj0On06GrqwsRERHIysoCwDV/RP+UmXAnl+UnoimLoY/+ytjYGCwtLdHX14fU1FQsWbIEarUaNTU1iI6OhlKphJWVFY4cOYLa2lrY2dnBy8sLTz75JIA/NowQ0a1jACQiIqNqb2+Hm5sbrKysxGOJiYnQaDQoKSlBeno6qqqqEB4ejm3btsHOzm7SFwrO/BHdHr57iIjIaD766CP4+/sjNDQUJ06cQEtLC4CrG0HUajUOHDiAV199FYGBgaioqMCOHTvQ398/aTaZ4Y/o9vAdRERERtHX14eioiJYWlpCpVIhOzsbSUlJ2L59O/r7+xEeHo6GhgZYW1sjOzsbgYGBKCgowNdff23qoRNNO7wETERERlNfX4933nkHQ0NDeOCBBxASEoLk5GT4+vri+++/R3t7O2pqarBs2TKMjY2htLQUa9asMfWwiaYdzgASEZHR+Pn5ITk5GTY2NqipqcHY2BgaGxsRHx+PoKAgyOVysZWgpaWlGP4mJiZMOGqi6YczgEREZHSnT59GTk4O2trakJiYiPXr1wO4epnYwcGBmzyI/mMMgEREZBJnzpzBzp07oVarsWHDBjz77LMAuMOXyBgYAImIyGRaW1uxc+dOtLS0ICoqCkql0tRDIpIEfsUiIiKTkcvlePHFF+Hs7IwLFy6YejhEksEZQCIiMjmNRgMXFxcA7CJDZAwMgERENGVw/R+RcTAAEhEREUkMv2YRERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERSQwDIBEREZHEMAASERERScz/ANLSlTXfvoJDAAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure()\n", + "\n", + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"MonopileDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + "}\n", + "results = {\n", + " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", + " \"transition_piece_unit_cost\": lambda run: run.design_results[\"transition_piece\"][\"unit_cost\"],\n", + "}\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "x = parametric.results[\"site.depth\"]\n", + "y = parametric.results[\"site.mean_windspeed\"]\n", + "z = parametric.results[\"monopile_unit_cost\"]\n", + "\n", + "ax = fig.add_subplot(projection='3d')\n", + "ax.set_title(\"Monopile Substructure\")\n", + "\n", + "# Plot the ORBIT data\n", + "ax.scatter(x, y, zs=z, zdir='z')\n", + "\n", + "# Plot the surfaces\n", + "surface = linear_2d(x, y, z)\n", + "ax.plot_surface(\n", + " np.reshape(x, (len(DEPTHS), -1)),\n", + " np.reshape(y, (len(DEPTHS), -1)),\n", + " np.reshape(surface, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Planar\"\n", + ")\n", + "\n", + "surface = quadratic_2d(x, y, z)\n", + "ax.plot_surface(\n", + " np.reshape(x, (len(DEPTHS), -1)),\n", + " np.reshape(y, (len(DEPTHS), -1)),\n", + " np.reshape(surface, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Quadratic\"\n", + ")\n", + "\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Mean wind speed (m/s)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mooring System\n", + "\n", + "For all types, the line length is a function of water depth.\n", + "\n", + "For TLP systems, line length is the difference between the water depth and the draft.\n", + "\n", + "For SemiTaut systems, line length is the sum of rope length and chain length.\n", + "Rope length is defined from a fixed relationship for depth and rope lengths.\n", + "Chain length is also defined from a fixed relationship for depth and chain diameter.\n", + "While the semi-taut system line length is dependent on rope length and chain length, the parameters\n", + "are fixed and depend on water depth so they are not included in this parameterization." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9792f103128847eea10a95d868da84fe", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"MooringSystemDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + "}\n", + "results = {\n", + " \"mooring_system_system_cost\": lambda run: run.design_results[\"mooring_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "## Run ORBIT for each mooring system type\n", + "\n", + "# Catenary mooring system\n", + "parameters[\"mooring_system_design.mooring_type\"] = [\"Catenary\"]\n", + "parametric_catenary = ParametricManager(config, parameters, results, product=True)\n", + "parametric_catenary.run()\n", + "\n", + "# Tension Leg Platform (TLP) mooring system\n", + "parameters[\"mooring_system_design.mooring_type\"] = [\"TLP\"]\n", + "parameters[\"mooring_system_design.draft_depth\"] = [i for i in range(5, 100, 5)] # Draft depth 5-100 meters\n", + "parametric_tlp = ParametricManager(config, parameters, results, product=True)\n", + "parametric_tlp.run()\n", + "\n", + "# Semi-taut mooring system\n", + "parameters[\"mooring_system_design.mooring_type\"] = [\"SemiTaut\"]\n", + "parametric_semitaut = ParametricManager(config, parameters, results, product=True)\n", + "parametric_semitaut.run()\n", + "\n", + "\n", + "## Fit the data to a curve\n", + "\n", + "x_catenary = parametric_catenary.results[\"site.depth\"]\n", + "z_catenary = parametric_catenary.results[\"mooring_system_system_cost\"]\n", + "curve_catenary = linear_1d(x_catenary, z_catenary)\n", + "\n", + "x_tlp = parametric_tlp.results[\"site.depth\"]\n", + "y_tlp = parametric_tlp.results[\"mooring_system_design.draft_depth\"]\n", + "z_tlp = parametric_tlp.results[\"mooring_system_system_cost\"]\n", + "curve_tlp = linear_2d(x_tlp, y_tlp, z_tlp)\n", + "\n", + "x_semitaut = parametric_semitaut.results[\"site.depth\"]\n", + "z_semitaut = parametric_semitaut.results[\"mooring_system_system_cost\"]\n", + "curve_semitaut = linear_1d(x_semitaut, z_semitaut)\n", + "\n", + "## Plot the ORBIT data and curve fits\n", + "\n", + "fig = plt.figure()\n", + "\n", + "ax = fig.add_subplot(2, 2, 1)\n", + "ax.set_title(\"Catenary\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "ax.scatter(x_catenary, z_catenary)\n", + "ax.plot(x_catenary, curve_catenary)\n", + "\n", + "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", + "ax.set_title(\"TLP\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Draft depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "ax.scatter(x_tlp, y_tlp, zs=z_tlp, zdir='z')\n", + "ax.plot_surface(\n", + " np.reshape(x_tlp, (len(DEPTHS), -1)),\n", + " np.reshape(y_tlp, (len(DEPTHS), -1)),\n", + " np.reshape(curve_tlp, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Quadratic\"\n", + ")\n", + "\n", + "ax = fig.add_subplot(2, 2, 3)\n", + "ax.set_title(\"Semi-Taut\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "ax.scatter(x_semitaut, z_semitaut)\n", + "ax.plot(x_semitaut, curve_semitaut)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Array System" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Cost ($)')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "995e099c7c8a456e8b9d2faacc20b9eb", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Array System\")\n", + "\n", + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + "}\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "curve = linear_1d(DEPTHS, parametric.results[\"array_system_system_cost\"])\n", + "\n", + "ax.scatter(DEPTHS, parametric.results[\"array_system_system_cost\"], marker=\"+\")\n", + "ax.plot(DEPTHS, curve)\n", + "\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "# ax.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Export System\n", + "- site.distance_to_landfall\n", + "- Here, we must use parametric.results[\"site.depth\"] instead of the global DEPTHS because the\n", + "- local depth list is broadcast to 2D for the product of the two lists.\n", + "- Plot curves for HVAC and HVDC cable types" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "PathCollection.set() got an unexpected keyword argument 'zs'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 30\u001b[0m\n\u001b[1;32m 21\u001b[0m curve_cost_depth \u001b[38;5;241m=\u001b[39m linear_1d(\n\u001b[1;32m 22\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.depth\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 23\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexport_system_system_cost\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 24\u001b[0m )\n\u001b[1;32m 25\u001b[0m curve_distance_to_landfall \u001b[38;5;241m=\u001b[39m linear_1d(\n\u001b[1;32m 26\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.distance_to_landfall\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 27\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexport_system_system_cost\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 28\u001b[0m )\n\u001b[0;32m---> 30\u001b[0m \u001b[43max\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscatter\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msite.depth\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[43m \u001b[49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msite.distance_to_landfall\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[43m \u001b[49m\u001b[43mzs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mexport_system_system_cost\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 34\u001b[0m \u001b[43m \u001b[49m\u001b[43mzdir\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mz\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHVAC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 36\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 37\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 38\u001b[0m xs\u001b[38;5;241m=\u001b[39mparametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.depth\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 39\u001b[0m ys\u001b[38;5;241m=\u001b[39mcurve_cost_depth,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 42\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHVAC cost(depth)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n\u001b[1;32m 44\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 45\u001b[0m xs\u001b[38;5;241m=\u001b[39mparametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.distance_to_landfall\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 46\u001b[0m ys\u001b[38;5;241m=\u001b[39mcurve_distance_to_landfall,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 49\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHVAC cost(distance_to_landfall)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 50\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/__init__.py:1473\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 1471\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1473\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1474\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1475\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1476\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1478\u001b[0m bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1479\u001b[0m auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[1;32m 1480\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n", + "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/axes/_axes.py:4901\u001b[0m, in \u001b[0;36mAxes.scatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4897\u001b[0m keys_str \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m extra_keys)\n\u001b[1;32m 4898\u001b[0m _api\u001b[38;5;241m.\u001b[39mwarn_external(\n\u001b[1;32m 4899\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo data for colormapping provided via \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 4900\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mParameters \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkeys_str\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m will be ignored\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 4901\u001b[0m \u001b[43mcollection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_internal_update\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4903\u001b[0m \u001b[38;5;66;03m# Classic mode only:\u001b[39;00m\n\u001b[1;32m 4904\u001b[0m \u001b[38;5;66;03m# ensure there are margins to allow for the\u001b[39;00m\n\u001b[1;32m 4905\u001b[0m \u001b[38;5;66;03m# finite size of the symbols. In v2.x, margins\u001b[39;00m\n\u001b[1;32m 4906\u001b[0m \u001b[38;5;66;03m# are present by default, so we disable this\u001b[39;00m\n\u001b[1;32m 4907\u001b[0m \u001b[38;5;66;03m# scatter-specific override.\u001b[39;00m\n\u001b[1;32m 4908\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_internal.classic_mode\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n", + "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/artist.py:1216\u001b[0m, in \u001b[0;36mArtist._internal_update\u001b[0;34m(self, kwargs)\u001b[0m\n\u001b[1;32m 1209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_internal_update\u001b[39m(\u001b[38;5;28mself\u001b[39m, kwargs):\n\u001b[1;32m 1210\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1211\u001b[0m \u001b[38;5;124;03m Update artist properties without prenormalizing them, but generating\u001b[39;00m\n\u001b[1;32m 1212\u001b[0m \u001b[38;5;124;03m errors as if calling `set`.\u001b[39;00m\n\u001b[1;32m 1213\u001b[0m \n\u001b[1;32m 1214\u001b[0m \u001b[38;5;124;03m The lack of prenormalization is to maintain backcompatibility.\u001b[39;00m\n\u001b[1;32m 1215\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1216\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_props\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1217\u001b[0m \u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{cls.__name__}\u001b[39;49;00m\u001b[38;5;124;43m.set() got an unexpected keyword argument \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 1218\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{prop_name!r}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/artist.py:1190\u001b[0m, in \u001b[0;36mArtist._update_props\u001b[0;34m(self, props, errfmt)\u001b[0m\n\u001b[1;32m 1188\u001b[0m func \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mset_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(func):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[1;32m 1191\u001b[0m errfmt\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m), prop_name\u001b[38;5;241m=\u001b[39mk))\n\u001b[1;32m 1192\u001b[0m ret\u001b[38;5;241m.\u001b[39mappend(func(v))\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret:\n", + "\u001b[0;31mAttributeError\u001b[0m: PathCollection.set() got an unexpected keyword argument 'zs'" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f3433a670f334d4a9bf6e3a5151560a4", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.set_title(\"Export System\")\n", + "\n", + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"ExportSystemDesign\"]\n", + "distance_to_landfall = [i for i in range(0, 400, 10)]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + " \"site.distance_to_landfall\": distance_to_landfall,\n", + "}\n", + "results = {\n", + " \"export_system_system_cost\": lambda run: run.design_results[\"export_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "\n", + "## HVAC\n", + "config[\"export_system_design\"][\"cables\"] = \"XLPE_1000mm_220kV\"\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "curve_cost_depth = linear_1d(\n", + " parametric.results[\"site.depth\"],\n", + " parametric.results[\"export_system_system_cost\"]\n", + ")\n", + "curve_distance_to_landfall = linear_1d(\n", + " parametric.results[\"site.distance_to_landfall\"],\n", + " parametric.results[\"export_system_system_cost\"]\n", + ")\n", + "\n", + "ax.scatter(\n", + " parametric.results[\"site.depth\"],\n", + " parametric.results[\"site.distance_to_landfall\"],\n", + " zs=parametric.results[\"export_system_system_cost\"],\n", + " zdir='z',\n", + " label=\"HVAC\"\n", + ")\n", + "ax.plot(\n", + " xs=parametric.results[\"site.depth\"],\n", + " ys=curve_cost_depth,\n", + " zs=0,\n", + " zdir=\"y\",\n", + " label='HVAC cost(depth)'\n", + ")\n", + "ax.plot(\n", + " xs=parametric.results[\"site.distance_to_landfall\"],\n", + " ys=curve_distance_to_landfall,\n", + " zs=0,\n", + " zdir=\"x\",\n", + " label='HVAC cost(distance_to_landfall)'\n", + ")\n", + "\n", + "## HVDC\n", + "config[\"export_system_design\"][\"cables\"] = \"XLPE_1000mm_220kV\"\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "curve_cost_depth = linear_1d(\n", + " parametric.results[\"site.depth\"],\n", + " parametric.results[\"export_system_system_cost\"]\n", + ")\n", + "curve_distance_to_landfall = linear_1d(\n", + " parametric.results[\"site.distance_to_landfall\"],\n", + " parametric.results[\"export_system_system_cost\"]\n", + ")\n", + "\n", + "ax.scatter(\n", + " parametric.results[\"site.depth\"],\n", + " parametric.results[\"site.distance_to_landfall\"],\n", + " zs=parametric.results[\"export_system_system_cost\"],\n", + " zdir='z',\n", + " label=\"HVDC\"\n", + ")\n", + "ax.plot(\n", + " xs=parametric.results[\"site.depth\"],\n", + " ys=curve_cost_depth,\n", + " zs=0,\n", + " zdir=\"y\",\n", + " label='HVDC cost(depth)'\n", + ")\n", + "ax.plot(\n", + " xs=parametric.results[\"site.distance_to_landfall\"],\n", + " ys=curve_distance_to_landfall,\n", + " zs=0,\n", + " zdir=\"x\",\n", + " label='HVDC cost(distance_to_landfall)'\n", + ")\n", + "\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Distance to landfall (km)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "ax.legend()\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + "}\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "curve = linear_1d(DEPTHS, parametric.results[\"array_system_system_cost\"])\n", + "\n", + "ax.scatter(DEPTHS, parametric.results[\"array_system_system_cost\"], marker=\"+\")\n", + "ax.plot(DEPTHS, curve)\n", + "\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "# ax.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "bos", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/nrwal.yaml b/examples/nrwal.yaml new file mode 100644 index 00000000..8ea2c9ee --- /dev/null +++ b/examples/nrwal.yaml @@ -0,0 +1,62 @@ +site: + depth: 30 + distance: 100 + distance_to_landfall: 60 + mean_windspeed: 9 +turbine: 17MW_low_SP +plant: + layout: grid + num_turbines: 36 + row_spacing: 7 + substation_distance: 1 + turbine_spacing: 7 + + + + + +OffshoreSubstationInstallation: + feeder: example_heavy_feeder + num_feeders: 1 +array_cable_install_vessel: example_cable_lay_vessel +array_system_design: + cables: + - XLPE_630mm_66kV +commissioning: 0.01 +decommissioning: 0.15 +# design_phases: +# - MonopileDesign +# - ScourProtectionDesign +# - ArraySystemDesign +# - ExportSystemDesign +# - OffshoreSubstationDesign +export_cable_bury_vessel: example_cable_lay_vessel +export_cable_install_vessel: example_cable_lay_vessel +export_system_design: + cables: XLPE_1000mm_220kV + percent_added_length: 0.05 +# install_phases: +# ArrayCableInstallation: 0 +# ExportCableInstallation: 0 +# MonopileInstallation: !!python/tuple +# - ScourProtectionInstallation +# - 0.5 +# OffshoreSubstationInstallation: 0 +# ScourProtectionInstallation: 0 +# TurbineInstallation: !!python/tuple +# - MonopileInstallation +# - 0.1 +landfall: + interconnection_distance: 3 + trench_length: 2 +oss_install_vessel: example_heavy_lift_vessel + +scour_protection_design: + cost_per_tonne: 40 + scour_protection_depth: 1 +spi_vessel: example_scour_protection_vessel +wtiv: example_wtiv +port: + monthly_rate: 2000000.0 + sub_assembly_lines: 1 + turbine_assembly_cranes: 1 \ No newline at end of file From 5e59f5c7e5d4d958c61832ee396afa3ca4ab47bf Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Thu, 8 Aug 2024 13:16:26 -0500 Subject: [PATCH 215/240] Add parameters to array cable cost curve --- examples/cost_curves.ipynb | 193 +++++++++++++++++++++++++++++++------ 1 file changed, 162 insertions(+), 31 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 29726af9..7aa28540 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -56,7 +56,13 @@ "data and curves.\n", "\n", "4. Refine the curve fits by swapping the curve-fit function from the options available in\n", - "the \"Curve Fit Library\" section\n" + "the \"Curve Fit Library\" section\n", + "\n", + "\n", + "\n", + "TODO:\n", + "- Provide a template for a 1-dimensional and 2-dimensional cost function\n", + "- Compare the different mpl APIs for 2d vs 3d plots" ] }, { @@ -238,7 +244,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c017c86e9d98483eb2d665e3406414cd", + "model_id": "6f23bfa80e8c42e98b45fd1db5e1abe8", "version_major": 2, "version_minor": 0 }, @@ -262,8 +268,6 @@ } ], "source": [ - "fig = plt.figure()\n", - "\n", "config = deepcopy(base_config)\n", "config[\"design_phases\"] = [\"MonopileDesign\"]\n", "parameters = {\n", @@ -281,27 +285,28 @@ "y = parametric.results[\"site.mean_windspeed\"]\n", "z = parametric.results[\"monopile_unit_cost\"]\n", "\n", + "surface_linear = linear_2d(x, y, z)\n", + "surface_quadratic = quadratic_2d(x, y, z)\n", + "\n", + "fig = plt.figure()\n", "ax = fig.add_subplot(projection='3d')\n", "ax.set_title(\"Monopile Substructure\")\n", "\n", "# Plot the ORBIT data\n", "ax.scatter(x, y, zs=z, zdir='z')\n", "\n", - "# Plot the surfaces\n", - "surface = linear_2d(x, y, z)\n", + "# Plot the surface\n", "ax.plot_surface(\n", " np.reshape(x, (len(DEPTHS), -1)),\n", " np.reshape(y, (len(DEPTHS), -1)),\n", - " np.reshape(surface, (len(DEPTHS), -1)),\n", + " np.reshape(surface_linear, (len(DEPTHS), -1)),\n", " alpha=0.3,\n", " label=\"Planar\"\n", ")\n", - "\n", - "surface = quadratic_2d(x, y, z)\n", "ax.plot_surface(\n", " np.reshape(x, (len(DEPTHS), -1)),\n", " np.reshape(y, (len(DEPTHS), -1)),\n", - " np.reshape(surface, (len(DEPTHS), -1)),\n", + " np.reshape(surface_quadratic, (len(DEPTHS), -1)),\n", " alpha=0.3,\n", " label=\"Quadratic\"\n", ")\n", @@ -332,23 +337,23 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9792f103128847eea10a95d868da84fe", + "model_id": "527c08f6d4dd4bceab13076a4af3e552", "version_major": 2, "version_minor": 0 }, @@ -399,7 +404,6 @@ "parametric_semitaut = ParametricManager(config, parameters, results, product=True)\n", "parametric_semitaut.run()\n", "\n", - "\n", "## Fit the data to a curve\n", "\n", "x_catenary = parametric_catenary.results[\"site.depth\"]\n", @@ -452,39 +456,137 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Array System" + "## Array System\n", + "\n", + "The array system cost is entirely dependent on the cable length.\n", + "The cable length is a function of some fixed plant parameters and the following spatially\n", + "dependent parameters:\n", + "- water depth\n", + "- touchdown distance\n", + "- floating cable depth" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in coshRuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in cosh" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "The iteration is not making good progress, as measured by the \n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in cosh" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", + "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" + ] + }, { "data": { "text/plain": [ - "Text(0, 0.5, 'Cost ($)')" + "Text(0.5, 0, 'Cost ($)')" ] }, - "execution_count": 10, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "995e099c7c8a456e8b9d2faacc20b9eb", + "model_id": "ca8953cdfee94567a200a72992f93eee", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -497,13 +599,12 @@ } ], "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_title(\"Array System\")\n", - "\n", "config = deepcopy(base_config)\n", "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", "parameters = {\n", " \"site.depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 200, 10)],\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", "}\n", "results = {\n", " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", @@ -511,14 +612,44 @@ "parametric = ParametricManager(config, parameters, results, product=True)\n", "parametric.run()\n", "\n", - "curve = linear_1d(DEPTHS, parametric.results[\"array_system_system_cost\"])\n", + "x = parametric.results[\"site.depth\"]\n", + "y_touchdown = parametric.results[\"array_system_design.touchdown_distance\"]\n", + "y_floating_depth = parametric.results[\"array_system_design.floating_cable_depth\"]\n", + "z = parametric.results[\"array_system_system_cost\"]\n", "\n", - "ax.scatter(DEPTHS, parametric.results[\"array_system_system_cost\"], marker=\"+\")\n", - "ax.plot(DEPTHS, curve)\n", + "curve_depth_touchdown = quadratic_2d(x, y_touchdown, z)\n", + "curve_depth_floatingdepth = quadratic_2d(x, y_floating_depth, z)\n", + "curve_floatingdepth_touchdown = quadratic_2d(y_touchdown, y_floating_depth, z)\n", "\n", + "fig = plt.figure()\n", + "\n", + "ax = fig.add_subplot(1, 3, 1, projection='3d')\n", + "ax.set_title(\"Depth vs Touchdown Distance\")\n", + "ax.scatter(x, y_touchdown, zs=z, zdir='z')\n", + "ax.plot_surface(\n", + " np.reshape(x, (len(DEPTHS), -1)),\n", + " np.reshape(y_touchdown, (len(DEPTHS), -1)),\n", + " np.reshape(curve_depth_touchdown, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + ")\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Cost ($)\")\n", - "# ax.legend()" + "ax.set_ylabel(\"Touchdown distance (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "\n", + "ax = fig.add_subplot(1, 3, 2, projection='3d')\n", + "ax.set_title(\"Depth vs Floating Cable Depth\")\n", + "ax.scatter(x, y_floating_depth, zs=z, zdir='z')\n", + "ax.plot_surface(\n", + " np.reshape(x, (len(DEPTHS), -1)),\n", + " np.reshape(y_floating_depth, (len(DEPTHS), -1)),\n", + " np.reshape(curve_depth_floatingdepth, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + ")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Floating Cable Depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "\n", + "# TODO: This runs the three parameters as a product. To plot, reduce the data to 2 parameters." ] }, { @@ -555,7 +686,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f3433a670f334d4a9bf6e3a5151560a4", + "model_id": "3a36d4943fab42a89e232877c8fd73e8", "version_major": 2, "version_minor": 0 }, From a733ee55316472a5e1acd8625fef51d6f252f604 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Fri, 9 Aug 2024 13:54:33 -0500 Subject: [PATCH 216/240] Improve array cable models and add export system curves --- examples/cost_curves.ipynb | 469 ++++++++++++++++++++++--------------- 1 file changed, 279 insertions(+), 190 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 7aa28540..4c82dbe8 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -97,6 +97,13 @@ "They should always be generic, so the global variables should not be used here." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2D Curves" + ] + }, { "cell_type": "code", "execution_count": 3, @@ -134,42 +141,28 @@ " # print(f\"R-squared: {rvalue**2:.6f}\")\n", "\n", " curve = line_eval(slope, intercept, x)\n", - " return curve" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def quadratic():\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def logarithmic():\n", + " return curve\n", + "\n", + "def quadratic(x, y, fit_check=False):\n", + " pass\n", + "\n", + "def logarithmic(x, y, fit_check=False):\n", + " pass\n", + "\n", + "def exponential(x, y, fit_check=False):\n", " pass" ] }, { - "cell_type": "code", - "execution_count": 6, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "def exponential():\n", - " pass" + "### 3D Surfaces" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -231,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -244,7 +237,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6f23bfa80e8c42e98b45fd1db5e1abe8", + "model_id": "ec96ade62b464c0192a3454a765ebb5b", "version_major": 2, "version_minor": 0 }, @@ -337,23 +330,23 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 9, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "527c08f6d4dd4bceab13076a4af3e552", + "model_id": "81b71b9f9f6343c69752883d9765966f", "version_major": 2, "version_minor": 0 }, @@ -468,20 +461,117 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7e89f3a890bb42a0877628cc8b02d659", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACDNklEQVR4nO3deVxU5f4H8M+AbLKMgiwjopKIiohr2rhvhBtpt83UwDItxLU0pa4ipoJZXU0NW0wtM0pubqXiCrnvqLjhAmI6SC4sooDOPL8/+HGuI6AsMwzDfN6v17xezjnPOed7Dp7Dl+c8i0wIIUBEREREJsPM0AEQERERUdViAkhERERkYpgAEhEREZkYJoBEREREJoYJIBEREZGJYQJIREREZGKYABIRERGZGCaARERERCaGCSARERGRiWECSERERGRimAASERERmRgmgEREREQmhgkgERERkYlhAkhERERkYpgAEhEREZkYJoBEREREJoYJIBEREZGJYQJIREREZGKYABIRERGZGCaARERERCaGCSARERGRiWECSERERGRimAASERERmRgmgEREREQmhgkgERERkYlhAkhERERkYpgAEhEREZkYJoBEREREJoYJIBEREZGJYQJIREREZGKYABIRERGZGCaARERERCaGCSARERGRiWECSERERGRimAASVcLKlSshk8lw9OhRQ4dCZHR0cf80btwYI0eO1F1Q1ZApnCNVPSaAVO0V/ZIo+lhbW6N+/foICAjAV199hZycHL3H8PXXX2PlypV6Pw6RPjx+/zztEx8fb+hQa7yePXtK19vMzAwODg5o1qwZ3nrrLWzfvl1nx9m8eTNmzZqls/1RzVPL0AEQldXs2bPh6emJhw8fIj09HfHx8Zg0aRK+/PJLbNy4EX5+fno79tdff4169erxr3AySj/99JPW9x9//BHbt28vtrxFixZVGZbJatCgASIjIwEAubm5uHTpEn7//XesXr0ar7/+OlavXg0LCwup/IULF2BmVr76ms2bN2Pp0qVMAqlUTADJaPTv3x8dOnSQvoeFhWHXrl0YNGgQXnrpJZw7dw42NjYGjJCoehoxYoTW94MHD2L79u3FllPVkMvlxa59VFQUJkyYgK+//hqNGzfG/PnzpXVWVlZVHSKZAL4CJqPWu3dvzJgxA1evXsXq1aul5efPn8err74KR0dHWFtbo0OHDti4caPWtkWvlv/66y+89957cHJygoODA4KCgnD37l2pXOPGjXHmzBkkJCRIr2569uypta/8/Hx88MEHcHZ2hq2tLV5++WX8888/ej13Il3Kzc3Fhx9+CA8PD1hZWaFZs2b4/PPPIYSQyqSmpkImk5XYHEImkxWrbbp+/TpGjRqF+vXrw8rKCp6enggJCUFBQYFWubLcP0IIzJkzBw0aNEDt2rXRq1cvnDlzpsRzuXLlCl577TU4Ojqidu3aeOGFF/Dnn39q7atevXr44IMPpGUajQZ16tSBubk5MjMzpeXz589HrVq1cO/ePQDAyJEjYWdnh+vXr2PIkCGws7ODs7MzpkyZArVa/dRr/DTm5ub46quv4OPjgyVLliArK0ta92QbwIcPHyIiIgJNmzaFtbU1nJyc0LVrV+kV8siRI7F06VIA2q//i3z++efo3LkznJycYGNjg/bt2yM2NrZYTDKZDOPGjcP69evh6+sLKysrtGzZElu3bi1Wtiw/68zMTEyaNEn6P+bl5YX58+dDo9FU+LpRxbEGkIzeW2+9hY8//hjbtm3D6NGjcebMGXTp0gXu7u6YPn06bG1t8dtvv2HIkCH473//i5dffllr+3HjxqFOnTqYNWsWLly4gOjoaFy9ehXx8fGQyWRYuHAhxo8fDzs7O3zyyScAAFdXV619jB8/HnXr1kV4eDhSU1OxcOFCjBs3Dr/++muVXQeiihJC4KWXXsLu3bsxatQotGnTBnFxcZg6dSquX7+O//znP+Xe540bN9CxY0dkZmZizJgxaN68Oa5fv47Y2Fjcv38flpaWUtmy3D8zZ87EnDlzMGDAAAwYMADHjx/Hiy++WCyZvHnzJjp37oz79+9jwoQJcHJywqpVq/DSSy8hNjYWL7/8MmQyGbp06YK//vpL2u7UqVPIysqCmZkZ9u3bh4EDBwIA9uzZg7Zt28LOzk4qq1arERAQgE6dOuHzzz/Hjh078MUXX6BJkyYICQkp97UqYm5ujjfffBMzZszA3r17pRieNGvWLERGRuLdd99Fx44dkZ2djaNHj+L48ePw9/fHe++9hxs3bpT4mh8AFi1ahJdeegnDhw9HQUEBYmJi8Nprr+GPP/4odsy9e/fi999/x9ixY2Fvb4+vvvoKr7zyCtLS0uDk5ASgbD/r+/fvo0ePHrh+/Tree+89NGzYEPv370dYWBhUKhUWLlxY4etGFSSIqrkVK1YIAOLIkSOllpHL5aJt27ZCCCH69OkjWrVqJfLy8qT1Go1GdO7cWTRt2rTYftu3by8KCgqk5Z999pkAIDZs2CAta9mypejRo0epsfXt21doNBpp+eTJk4W5ubnIzMys0DkT6VNoaKh4/PG/fv16AUDMmTNHq9yrr74qZDKZuHTpkhBCiJSUFAFArFixotg+AYjw8HDpe1BQkDAzMyvxvi26V8p6/2RkZAhLS0sxcOBArXIff/yxACCCg4OlZZMmTRIAxJ49e6RlOTk5wtPTUzRu3Fio1WohhBALFiwQ5ubmIjs7WwghxFdffSUaNWokOnbsKKZNmyaEEEKtVos6deqIyZMnS/sKDg4WAMTs2bO1zqlt27aiffv2xc71ST169BAtW7Ysdf26desEALFo0SJpWaNGjbTOsXXr1mLgwIFPPc6TP+PH3b9/X+t7QUGB8PX1Fb1799ZaDkBYWlpKP38hhDh58qQAIBYvXiwtK8vP+tNPPxW2trYiOTlZa/306dOFubm5SEtLe+r5kO7xFTDVCHZ2dsjJycGdO3ewa9cuvP7668jJycGtW7dw69Yt3L59GwEBAbh48SKuX7+ute2YMWO0GlyHhISgVq1a2Lx5c5mPP2bMGK1XLN26dYNarcbVq1crf3JEerZ582aYm5tjwoQJWss//PBDCCGwZcuWcu1Po9Fg/fr1CAwM1Gq3W+TxewV49v2zY8cOFBQUYPz48VrlJk2aVOK5dOzYEV27dpWW2dnZYcyYMUhNTcXZs2e1jrF//34AhTV93bp1Q7du3bBnzx4AQFJSEjIzM9GtW7dix3n//fe1vnfr1g1Xrlx56nUpi6KaxqeNblCnTh2cOXMGFy9erNAxHm8rfffuXWRlZaFbt244fvx4sbJ9+/ZFkyZNpO9+fn5wcHCQzrWsP+u1a9eiW7duqFu3rvRcvnXrFvr27Qu1Wq1VG0tVgwmgjvz1118IDAxE/fr1IZPJsH79+nJtP2vWrBKHZbC1tdVPwDXMvXv3YG9vj0uXLkEIgRkzZsDZ2VnrEx4eDgDIyMjQ2rZp06Za3+3s7KBQKJCamlrm4zds2FDre926dQFAqy0h0ZOqy3Pj6tWrqF+/Puzt7bWWF/UKLu8fMv/88w+ys7Ph6+tbpvLPun+Kjv/kvers7CyVLXL16lU0a9as2DGePJd27dqhdu3aUrJXlAB2794dR48eRV5enrTu8WQSAKytreHs7FwsZl3c70VtDZ/8WTxu9uzZyMzMhLe3N1q1aoWpU6fi1KlTZT7GH3/8gRdeeAHW1tZwdHSEs7MzoqOjtdodFnnyZwNon2tZf9YXL17E1q1biz2X+/btC6D4c5n0j20AdSQ3NxetW7fGO++8g3/961/l3n7KlCnF/qLs06cPnn/+eV2FWGP9/fffyMrKgpeXl9SYeMqUKQgICCixvJeXl85jMDc3L3G5eKwBPdGTjO258WTNXZHKdH4ADHP/WFhYoFOnTvjrr79w6dIlpKeno1u3bnB1dcXDhw9x6NAh7NmzB82bNy+W7JUWry4kJSUBePpzqnv37rh8+TI2bNiAbdu24fvvv8d//vMfLFu2DO++++5T979nzx689NJL6N69O77++msoFApYWFhgxYoVWLNmTbHyuvrZaDQa+Pv746OPPipxvbe3d7n2R5XHBFBH+vfvj/79+5e6Pj8/H5988gl++eUXZGZmwtfXF/Pnz5d6k9rZ2Wk1Mj558iTOnj2LZcuW6Tt0o1fUyDkgIADPPfccgMKHe9Ffls9y8eJF9OrVS/p+7949qFQqDBgwQFpW2i8+osqoLs+NRo0aYceOHcjJydGqeTp//ry0HvhfzdzjvWSB4jWEzs7OcHBwkJKZyio6/sWLF6V7HCisfXqy1q1Ro0a4cOFCsX08eS5A4Wvb+fPnY8eOHahXrx6aN28OmUyGli1bYs+ePdizZw8GDRqkk3MoC7VajTVr1qB27drFah2f5OjoiLfffhtvv/027t27h+7du2PWrFlSAljaM+u///0vrK2tERcXpzW8zIoVKyoUc1l/1k2aNMG9e/fK/Fwm/eMr4Coybtw4HDhwADExMTh16hRee+019OvXr9Q2HN9//z28vb1LbHtC/7Nr1y58+umn8PT0xPDhw+Hi4oKePXvim2++gUqlKla+pKFZvv32Wzx8+FD6Hh0djUePHmn9Yra1tS32S49I36rquTFgwACo1WosWbJEa/l//vMfyGQy6V5wcHBAvXr1irXX+vrrr7W+m5mZYciQIdi0aVOJ07yVt/aob9++sLCwwOLFi7W2Lann6IABA3D48GEcOHBAWpabm4tvv/0WjRs3ho+Pj7S8W7duyM/Px8KFC9G1a1cpaerWrRt++ukn3Lhxo8qewWq1GhMmTMC5c+cwYcIEODg4lFr29u3bWt/t7Ozg5eWF/Px8aVlRM4Ann1vm5uaQyWRatbapqanlbn5QpKw/69dffx0HDhxAXFxcsTKZmZl49OhRhY5PFccawCqQlpaGFStWIC0tDfXr1wdQ+Opm69atWLFiBebNm6dVPi8vDz///DOmT59uiHCrrS1btuD8+fN49OgRbt68iV27dmH79u1o1KgRNm7cCGtrawDA0qVL0bVrV7Rq1QqjR4/Gc889h5s3b+LAgQP4+++/cfLkSa39FhQUoE+fPnj99ddx4cIFfP311+jatSteeuklqUz79u0RHR2NOXPmwMvLCy4uLujdu3eVnj+Zlqp8bgQGBqJXr1745JNPkJqaitatW2Pbtm3YsGEDJk2apNUJ4N1330VUVBTeffdddOjQAX/99ReSk5OL7XPevHnYtm0bevTogTFjxqBFixZQqVRYu3Yt9u7dizp16pQ5vqJx9iIjIzFo0CAMGDAAJ06cwJYtW1CvXj2tstOnT8cvv/yC/v37Y8KECXB0dMSqVauQkpKC//73v1ozaiiVStSqVQsXLlzAmDFjpOXdu3dHdHQ0AOglAczKypLGLb1//740E8jly5cxdOhQfPrpp0/d3sfHBz179kT79u3h6OiIo0ePIjY2FuPGjZPKtG/fHgAwYcIEBAQEwNzcHEOHDsXAgQPx5Zdfol+/fhg2bBgyMjKwdOlSeHl5lasd4ePK8rOeOnUqNm7ciEGDBmHkyJFo3749cnNzcfr0acTGxiI1NbXYz5L0zHAdkGsuAGLdunXS9z/++EMAELa2tlqfWrVqiddff73Y9mvWrBG1atUS6enpVRh19VU0VETRx9LSUri5uQl/f3+xaNEiaRiHx12+fFkEBQUJNzc3YWFhIdzd3cWgQYNEbGxssf0mJCSIMWPGiLp16wo7OzsxfPhwcfv2ba39paeni4EDBwp7e3sBQBoSprQhanbv3i0AiN27d+v8elDNVJXPjZKGCMnJyRGTJ08W9evXFxYWFqJp06ZiwYIFWsOuCFE4hMioUaOEXC4X9vb24vXXXxcZGRnFhoERQoirV6+KoKAg4ezsLKysrMRzzz0nQkNDRX5+vhCifPePWq0WERERQqFQCBsbG9GzZ0+RlJRUbIgUIQrv/1dffVXUqVNHWFtbi44dO4o//vijxGvx/PPPCwDi0KFD0rK///5bABAeHh7FygcHBwtbW9tiy8PDw0sdduVxPXr00Hqe2dnZiaZNm4oRI0aIbdu2lbjNk+c4Z84c0bFjR1GnTh1hY2MjmjdvLubOnas1nNWjR4/E+PHjhbOzs5DJZFqxLV++XDRt2lRYWVmJ5s2bixUrVpQYPwARGhr6zHiEePbPWojC/2NhYWHCy8tLWFpainr16onOnTuLzz//XCt2qhoyIdhKXddkMhnWrVuHIUOGAAB+/fVXDB8+HGfOnCnWoNbOzg5ubm5ay/r06QMHBwesW7euqkI2SStXrsTbb7+NI0eOlDh8AVFV4nODiKoSXwFXgbZt20KtViMjI+OZrxNSUlKwe/fuYtOWEZFp4XODiPSJCaCO3Lt3D5cuXZK+p6SkIDExEY6OjvD29sbw4cMRFBSEL774Am3btsU///yDnTt3ws/PT2vqnR9++AEKheKpPQOJqGbgc4OIDMbQ76BriqI2K09+itpJFBQUiJkzZ4rGjRsLCwsLoVAoxMsvvyxOnTol7UOtVosGDRqIjz/+2EBnYVrKMsUckT7xuUFEhsI2gEREREQmhuMAEhEREZkYJoBEREREJoYJIBEREZGJYS/gStBoNLhx4wbs7e05VyyRAQghkJOTg/r162vN8FDd8dlBZFjG+uzQJSaAlXDjxg14eHgYOgwik3ft2jU0aNDA0GGUGZ8dRNWDsT07dIkJYCXY29sDKPwP9LSJu4lIP7Kzs+Hh4SHdi8aCzw4iwzLWZ4cuMQGshKJXNw4ODnyIE+mIWiNwOOUOMnLy4GJvjY6ejjA3e/prUmN7jVqWZ0dFrgMRlY+xPTt0iQkgEVUbW5NUiNh0FqqsPGmZQm6N8EAf9PNVGDCyqsXrQET6ZpotH4mo2tmapELI6uNaSQ8ApGflIWT1cWxNUhkosqrF60BEVYEJIBEZnFojELHpLEqalqhoWcSms1BravbERbwORFRVmAASkcEdTrlTrMbrcQKAKisPh1PuVF1QBsDrQERVhQkgERlcRk7pSU9FyhkrXgciqipMAInI4FzsrXVazljxOhBRVWECSEQG19HTEQq5NUobkEGGwl6wHT0dqzKsKsfrQERVhQkgERmcuZkM4YE+AFAs+Sn6Hh7oU+PHweN1IKKqwgSQiKqFfr4KRI9oBze59utNN7k1oke0M5nx73gdiKgqcCBoIqo2+vkq4O/jZvIzYPA6EJG+MQEkomrF3EwGZRMnQ4dhcLwORKRPfAVMREREZGKYABIRERGZGCaARERERCaGCSAR1UjR0dHw8/ODg4MDHBwcoFQqsWXLllLL9+zZEzKZrNhn4MCBUhkhBGbOnAmFQgEbGxv07dsXFy9erIrTISLSKSaARFQpao3Agcu3sSHxOg5cvg21Rhg6JABAgwYNEBUVhWPHjuHo0aPo3bs3Bg8ejDNnzpRY/vfff4dKpZI+SUlJMDc3x2uvvSaV+eyzz/DVV19h2bJlOHToEGxtbREQEIC8PE7NRkTGhb2AiajCtiapELHpLFRZ/0uAFHJrhAf6GHy8usDAQK3vc+fORXR0NA4ePIiWLVsWK+/oqD27RkxMDGrXri0lgEIILFy4EP/+978xePBgAMCPP/4IV1dXrF+/HkOHDtXTmRAR6R5rAImoQrYmqRCy+rhW8gcA6Vl5CFl9HFuTVAaKrDi1Wo2YmBjk5uZCqVSWaZvly5dj6NChsLW1BQCkpKQgPT0dffv2lcrI5XJ06tQJBw4c0EvcRET6whpAIio3tUYgYtNZlPSyV6Bw2rKITWfh7+Nm0MGLT58+DaVSiby8PNjZ2WHdunXw8fF55naHDx9GUlISli9fLi1LT08HALi6umqVdXV1ldaVJj8/H/n5+dL37Ozs8pwGEZHOsQaQiMrtcMqdYjV/jxMAVFl5OJxyp+qCKkGzZs2QmJiIQ4cOISQkBMHBwTh79uwzt1u+fDlatWqFjh076iSOyMhIyOVy6ePh4aGT/RIRVRQTQCIqt4ycsnV6KGs5fbG0tISXlxfat2+PyMhItG7dGosWLXrqNrm5uYiJicGoUaO0lru5uQEAbt68qbX85s2b0rrShIWFISsrS/pcu3atAmdDRKQ7TACJqNxc7K11Wq6qaDQarVexJVm7di3y8/MxYsQIreWenp5wc3PDzp07pWXZ2dk4dOjQM9sVWllZScPRFH2IiAyJbQCJqNw6ejpCIbdGelZeie0AZQDc5Nbo6OlYwtqqERYWhv79+6Nhw4bIycnBmjVrEB8fj7i4OABAUFAQ3N3dERkZqbXd8uXLMWTIEDg5ac/DK5PJMGnSJMyZMwdNmzaFp6cnZsyYgfr162PIkCFVdVpERDrBBJCIys3cTIbwQB+ErD4OGaCVBBZ1+QgP9DFoB5CMjAwEBQVBpVJBLpfDz88PcXFx8Pf3BwCkpaXBzEz7JciFCxewd+9ebNu2rcR9fvTRR8jNzcWYMWOQmZmJrl27YuvWrbC2rl41nUREzyITQlSPUVuNUHZ2NuRyObKysvhKh0ySoccBNNZ70FjjJqopeA+yBpCIKqGfrwL+Pm44nHIHGTl5cLEvfO1ryJo/IiJ6NiaARFQp5mYyKJs4PbsgERFVG+wFTERERGRimAASERERmRgmgEREREQmxigSwOjoaPj5+UkDqCqVSmzZsqXU8j179oRMJiv2GThwoFRm5MiRxdb369evKk6HyGDUGoEDl29jQ+J1HLh8G2oNBwEgIjJFRtEJpEGDBoiKikLTpk0hhMCqVaswePBgnDhxAi1btixW/vfff0dBQYH0/fbt22jdujVee+01rXL9+vXDihUrpO9WVlb6OwkiAzP0kC1ERFR9GEUCGBgYqPV97ty5iI6OxsGDB0tMAB0dtWcfiImJQe3atYslgFZWVs+cw5OoJtiapELI6uPFZu1Iz8pDyOrjiB7RjkkgEZEJMYpXwI9Tq9WIiYlBbm7uM+ffLLJ8+XIMHToUtra2Wsvj4+Ph4uKCZs2aISQkBLdv337qfvLz85Gdna31Iaru1BqBiE1nS5yyrWhZxKazfB1MRGRCjCYBPH36NOzs7GBlZYX3338f69atg4+PzzO3O3z4MJKSkvDuu+9qLe/Xrx9+/PFH7Ny5E/Pnz0dCQgL69+8PtVpd6r4iIyMhl8ulj4eHR6XPi0jfDqfc0Xrt+yQBQJWVh8Mpd6ouKCIiMiijeAUMAM2aNUNiYiKysrIQGxuL4OBgJCQkPDMJXL58OVq1aoWOHTtqLR86dKj071atWsHPzw9NmjRBfHw8+vTpU+K+wsLC8MEHH0jfs7OzmQRStZeRU3ryV5FyRERk/IymBtDS0hJeXl5o3749IiMj0bp1ayxatOip2+Tm5iImJgajRo165v6fe+451KtXD5cuXSq1jJWVldQTuehDVN252FvrtBwRERk/o0kAn6TRaJCfn//UMmvXrkV+fj5GjBjxzP39/fffuH37NhQKNoSnmqWjpyMUcmuUNjuvDIW9gTt6OpZSgoiIahqjSADDwsLw119/ITU1FadPn0ZYWBji4+MxfPhwAEBQUBDCwsKKbbd8+XIMGTIETk7a85Teu3cPU6dOxcGDB5GamoqdO3di8ODB8PLyQkBAQJWcE1FVMTeTITywsKnEk0lg0ffwQB+Ym5WWIhIRUU1jFG0AMzIyEBQUBJVKBblcDj8/P8TFxcHf3x8AkJaWBjMz7Vz2woUL2Lt3L7Zt21Zsf+bm5jh16hRWrVqFzMxM1K9fHy+++CI+/fRTjgVINVI/XwWiR7QrNg6gG8cBJCIySTIhBMd+qKDs7GzI5XJkZWWxPSAZBbVG4HDKHWTk5MHFvvC1rzHX/BnrPWiscRPVFLwHjaQGkIh0w9xMBmUTp2cXJCKiGs0o2gASERERke6wBpCIyMTUtKYARFR+TACJiEzI1iRVsc5ACnYGIjI5fAVMVI2pNQIHLt/GhsTrOHD5NufrpUrZmqRCyOrjxaYGTM/KQ8jq49iapDJQZERU1VgDSFRNsaaGdEmtEYjYdBYl/QkhUDgmZMSms/D3cePrYCITwBpAomqINTWka4dT7hT7//Q4AUCVlYfDKXeqLigiMhgmgETVzLNqaoDCmhq+DqbyyMgpPfmrSDkiMm5MAImqGdbUkD642FvrtBwRGTcmgETVDGtqSB86ejpCIbcuNh90ERkK25h29HSsyrCIyECYABJVM6ypIX0wN5MhPNAHAIolgUXfwwN92AGEyEQwASSqZlhTQ/rSz1eB6BHt4CbX/uPBTW6N6BHt2LucyIRwGBiiaqaopiZk9XHIAK3OIKypocrq56uAv48bZwIhMnFMAImqoaKamifHAXTjOICkA+ZmMiibOBk6DCIyIL0kgJmZmVi3bh327NmDq1ev4v79+3B2dkbbtm0REBCAzp076+OwRDWKqdXU8LlBRFR1dNoG8MaNG3j33XehUCgwZ84cPHjwAG3atEGfPn3QoEED7N69G/7+/vDx8cGvv/6qy0MT1UhFNTWD27hD2cSpRiZ/fG4QEVU9ndYAtm3bFsHBwTh27Bh8fHxKLPPgwQOsX78eCxcuxLVr1zBlyhRdhkBERobPDSKiqicTQuhsOoHbt2/Dyans7UrKW766yc7OhlwuR1ZWFhwcHAwdDpFRqsxzw1jvQWONm6im4D2o41fA5U3mjDn5IyLd0NdzIzo6Gn5+fnBwcICDgwOUSiW2bNny1G0yMzMRGhoKhUIBKysreHt7Y/PmzdJ6tVqNGTNmwNPTEzY2NmjSpAk+/fRT6PDvaCKiKlFlvYDPnTuHgwcPom3btmjTpk1VHZaoyqg1wmQ6bFSVyjw3GjRogKioKDRt2hRCCKxatQqDBw/GiRMn0LJly2LlCwoK4O/vDxcXF8TGxsLd3R1Xr15FnTp1pDLz589HdHQ0Vq1ahZYtW+Lo0aN4++23IZfLMWHChEqeLRFR1dFLAjh79mzY2Nhg6tSpAIDdu3ejX79+sLe3R1ZWFlauXInhw4fr49BEBrE1SVVsyBYFh2wpF10/NwIDA7W+z507F9HR0Th48GCJCeAPP/yAO3fuYP/+/bCwsAAANG7cWKvM/v37MXjwYAwcOFBa/8svv+Dw4cPlOVUiIoPTy0wgsbGxWo25586diwkTJuDWrVtYsmQJ5s2bp4/DEhnE1iQVQlYf10r+ACA9Kw8hq49ja5LKQJEZF30+N9RqNWJiYpCbmwulUllimY0bN0KpVCI0NBSurq7w9fXFvHnzoFarpTKdO3fGzp07kZycDAA4efIk9u7di/79+1c4NiIiQ9BpDeCPP/4IIQRSU1ORmJiI27dvQwiBffv2oVu3bvjxxx+h0Whw5coV/PjjjwCAoKAgXYZAVKXUGoGITWdRUgswgcKZOyI2nYW/jxtfB5dCn8+N06dPQ6lUIi8vD3Z2dli3bl2pPY2vXLmCXbt2Yfjw4di8eTMuXbqEsWPH4uHDhwgPDwcATJ8+HdnZ2WjevDnMzc2hVqsxd+7cZ9ZM5ufnIz8/X/qenZ1dpviJiPRFpwlgo0aNAACWlpZwdXVFo0aNkJiYCAcHB/Tq1QtCCOTn50Mmk6Fx48ZsOE1G73DKnWI1f48TAFRZeTiccoczL5RCn8+NZs2aITExEVlZWYiNjUVwcDASEhJKTAI1Gg1cXFzw7bffwtzcHO3bt8f169exYMECKQH87bff8PPPP2PNmjVo2bIlEhMTMWnSJNSvXx/BwcGlxhEZGYmIiIhyXhkiIv3RaQLYo0cPAEC7du3wxx9/YNq0adi6dSsGDBiA7t27Ayj8i9zDw0P6TmTMMnJKT/4qUs4U6fO5YWlpCS8vLwBA+/btceTIESxatAjffPNNsbIKhQIWFhYwNzeXlrVo0QLp6ekoKCiApaUlpk6diunTp2Po0KEAgFatWuHq1auIjIx8agIYFhaGDz74QPqenZ0NDw+Pcp0LEZEu6aUN4IIFC5CYmIguXbrg6tWrmD17trRu5cqV6Nevnz4OS1TlXOytdVrOlFXFc0Oj0Wi9in1cly5dcOnSJWg0GmlZcnIyFAoFLC0tAQD379+HmZn2Y9Pc3Fxrm5JYWVlJw9EUfYiIDEkvvYBbt26N1NTUEgd4nTJlCh9+VGN09HSEQm6N9Ky8EtsBygC4yQuHhKGn0/VzIywsDP3790fDhg2Rk5ODNWvWID4+HnFxcQAK2xG6u7sjMjISABASEoIlS5Zg4sSJGD9+PC5evIh58+ZpDe8SGBiIuXPnomHDhmjZsiVOnDiBL7/8Eu+8804lz56IqGrpdRzAkgZsVSg4JAbVHOZmMoQH+iBk9XHIAK0ksKjLR3igDzuAlIOunhsZGRkICgqCSqWCXC6Hn58f4uLi4O/vDwBIS0vTqs3z8PBAXFwcJk+eDD8/P7i7u2PixImYNm2aVGbx4sWYMWMGxo4di4yMDNSvXx/vvfceZs6cWYEzJSIyHJ1OBRcTEyO1jXmWa9euIS0tDV26dNHV4ascp5KhIhwHsOIq89ww1nvQWOMmqil4D+q4DWB0dDRatGiBzz77DOfOnSu2PisrC5s3b8awYcPQrl073L59W5eHJzKYfr4K7J3WG7+MfgGLhrbBL6NfwN5pvZn8lQGfG0REVU+nr4ATEhKwceNGLF68GGFhYbC1tYWrqyusra1x9+5dpKeno169ehg5ciSSkpLg6uqqy8MTGZS5mYxDvVQAnxtERFVPp6+AH3fr1i3s3bsXV69exYMHD1CvXj20bdsWbdu2LdaLzlixCplIt8r73DDWe9BY4yaqKXgP6rETSL169TBkyBB97Z6IaiA+N4iIqoZeewETEZHpUGsEDqfcQUZOHlzsC4c/Yg94ouqJCSAREVUae8ITGZea0RiPqALUGoEDl29jQ+J1HLh8G2oN56YmqoitSSqErD5ebF7s9Kw8hKw+jq1JKgNFRkSlYQ0gmSTWVhDphlojELHpbIkz4QgUDogeseks/H3c+DqYqBrRWw3g7Nmzcf/+/WLLHzx4oDXHJ1FVY21F9cXnhvE5nHKn2L30OAFAlZWHwyl3qi4oInomvSWAERERuHfvXrHl9+/fR0REhL4OS/RUz6qtAAprK/g62DD43DA+GTmlJ38VKUdEVUNvCaAQAjJZ8er+kydPwtHRUV+HJXoq1lZUb3xuGB8Xe2udliOiqqHzNoB169aFTCaDTCaDt7e31sNcrVbj3r17eP/993V9WKIyYW1F9cTnhvHq6OkIhdwa6Vl5JdasywC4yQuHhCGi6kPnCeDChQshhMA777yDiIgIyOVyaZ2lpSUaN24MpVKp68MSlQlrK6onPjeMl7mZDOGBPghZfRwyQCsJLErjwwN92AGEqJrReQIYHBwMAPD09ESXLl1Qq1blDxEdHY3o6GikpqYCAFq2bImZM2eif//+JZbv2bMnEhISii0fMGAA/vzzTwCFr5rCw8Px3XffITMzE126dEF0dDSaNm1a6Xip+mJtRfWkj+cGVZ1+vgpEj2hXrGe9G3vWE1VbemsDaG9vj3PnzknfN2zYgCFDhuDjjz9GQUFBufbVoEEDREVF4dixYzh69Ch69+6NwYMH48yZMyWW//3336FSqaRPUlISzM3N8dprr0llPvvsM3z11VdYtmwZDh06BFtbWwQEBCAvj6/+arKi2grgf7UTRVhbYXi6fG5Q1ernq8Deab3xy+gXsGhoG/wy+gXsndabyR9RNaW3BPC9995DcnIyAODKlSt44403ULt2baxduxYfffRRufYVGBiIAQMGoGnTpvD29sbcuXNhZ2eHgwcPllje0dERbm5u0mf79u2oXbu2lAAKIbBw4UL8+9//xuDBg+Hn54cff/wRN27cwPr16yt13lT9FdVWuMm1X/O6ya0RPaIdf2EZkC6fG1T1zM1kUDZxwuA27lA2ceIfUkTVmN7esyQnJ6NNmzYAgLVr16JHjx5Ys2YN9u3bh6FDh2LhwoUV2q9arcbatWuRm5tb5jZBy5cvx9ChQ2FrawsASElJQXp6Ovr27SuVkcvl6NSpEw4cOIChQ4eWuJ/8/Hzk5+dL37Ozsyt0DmR4/XwV8Pdx47yl1Yy+nhtERKRNbwmgEAIajQYAsGPHDgwaNAgA4OHhgVu3bpV7f6dPn4ZSqUReXh7s7Oywbt06+Pj4PHO7w4cPIykpCcuXL5eWpaenAwBcXV21yrq6ukrrShIZGcmxyGqQotoKqj50/dwgIqKS6e0VcIcOHTBnzhz89NNPSEhIwMCBAwEU1r49mXiVRbNmzZCYmIhDhw4hJCQEwcHBOHv27DO3W758OVq1aoWOHTuW+5hPCgsLQ1ZWlvS5du1apfdJRP+j6+cGERGVTG8J4MKFC3H8+HGMGzcOn3zyCby8vAAAsbGx6Ny5c7n3Z2lpCS8vL7Rv3x6RkZFo3bo1Fi1a9NRtcnNzERMTg1GjRmktd3NzAwDcvHlTa/nNmzeldSWxsrKCg4OD1oeIdEfXzw0iIiqZ3l4B+/n54fTp08WWL1iwAObm5pXev0aj0WqPV5K1a9ciPz8fI0aM0Fru6ekJNzc37Ny5U2pvlJ2dLdUuEpFh6Pu5QUREhfQ+2NaxY8ekYR18fHzQrl27cu8jLCwM/fv3R8OGDZGTk4M1a9YgPj4ecXFxAICgoCC4u7sjMjJSa7vly5djyJAhcHLSbuclk8kwadIkzJkzB02bNoWnpydmzJiB+vXrY8iQIRU7UdIrtUaww4YJ0cVzg4iISqe3BDAjIwNvvPEGEhISUKdOHQBAZmYmevXqhZiYGDg7O5drX0FBQVCpVJDL5fDz80NcXBz8/f0BAGlpaTAz036bfeHCBezduxfbtm0rcZ8fffQRcnNzMWbMGGRmZqJr167YunUrrK05A0R1szVJVWyAWQUHmK2RdPncICKi0smEECVNiFBpb7zxBq5cuYIff/wRLVq0AACcPXsWwcHB8PLywi+//KKPw1ap7OxsyOVyZGVlsT2gnmxNUiFk9fFis3YU1f1x3L6apbzPDWO9B401bqKagvegHhNAuVyOHTt24Pnnn9dafvjwYbz44ovIzMzUx2GrFP8D6ZdaI9B1/i6tmr/HFU3btndab74OriHK+9ww1nvQWOMmqil4D+qxF7BGo4GFhUWx5RYWFtI4X0RPczjlTqnJH1A46bwqKw+HU+5UXVCkV3xuEBFVDb0lgL1798bEiRNx48YNadn169cxefJk9OnTR1+HpRokI6ds8zKXtRxVf3xuEBFVDb0lgEuWLEF2djYaN26MJk2aoEmTJvD09ER2djYWL16sr8NSDeJiX7YOOWUtR9UfnxtUGrVG4MDl29iQeB0HLt+GWqOX1ktEJkNvvYA9PDxw/Phx7NixA+fPnwcAtGjRQmv+XaKn6ejpCIXcGulZecU6gQD/awPY0dOxqkMjPeFzg0rCkQCIdE9vnUBMARuR6l9RL2AAWkkgewETYLz3oLHGbQgcCYD0gfegHl4B79q1Cz4+PsjOzi62LisrCy1btsSePXt0fViqofr5KhA9oh3c5Nqved3k1nzw1yB8blBJ1BqBiE1nS3wDULQsYtNZvg4mqgCdvwJeuHAhRo8eXWJGLZfL8d577+HLL79Et27ddH1oqqH6+Srg7+PGmUBqMD43qCTlGQlA2cSp1HJEVJzOawBPnjyJfv36lbr+xRdfxLFjx3R9WKrhzM1kUDZxwuA27lA2cWLyV8PwuUEl4UgARPqj8wTw5s2bJY7jVaRWrVr4559/dH1YIjJifG5QSTgSAJH+6DwBdHd3R1JSUqnrT506BYWC7baI6H/08dyIjo6Gn58fHBwc4ODgAKVSiS1btjx1m8zMTISGhkKhUMDKygre3t7YvHmzVpnr169jxIgRcHJygo2NDVq1aoWjR4+WKzYqm6KRAEqr75ehsDcwRwIgKj+dJ4ADBgzAjBkzkJdXvEr+wYMHCA8Px6BBg3R9WCIyYvp4bjRo0ABRUVE4duwYjh49it69e2Pw4ME4c+ZMieULCgrg7++P1NRUxMbG4sKFC/juu+/g7u4ulbl79y66dOkCCwsLbNmyBWfPnsUXX3yBunXrlu+EqUzMzWQID/QBgGJJYNH38EAfNgkhqgCdDwNz8+ZNtGvXDubm5hg3bhyaNWsGADh//jyWLl0KtVqN48ePw9XVVZeHNQh2Iy+dWiPYaYPKrKLPjfLeg46OjliwYAFGjRpVbN2yZcuwYMECnD9/vtTX0dOnT8e+ffsq3SOZz47y4TiApGu8B/U0DuDVq1cREhKCuLg4FO1eJpMhICAAS5cuhaenp64PaRD8D1QyPqypIiry3CjrPahWq7F27VoEBwfjxIkT8PHxKVZmwIABcHR0RO3atbFhwwY4Oztj2LBhmDZtGszNzQEAPj4+CAgIwN9//42EhAS4u7tj7NixGD169FPPLT8/H/n5+Vpxe3h48NlRDvyjknSJv7/1PBD03bt3cenSJQgh0LRp0xr3moT/gYrjoK1UWeV5bjzrHjx9+jSUSiXy8vJgZ2eHNWvWYMCAASXuq3nz5khNTcXw4cMxduxYXLp0CWPHjsWECRMQHh4OALC2Luxs8MEHH+C1117DkSNHMHHiRCxbtgzBwcGlxjlr1ixEREQUW85nB5Fh8Pc3ZwKpFP4H0qbWCHSdv6vUcbuKpm7bO603/3InnXjWPVhQUIC0tDRkZWUhNjYW33//PRISEkqsAfT29kZeXh5SUlKkGr8vv/wSCxYsgEqlAgBYWlqiQ4cO2L9/v7TdhAkTcOTIERw4cKDUOFkDSFS98Pe3HjqBkOkqz6CtRFXB0tISXl5eaN++PSIjI9G6dWssWrSoxLIKhQLe3t5S8gcUzkOcnp6OgoICqcyTyWOLFi2Qlpb21DisrKyk3shFHyIiQ2ICSDrDQVuputNoNFo1cY/r0qULLl26BI1GIy1LTk6GQqGApaWlVObChQta2yUnJ6NRo0b6C5qISA+YAJLOcNBWqk7CwsLw119/ITU1FadPn0ZYWBji4+MxfPhwAEBQUBDCwsKk8iEhIbhz5w4mTpyI5ORk/Pnnn5g3bx5CQ0OlMpMnT8bBgwcxb948XLp0CWvWrMG3336rVYaIyBjofC5gMl1Fg7amZ+WVOHl7URtADtpKVSEjIwNBQUFQqVSQy+Xw8/NDXFwc/P39AQBpaWkwM/vf38AeHh6Ii4vD5MmT4efnB3d3d0ycOBHTpk2Tyjz//PNYt24dwsLCMHv2bHh6emLhwoVSUknGiT2MyRSxE0glsBFpcUW9gAFoJYHsBUz6YKz3oLHGXRNx2CrTxHuQr4BJx/r5KhA9oh3c5Nqved3k1kz+iKhaKfqD9cnOa+lZeQhZfRxbk1QGioxI//gKmHSun68C/j5ufKVCRNWWWiMQselsic1VBArfWkRsOgt/Hzc+u6hGYgJIemFuJoOyiZOhwyAiKlF5hq3is4xqIr4CJiIik8Nhq8jUMQEkIiKTw2GryNQxASQiIpNTNGxVaa37ZCjsDcxhq6imYgJIUGsEDly+jQ2J13Hg8m2oNRwZiIhqNnMzGcIDC6f1ezIJLPoeHujDDiBUY7ETiInjGFhEZKqKhq168hnoxmcgmQAmgCasaAysJ+v7isbA4rh9RFTTcdgqMlVMAE0Ux8AiIirEYavIFLENoIkqzxhYRERUMWxjTdUVawBNFMfAIiLSL7axpuqMNYAmimNgERHpD+cZpuqOCaCJ4hhYRET68aw21kBhG2u+DiZDYgJoojgGFhGRfrCNNRkDJoAmrGgMLDe59mteN7k1h4AhIqogtrEmY8BOICaOY2AREekW21iTMWACSBwDi4hIh4raWKdn5ZXYDlCGwjctbGNNhsRXwERERDrENtZkDJgAEhER6RjbWFN1x1fAREREeqDPNtZqjWDbbaoUo6gBjI6Ohp+fHxwcHODg4AClUoktW7Y8dZvMzEyEhoZCoVDAysoK3t7e2Lx5s7R+1qxZkMlkWp/mzZvr+1SIiMiEFLWxHtzGHcomTjpJ0rYmqdB1/i68+d1BTIxJxJvfHUTX+bs4uDSVi1HUADZo0ABRUVFo2rQphBBYtWoVBg8ejBMnTqBly5bFyhcUFMDf3x8uLi6IjY2Fu7s7rl69ijp16miVa9myJXbs2CF9r1XLKC4H//IjIjJRRTOMPNm5pGiGEb5eprIyiownMDBQ6/vcuXMRHR2NgwcPlpgA/vDDD7hz5w72798PCwsLAEDjxo2LlatVqxbc3Nz0ErO+cG5JIiLT9KwZRmQonGHE38eNlQL0TEbxCvhxarUaMTExyM3NhVKpLLHMxo0boVQqERoaCldXV/j6+mLevHlQq9Va5S5evIj69evjueeew/Dhw5GWllYVp1BhnFuSiMh0cYYR0iWjqAEEgNOnT0OpVCIvLw92dnZYt24dfHx8Six75coV7Nq1C8OHD8fmzZtx6dIljB07Fg8fPkR4eDgAoFOnTli5ciWaNWsGlUqFiIgIdOvWDUlJSbC3ty9xv/n5+cjPz5e+Z2dn6/5ES8G//IiITBtnGCFdMpoEsFmzZkhMTERWVhZiY2MRHByMhISEEpNAjUYDFxcXfPvttzA3N0f79u1x/fp1LFiwQEoA+/fvL5X38/NDp06d0KhRI/z2228YNWpUiTFERkYiIiJCPyf4DOX5y4+DOhMR1TycYYR0yWheAVtaWsLLywvt27dHZGQkWrdujUWLFpVYVqFQwNvbG+bm5tKyFi1aID09HQUFBSVuU6dOHXh7e+PSpUulxhAWFoasrCzpc+3atcqdVDnwLz8iItNWNMNIae94ZChsE17ZGUbUGoEDl29jQ+J1HLh8G2pNSe+eyNgZTQ3gkzQajdbr2Md16dIFa9asgUajgZlZYY6bnJwMhUIBS0vLEre5d+8eLl++jLfeeqvUY1pZWcHKyqrywVcA//IjIjJtRTOMhKw+Dhmg1SRIVzOMsKOh6TCKGsCwsDD89ddfSE1NxenTpxEWFob4+HgMHz4cABAUFISwsDCpfEhICO7cuYOJEyciOTkZf/75J+bNm4fQ0FCpzJQpU5CQkIDU1FTs378fL7/8MszNzfHmm29W+fmVRVX95UdERNWXPmcYYUdD02IUNYAZGRkICgqCSqWCXC6Hn58f4uLi4O/vDwBIS0uTavoAwMPDA3FxcZg8eTL8/Pzg7u6OiRMnYtq0aVKZv//+G2+++SZu374NZ2dndO3aFQcPHoSzs3OVn19ZVMVffkREVP3pY4YRdjQ0PTIhBF/uV1B2djbkcjmysrLg4OBQJcdk9TzR/xjiHtQFY42baq4Dl2/jze8OPrPcL6NfqBEdDXkPGkkNIP2PPueWJCIi01RVHQ05k1X1wQTQCBXNLUlERKQLVdHRkG+wqhej6ARCRFRe0dHR8PPzg4ODAxwcHKBUKrFly5anbpOZmYnQ0FAoFApYWVnB29sbmzdvLrFsVFQUZDIZJk2apIfoiaqWvjsasoNJ9cMEkIhqpAYNGiAqKgrHjh3D0aNH0bt3bwwePBhnzpwpsXxBQQH8/f2RmpqK2NhYXLhwAd999x3c3d2LlT1y5Ai++eYb+Pn56fs0iKpEUUdDAMWSwMp2NHxWBxOgsIMJxxusWkwAiahGCgwMxIABA9C0aVN4e3tj7ty5sLOzw8GDJTd0/+GHH3Dnzh2sX78eXbp0QePGjdGjRw+0bt1aq9y9e/cwfPhwfPfdd6hbt25VnApRldDXEDOcw7h6YhtAPWODVyLDU6vVWLt2LXJzc6FUKksss3HjRiiVSoSGhmLDhg1wdnbGsGHDMG3aNK1ZhUJDQzFw4ED07dsXc+bMKdPxDTmPOFF56KOjITuYVE9MAPWIDV6JDOv06dNQKpXIy8uDnZ0d1q1bV+L84QBw5coV7Nq1C8OHD8fmzZtx6dIljB07Fg8fPpTmEI+JicHx48dx5MiRcsVhyHnEicpL1x0N2cGkeuIrYD1hg1ciw2vWrBkSExNx6NAhhISEIDg4GGfPni2xrEajgYuLC7799lu0b98eb7zxBj755BMsW7YMAHDt2jVMnDgRP//8M6yty/eLypDziBMZGjuYVE9MAPWADV6JqgdLS0t4eXmhffv2iIyMROvWrbFo0aISyyoUCnh7e2u97m3RogXS09NRUFCAY8eOISMjA+3atUOtWrVQq1YtJCQk4KuvvkKtWrWgVqtLjcPKykrqjVz0ITIV7GBSPTEB1AM2eCWqnjQajVZbvMd16dIFly5dgkajkZYlJydDoVDA0tISffr0wenTp5GYmCh9OnTogOHDhyMxMVErcSQibexgUv2wDaAeVFWDVyIqXVhYGPr374+GDRsiJycHa9asQXx8POLi4gAAQUFBcHd3R2RkJAAgJCQES5YswcSJEzF+/HhcvHgR8+bNw4QJEwAA9vb28PX11TqGra0tnJycii0nouKMuYNJTcQEUA+qosErET1dRkYGgoKCoFKpIJfL4efnh7i4OPj7+wMA0tLSYGb2v5cgHh4eiIuLw+TJk+Hn5wd3d3dMnDgR06ZNM9QpENU4xtjBpKZiAqgHRQ1e07PySmyXIENhtXdFG7wS0bMtX778qevj4+OLLVMqlaWOE1jWfRBR1eHv24pjG0A90GeDVyIiIirE37cVxwRQT/TV4JWIiIj+h79vK4avgPVIHw1eiYiISBt/35YfE0A903WDVyIiIiqOv2/LhwlgJQhR2OSU83oSGUbRvVd0LxoLPjuIDMtYnx26xASwEnJycgAUDh9BRIaTk5MDuVxu6DDKjM8OourB2J4duiQTppz+VpJGo8GNGzdgb28PmYztDJ6UnZ0NDw8PXLt2jVNfVQKvY+mEEMjJyUH9+vW1xvSr7sr67DDGn70xxgwYZ9zGGDNQPeI21meHLrEGsBLMzMzQoEEDQ4dR7XHuU93gdSyZMf71Xt5nhzH+7I0xZsA44zbGmAHDx22Mzw5dMs20l4iIiMiEMQEkIiIiMjFMAElvrKysEB4eDisrK0OHYtR4HU2XMf7sjTFmwDjjNsaYAeONu6ZhJxAiIiIiE8MaQCIiIiITwwSQiIiIyMQwASQiIiIyMUwAqVIiIyPx/PPPw97eHi4uLhgyZAguXLigVSYvLw+hoaFwcnKCnZ0dXnnlFdy8edNAERuHqKgoyGQyTJo0SVrG62hali5disaNG8Pa2hqdOnXC4cOHDR2Slppw7xvTfXb9+nWMGDECTk5OsLGxQatWrXD06FFpvRACM2fOhEKhgI2NDfr27YuLFy8aLF61Wo0ZM2bA09MTNjY2aNKkCT799FOtqdeqW8wmRxBVUKNGjUT9+vXFihUrRFJSkkhMTBQDBgwQDRs2FPfu3ZPKvf/++8LDw0Ps3LlTHD16VLzwwguic+fOlTp2eHi4qKn/fQ8fPiwaN24s/Pz8xMSJE6XlZb2OwcHBwtbWtgojJl2LiYkRlpaW4ocffhBnzpwRo0ePFnXq1BE3b940dGiSgIAAg9z7ulLZ+6wq3blzRzRq1EiMHDlSHDp0SFy5ckXExcWJS5cuSWWioqKEXC4X69evFydPnhQvvfSS8PT0FA8ePDBIzHPnzhVOTk7ijz/+ECkpKWLt2rXCzs5OLFq0qNrGbGpq5m9QqpQVK1YIACV+pk2bJpVr1KiRCA4O1to2IyNDABAJCQlCCCEyMzOFhYWFWLt2rVTm3LlzAoA4cODAU+PIzc0V4eHhYvfu3cXWGTIBDA4O1romtra2wtPTU7zyyisiNjZWqNXqCu87JydHNG3aVGzfvl306NFD+sX05HXMzc0VoaGhJV5HJoDGr2PHjiI0NFT6rlarRf369UVkZKQBo3o6Xd77+lbW+0yI6hHztGnTRNeuXUtdr9FohJubm1iwYIG0LDMzU1hZWYlffvmlKkIsZuDAgeKdd97RWvavf/1LDB8+XAhRPWM2NXwFTKWaPXs2fvrpJ63P0KFDn7pNVlYWAMDR0REAcOzYMTx8+BB9+/aVyjRv3hwNGzbEgQMHnrqv+/fvIyIiAvHx8cXW/fvf/8aDBw/KeUa6Y2VlJV2T//znPxg2bBguXryIV199FX369EF2dnaF9hsaGoqBAwdqXS+g+HW8f/8+li5dCgcHh2deRzIuBQUFOHbsmNb/ATMzM/Tt27da/6x1ee/rW1nvM6B6xLxx40Z06NABr732GlxcXNC2bVt899130vqUlBSkp6drxS2Xy9GpUyeDxd25c2fs3LkTycnJAICTJ09i79696N+/f7WN2dRwLmAqVf/+/dGhQ4cyl9doNJg0aRK6dOkCX19fAEB6ejosLS1Rp04drbKurq5IT0+vcGy1atVCrVqG++9bq1YtjBgxQmvZnDlzEBUVhbCwMIwePRq//vprufYZExOD48eP48iRI8XWlXYd7ezsKnUdqfq5desW1Go1XF1dtZa7urri/PnzBorq6ary3q+sitxnho75ypUriI6OxgcffICPP/4YR44cwYQJE2BpaYng4GAptpL+zxgq7unTpyM7OxvNmzeHubk51Go15s6di+HDhwNAtYzZ1LAGkHQmNDQUJ06cQJ06deDo6IjatWtj5syZ0Gg0WuUKCgpw/fp1rFq1CnK5HLa2tujWrRt2794tlUlNTYWzszMAICIiAjKZDDKZDLNmzQIAzJo1CzKZTGu/MpkM48aNw/r16+Hr6wsrKyu0bNkSW7duLRZrfHw8OnToAGtrazRp0gTffPNNifssr+nTp+PFF1/E2rVrpb98i2zZsgXdunWDra0t7O3tMXDgQJw5cwYAcO3aNUycOBHPPfcc6tWrhytXruDUqVNYunQp6tevj99//11qPP34tblx4wY+++wzrWtT5Pr16xgyZAjs7Ozg7OyMKVOmQK1WV+r8iEoSGhqKpKQkxMTEGDqUpyq6z37++WdYW1sbOpwy02g0aNeuHebNm4e2bdtizJgxGD16NJYtW2bo0Er122+/4eeff8aaNWtw/PhxrFq1Cp9//jlWrVpl6NDo/zEBpFJlZWXh1q1bWp/SjBs3Dhs2bEBBQQH++usvjB07FnPnzgUAPHr0CKtXr5bKZmdn4+bNm2jevDnmz5+PWbNm4Z9//kFAQAASExMBAM7OzoiOjgYAvPzyy9Lr1n/9619PjXnv3r0YO3Yshg4dis8++wx5eXl45ZVXcPv2banMiRMn0K9fP9y+fRsREREYNWoUZs+ejfXr11fwSml76623IITA9u3bpWU//fQTBg4cCDs7O8yfPx8zZszA2bNn0bVrV6SmpuLYsWPIyMjApk2bkJubiyZNmuDu3bt49OgRVCoV/vvf/+Lhw4fIzMzUujY2NjYYNmxYsWujVqsREBAAJycnfP755+jRowe++OILfPvttzo5R9KfevXqwdzcvFjP05s3b8LNzc1AUZVu3Lhx+OOPP7B79240aNBAWu7m5oaCggJkZmZqlTfkeRTdZ+3atZPeIiQkJOCrr75CrVq14OrqWu1iBgCFQgEfHx+tZS1atEBaWhoASLFVp/8zU6dOxfTp0zF06FC0atUKb731FiZPnozIyEgA1TNmk2PoRohU/TytE8jjijqBhIaGivr164uRI0cKAGLPnj1Smb///lsAEC4uLlLniDNnzhRrVH337l3h6uqq1Wj4n3/+EQBEeHh4sRhL6gQCQFhaWmr1jDt58qQAIBYvXiwtCwwMFLVr1xbXr1+Xll28eFHUqlWrTB1LntXJ4sSJEwKAmDx5shCisMF5nTp1xOjRo7XKpaenC7lcLkaPHi2ys7PF6dOnxUsvvSQAiGHDhokOHTqIESNGiFOnTomAgAABQPzwww9a1+bJ61gUHwAxe/ZsreVt27YV7du3f+b5keF17NhRjBs3TvquVquFu7t7teoEotFopHs/OTm52PqiDhWxsbHSsvPnzxu0Q0XRffb4p+g+O336dLWMWQgh3nzzzWKdQCZNmiSUSqUQ4n8dKj7//HNpfVZWlkE7VDg6Ooqvv/5aa9m8efNE06ZNhRDVM2ZTwwSQiilKAJcuXSq2b9+u9Xlco0aNRLNmzYRcLhfx8fGiSZMmom3btkKlUon79+9L5Tp16iQAiOXLl4ujR48KpVIpPbjUarW4ffu2+Oeff8TAgQNFmzZtpO0qkgAOGDCgWFkHBwcpGXv06JGwsbERw4YNK1YuMDBQJwngxYsXBQDx7rvvCiGE+P333wUAsWvXLvHPP/9ofV588UXh5eWltW8A4sKFC1q9E7ds2SIACCcnJ7Fr1y6xY8cOAUA0aNCgxPgAiIyMDK3lEyZMEHXr1n3m+ZHhxcTECCsrK7Fy5Upx9uxZMWbMGFGnTh2Rnp5u6NAkISEh0r2vUqmkz+P3/vvvvy8aNmwodu3aVezery4ev8+EqJ4xHz58WNSqVUvMnTtXXLx4Ufz888+idu3aYvXq1VKZqKgoUadOHbFhwwZx6tQpMXjwYIMOqRIcHCzc3d2lYWB+//13Ua9ePfHRRx9V25hNDRNAHUlISBCDBg0SCoVCABDr1q0r1/ZFCc2Tn9q1a+sn4KcoSgCPHDny1HKNGjUqtaZwxYoVUrnffvtNABB2dnaidu3a4uWXXxaLFi0SrVq1EhYWFlrbeXp6SttVJAF8//33S4xz5MiRQgghbty4IQCImTNnFis3efJkvdQAzp8/v9TrBEA4ODho7dvMzEw8fPhQ6xfT5cuXBQDxwgsviLp16wobGxsBQHz44YclxmdtbV1seU0eO7EmWrx4sWjYsKGwtLQUHTt2FAcPHjR0SFrKcu8/ePBAjB07VtStW1e691UqleGCLsGTCWB1jXnTpk3C19dXWFlZiebNm4tvv/1Wa71GoxEzZswQrq6uwsrKSvTp00dcuHDBQNEW1rZOnDhRNGzYUFhbW4vnnntOfPLJJyI/P7/axmxq2AtYR3Jzc9G6dWu88847z2ynVpIpU6bg/fff11rWp08fPP/887oKUS+Cg4OxcuVKAIC1tTVef/11/Pjjj1plLC0tART2vhs4cCBWr16Nt956C0OGDMHUqVPh4uICc3NzREZG4vLly5WKx9zcvMTl4rHR5/UtKSkJAODl5QUAUieYn376qcS2LaX1Zi5p+JvBgwdj+vTpuHXrFpydnWFnZ1fitqVdBzIe48aNw7hx4wwdRqnKck9ZW1tj6dKlWLp0aRVEVDFP3mfVNeZBgwZh0KBBpa6XyWSYPXs2Zs+eXYVRlc7e3h4LFy7EwoULSy1T3WI2NUwAdaR///7S+EYlyc/PxyeffIJffvkFmZmZ8PX1xfz589GzZ08AhcN5PP7L/OTJkzh79my17uX1pEaNGhWbCgqANHRFo0aNAACxsbF47rnn8Pvvv2v1ug0PD9farrI9ckvi4uICa2trXLp0qdi6kpZVxE8//QSZTAZ/f38AQJMmTaRjPznuWEk0Gg2uXLkCb29vaVlRj+LGjRsD0M+1ISIi08FewFVk3LhxOHDgAGJiYnDq1Cm89tpr6NevX6nzHn7//ffw9vZGt27dqjjSihswYAAOHz6sNYhnbm4uvv32WzRu3FjqxVZUO/V4DcKhQ4eKDf5Zu3ZtACjWI68yzM3N0bdvX6xfvx43btyQll+6dAlbtmyp9P6joqKwbds2vPHGG2jatCkAICAgAA4ODpg3bx4ePnxYbJt//vmn2LIlS5ZI/xZCYMmSJbCwsECfPn0A6OfaEBGR6WANYBVIS0vDihUrkJaWhvr16wMofOW7detWrFixAvPmzdMqn5eXh59//hnTp083RLgVNn36dPzyyy/o378/JkyYAEdHR6xatQopKSn473//CzOzwr83Bg0ahN9//x0vv/wyBg4ciJSUFCxbtgw+Pj64d++etD8bGxv4+Pjg119/hbe3NxwdHeHr6ysNNFtRs2bNwrZt29ClSxeEhIRArVZjyZIl8PX1lYaheZbHh7bJy8vD1atXsXHjRpw6dQq9evXSGm7FwcEB0dHReOutt9CuXTsMHToUzs7OSEtLw59//okuXbpoJXzW1tbYunUrgoOD0alTJ2zZsgV//vknPv74Y2n8P31dGyIiMg1MAKvA6dOnoVartV7pAYWvhZ2cnIqVX7duHXJychAcHFxVIeqEq6sr9u/fj2nTpmHx4sXIy8uDn58fNm3ahIEDB0rlRo4cifT0dHzzzTeIi4uDj48PVq9ejbVr1xZrj/P9999j/PjxmDx5MgoKChAeHl7pJKd9+/bYsmULpkyZghkzZsDDwwOzZ8/GuXPnyjzTQn5+Pt566y0AhbVxLi4uaN++PWbOnImXX35ZSnaLDBs2DPXr10dUVBQWLFiA/Px8uLu7o1u3bnj77be1ypqbm2Pr1q0ICQnB1KlTYW9vj/DwcMycOVOrnD6uDRERmQaZqMrW8SZCJpNh3bp1GDJkCADg119/xfDhw3HmzJlijfPt7OyKdQzo06cPHBwcsG7duqoKmQAMGTIEZ86cKfW1fFUYOXIkYmNjtWpCiYiIdI01gFWgbdu2UKvVyMjIeGabvpSUFOzevRsbN26souhM04MHD2BjYyN9v3jxIjZv3mx0ta5EREQVwQRQR+7du6fVizQlJQWJiYlwdHSEt7c3hg8fjqCgIHzxxRdo27Yt/vnnH+zcuRN+fn5ar0d/+OEHKBSKp/Yopsp77rnnMHLkSDz33HO4evUqoqOjYWlpiY8++sjQoREREekdE0AdOXr0KHr16iV9/+CDDwD8b5y8FStWYM6cOfjwww9x/fp11KtXDy+88ILWuE4ajQYrV67EyJEjOY6bnvXr1w+//PIL0tPTYWVlBaVSiXnz5kk9d4mIiGoytgEkk5WamgpPT0+cOHECbdq0Kde2O3fuxLhx45CUlFThZL2goADe3t6IjY1Fhw4dKrQPouqsZ8+eaNOmzVMHAy7Jk+2ojcnKlSsxadIkvQ7RFB8fj169euHu3buoU6eO3o5TFsuXL8evv/6Kbdu2VXgft27dgo+PD44fP44GDRroMDp6Go4DSAYxcuRIyGQyyGQyWFhYwNXVFf7+/vjhhx+kmTN0fTxd/jL56KOP8O9//7tSNbWWlpaYMmUKpk2bprO4iB5XdI+V9pk1a5ahQzQaj183W1tbNG3aFCNHjsSxY8e0yr3xxhvSwO3PsnLlygolcJ07d4ZKpYJcLi/3trqUl5eHGTNmFBvEv7zq1auHoKCgSu+HyocJIBlMv379oFKpkJqaii1btqBXr16YOHEiBg0ahEePHhk6vFLt3bsXly9fxiuvvFLpfQ0fPhx79+7FmTNndBAZkTaVSiV9Fi5cCAcHB61lU6ZMMXSIRmXFihVQqVQ4c+YMli5dinv37qFTp05a01/a2NjAxcVFr3FYWlrCzc3N4DMCxcbGwsHBAV26dKn0vt5++238/PPPuHPnjg4io7JgAlgJGo0Gf//9N7KyspCdnc1POT4FBQUwMzND7dq1YW9vDy8vL4wbNw5r1qzBli1bEB0dLZVNS0tDUFAQnJycYG9vj+7du2Pfvn3S+rCwMLRq1QoLFy6Eu7s7bGxs8PLLL+PatWvS+lWrVmHDhg3SX/B//vkncnJyABTO3dutWzfY2NjA19cXO3bseGrsP/74I3r27ImCgoJiMSxduhQNGjSAra0t3n33Xdy9exezZ8+Gi4sL6tWrhxkzZmjty9zcHJ06dcKqVasM/jMxxk9WVhb+/vtvvdQa1wRubm7SRy6XQyaTSd9dXFzw5ZdfokGDBrCyskKbNm2wdetWadv4+HjIZDKtV5mJiYmQyWRITU2Vlu3btw89e/ZE7dq1UbduXQQEBODu3bvSeo1Gg48++giOjo5wc3MrVut48eJFdO/eHdbW1vDx8cH27duLncfp06fRu3dv2NjYwMnJCWPGjJGGSkpKSoKZmZk0o86dO3dgZmaGoUOHStvPmTMHXbt21TqvnTt3okOHDqhduzY6d+5c4jSWT6pTpw7c3NzQuHFjvPjii4iNjcXw4cMxbtw46ZyfrNU7efIkevXqBXt7ezg4OKB9+/Y4evQo4uPj8fbbbyMrK6tYjexPP/2EDh06wN7eHm5ubhg2bBgyMjJK/dkUHTMuLg4tWrSAnZ2d9Af243744Qe0bNkSVlZWUCgUWnNNZ2Zm4t1334WzszMcHBzQu3dvnDx58qnXIyYmBoGBgVrLit62zJs3D66urqhTpw5mz56NR48eYerUqXB0dESDBg2wYsUKre1atmyJ+vXrc/izqiSowq5duyYA8MMPPwb+XLt2zdCPg2pvxYoVQi6XS9+//PJL4eDgIH755Rdx/vx58dFHHwkLCwuRnJwshBBi9+7dAoC4e/eutM2JEycEAJGSkiJ9t7KyEiEhISIxMVEkJSWJxYsXi3/++UcIIUSPHj2Eg4ODmDVrlkhOTharVq0SMplMbNu2TQghhFqtFr6+vqJPnz4iMTFRJCQkiLZt2woAYt26dUIIIe7duycUCoX417/+JU6fPi127twpPD09RXBwsBBCCI1GI+rVqyfWrl0rhBBi/fr1ol69esLNzU2Ku2/fvuKTTz7ROq9OnTqJ+Ph4cebMGdGtWzfRuXPnp16/x2N6XNE1+fXXX0u8zi1bthQjRowQ586dE8nJyeK3334TiYmJIj8/XyxcuFA4ODgIlUolVCqVyMnJEUIIsXz5crF582Zx+fJlceDAAaFUKkX//v2lfT75s1mxYoWwsLAQffv2FUeOHBHHjh0TLVq0EMOGDZO2+frrr4W1tbVYuHChuHDhgjh8+LD4z3/+o3WNAgMDxZEjR0RycrL48MMPhZOTk7h9+3ap10Qul4uYmBitZcHBwcLe3l6EhoaK8+fPi+XLlwsAIiAgQMydO1ckJyeLTz/9VFhYWBS7b9944w3p50r6x17AlWBvbw8AuHbtGhwcHAwcDZHpyc7OhoeHh3QvUtl9/vnnmDZtmlRTNn/+fOzevRsLFy7E0qVLy7SPzz77DB06dMDXX38tLWvZsqVWGT8/P6ltV9OmTbFkyRLs3LkT/v7+2LFjB86fP4+4uDhpmsx58+ZpDYO1Zs0a5OXl4ccff4StrS2AwrmyAwMDMX/+fLi6uqJ79+6Ij4/Hq6++KtWsff/99zh//jyaNGmC/fv3Fxviae7cuejRoweAwmksBw4ciLy8PFhbW5fnMqJ58+YAoFUr+ri0tDRMnTpVKvf4SAOP18o+7p133pH+/dxzz+Grr77C888/j3v37sHOzq7E4zx8+BDLli1DkyZNABTOPz979mxpfdEoFBMnTpSWPf/88wAKm7UcPnwYGRkZsLKyAlD4/2P9+vWIjY3FmDFjih0vMzMTWVlZ0s/tcY6Ojvjqq69gZmaGZs2a4bPPPsP9+/fx8ccfAwDCwsIQFRWFvXv3atXU1q9fHydOnCjx/Ej3mABWQlH7CwcHByaARAZk6LZQxiY7Oxs3btwo1narS5cuz3zt97jExES89tprTy3j5+en9V2hUEivM8+dOwcPDw+tJEKpVGqVP3fuHFq3bi0lf0VxajQaXLhwAa6urujRo4c0/3ZCQgLmzZuH5ORkxMfH486dO3j48GGxc308LoVCAQDIyMhAw4YNy3r6AADx/wNplPZ/8IMPPsC7776Ln376CX379sVrr70mJWmlOXbsGGbNmoWTJ0/i7t27UhOHtLQ0+Pj4lLhN7dq1tfb7+HXOyMjAjRs30KdPnxK3PXnyJO7du1dsatIHDx7g8uXLJW7z4MEDACgxYW7ZsqXWdJiurq5a01Sam5vDyclJ67U2UNh+8v79+yUej3SPCSCZLLVG4HDKHWTk5MHF3hodPR1hblbxRELX+2OMuouRyq/oF7h4bKSwhw8fapV5fDad0lhYWGh9l8lkOm+z2bNnT0yaNAkXL17E2bNn0bVrV5w/fx7x8fG4e/eu1NavtLiKkreKxHXu3DkAgKenZ4nrZ82ahWHDhuHPP//Eli1bEB4ejpiYGLz88sslls/NzUVAQAACAgLw888/w9nZGWlpaQgICEBBQUGpcZR0nYt+ds/6Od27dw8KhaLYXOwASu2l7OTkBJlMptXe82mxlOX/wZ07d+Ds7PzUWEl3mACSSdqapELEprNQZeVJyxRya4QH+qCfr8Lg+2OMuouRinNwcED9+vWxb98+6TUoUNiho2PHjgAg/SJWqVSoW7cugMIav8f5+flh586diIiIqFAcLVq0wLVr16BSqaRauIMHDxYrs3LlSuTm5kq1gPv27ZNeLwJAq1atULduXcyZMwdt2rSBnZ0devbsifnz5+Pu3bvo2bNnheIri6Le1X379i21jLe3N7y9vTF58mS8+eabWLFiBV5++WVYWlpCrVZrlT1//jxu376NqKgoeHh4ACicaKAy7O3t0bhxY+zcuVNrwoIi7dq1Q3p6OmrVqoXGjRuXaZ+Wlpbw8fHB2bNn8eKLL1YqviJJSUl6/VmRNvYCJpOzNUmFkNXHtZIMAEjPykPI6uPYmqQqZcuq2R9j1F2MVLqpU6di/vz5+PXXX3HhwgVMnz4diYmJUhsxLy8veHh4YNasWbh48SL+/PNPfPHFF1r7CAsLw5EjRzB27FicOnUK58+fR3R0NG7dulWmGPr27Qtvb28EBwfj5MmT2LNnDz755BOtMsOHD4e1tTWCg4ORlJSE3bt3Y/z48Xjrrbfg6uoKoLA2qXv37vj555+lBMLPzw/5+fnYuXOnVpJbGZmZmUhPT8fVq1exfft2vPrqq1izZg2io6NLrCl78OABxo0bh/j4eFy9ehX79u3DkSNH0KJFCwBA48aNce/ePezcuRO3bt3C/fv30bBhQ1haWmLx4sW4cuUKNm7ciE8//bTSsc+aNQtffPEFvvrqK1y8eBHHjx/H4sWLART+HJRKJYYMGYJt27YhNTUV+/fvxyeffPLU5DMgIAB79+6tdGwAcP/+fRw7dkxnySQ9GxNAMilqjUDEprMQJawrWhax6SzUmpJK6H9/jFF3MdLTTZgwAR988AE+/PBDtGrVClu3bsXGjRulTgoWFhb45ZdfcP78efj5+WH+/PmYM2eO1j68vb2xbds2nDx5Eh07doRSqcSGDRtQq1bZXi6ZmZlh3bp1ePDgATp27Ih3330Xc+fO1SpTu3ZtxMXF4c6dO3j++efx6quvok+fPliyZIlWuR49ekCtVksJoJmZGbp37w6ZTKaTceqAwrHqFAoFmjdvjpCQENjZ2eHw4cMYNmxYieXNzc1x+/ZtBAUFwdvbG6+//jr69+8v1Zh27twZ77//Pt544w04Ozvjs88+g7OzM1auXIm1a9fCx8cHUVFR+Pzzzysde3BwMBYuXIivv/4aLVu2xKBBg3Dx4kUAhQn05s2b0b17d7z99tvw9vbG0KFDcfXqVSnJLsmoUaOwefNmZGVlVTq+DRs2oGHDhujWrVul90Vlw6ngKiE7OxtyuRxZWVnsBGIkDly+jTe/O/jMcr+MfgHKJk7PLKfr/THG8u2P9yCRYb322mto164dwsLCKrWfF154ARMmTCg1mSbdYw0gmZSMnLxnFzJgOUMeu6bFSET6t2DBglKHpimrW7du4V//+hfefPNNHUVFZcFOIGRSXOzLNsaXocoZ8tg1LUYi0r/GjRtj/PjxldpHvXr1io3TSPrHGkAyKR09HaGQW6O0QUVkKOx12tHT0SD7Y4y6i5GIiErHBJBMirmZDOGBhQOpPplsFH0PD/Qp87hzut4fY9RdjEREVDomgGRy+vkqED2iHdzk2q8T3eTWiB7Rrtzjzel6f4xRdzESEVHJ2Au4EtgD0bgZwwwWjPHp++M9SERUMUwAK4G/fIgMi/cgEVHF8BUwERERkYlhAkhERERkYowiAYyOjoafnx8cHBzg4OAApVKJLVu2lFq+Z8+ekMlkxT4DBw6UygghMHPmTCgUCtjY2KBv377StDhERERENZlRJIANGjRAVFQUjh07hqNHj6J3794YPHgwzpw5U2L533//HSqVSvokJSXB3Nwcr732mlTms88+w1dffYVly5bh0KFDsLW1RUBAAPLyONMAERER1WxG2wnE0dERCxYswKhRo55ZduHChZg5cyZUKhVsbW0hhED9+vXx4YcfYsqUKQCArKwsuLq6YuXKlRg6dGiZYmADdCLD4j1IRFQxRlED+Di1Wo2YmBjk5uZCqVSWaZvly5dj6NChsLW1BQCkpKQgPT0dffv2lcrI5XJ06tQJBw4c0EvcRERERNWF0cwFfPr0aSiVSuTl5cHOzg7r1q2Dj4/PM7c7fPgwkpKSsHz5cmlZeno6AMDV1VWrrKurq7SuJPn5+cjPz5e+Z2dnl/c0iIiIiAzOaGoAmzVrhsTERBw6dAghISEIDg7G2bNnn7nd8uXL0apVK3Ts2LHSMURGRkIul0sfDw+PSu+TiIiIqKoZTQJoaWkJLy8vtG/fHpGRkWjdujUWLVr01G1yc3MRExNTrJ2gm5sbAODmzZtay2/evCmtK0lYWBiysrKkz7Vr1yp4NkRERESGYzQJ4JM0Go3W69iSrF27Fvn5+RgxYoTWck9PT7i5uWHnzp3SsuzsbBw6dOip7QqtrKykoWiKPkRERETGxijaAIaFhaF///5o2LAhcnJysGbNGsTHxyMuLg4AEBQUBHd3d0RGRmptt3z5cgwZMgROTk5ay2UyGSZNmoQ5c+agadOm8PT0xIwZM1C/fn0MGTKkqk6LiIiIyCCMIgHMyMhAUFAQVCoV5HI5/Pz8EBcXB39/fwBAWloazMy0KzMvXLiAvXv3Ytu2bSXu86OPPkJubi7GjBmDzMxMdO3aFVu3boW1tbXez4eIiIjIkIx2HMDqgGOQERkW70Eiooox2jaARERERFQxTACJiIiITAwTQCIiIiITwwSQiIiIyMQwASQiIiIyMUYxDAyRWiNwOOUOMnLy4GJvjY6ejjA3kxk6LCIiIqPEBJCqva1JKkRsOgtVVp60TCG3RnigD/r5KgwYGRERkXHiK2Cq1rYmqRCy+rhW8gcA6Vl5CFl9HFuTVAaKjIiIyHgxAaRqS60RiNh0FiWNVF60LGLTWag1HMuciIioPJgAUrV1OOVOsZq/xwkAqqw8HE65U3VBERER1QBMAKnaysgpPfmrSDkiIiIqxASQqi0Xe2udliMiIqJCTACp2uro6QiF3BqlDfYiQ2Fv4I6ejlUZFhERkdFjAkjVlrmZDOGBPgBQLAks+h4e6MPxAImIiMqJCSBVa/18FYge0Q5ucu3XvG5ya0SPaMdxAImIiCqAA0FTtdfPVwF/HzfOBEJERKQjTADJKJibyaBs4mToMIiIiGoEvgImIiIiMjFMAImIiIhMDBNAIiIiIhPDBJCIiIjIxDABJCIiIjIxTACJiIiITAwTQCIiIiITwwSQiIiIyMQwASQiIiIyMUwAiYiIiEwME0AiIiIiE8MEkIiIiMjEMAEkIiIiMjFMAImIiIhMTC197DQzMxPr1q3Dnj17cPXqVdy/fx/Ozs5o27YtAgIC0LlzZ30cloiIiIjKQKc1gDdu3MC7774LhUKBOXPm4MGDB2jTpg369OmDBg0aYPfu3fD394ePjw9+/fXXMu0zOjoafn5+cHBwgIODA5RKJbZs2fLUbTIzMxEaGgqFQgErKyt4e3tj8+bN0nq1Wo0ZM2bA09MTNjY2aNKkCT799FMIISp1/kRERETGQKc1gG3btkVwcDCOHTsGHx+fEss8ePAA69evx8KFC3Ht2jVMmTLlqfts0KABoqKi0LRpUwghsGrVKgwePBgnTpxAy5Yti5UvKCiAv78/XFxcEBsbC3d3d1y9ehV16tSRysyfPx/R0dFYtWoVWrZsiaNHj+Ltt9+GXC7HhAkTKnUNiIiIiKo7mdBhtdft27fh5OSkt/JFHB0dsWDBAowaNarYumXLlmHBggU4f/48LCwsStx+0KBBcHV1xfLly6Vlr7zyCmxsbLB69eoyx5GdnQ25XI6srCw4ODiU+zyIqHJ4DxIRVYxOXwGXN5krb3m1Wo2YmBjk5uZCqVSWWGbjxo1QKpUIDQ2Fq6srfH19MW/ePKjVaqlM586dsXPnTiQnJwMATp48ib1796J///5PPX5+fj6ys7O1PkRERETGRi+dQEpy7tw5HDx4EG3btkWbNm3Kte3p06ehVCqRl5cHOzs7rFu3rtRXzFeuXMGuXbswfPhwbN68GZcuXcLYsWPx8OFDhIeHAwCmT5+O7OxsNG/eHObm5lCr1Zg7dy6GDx/+1DgiIyMRERFRrthNlVojcDjlDjJy8uBib42Ono4wN5MZOiwiIiKCjl8BF5k9ezZsbGwwdepUAMDu3bvRr18/2NvbIysrCytXrnxmsvW4goICpKWlISsrC7Gxsfj++++RkJBQYhLo7e2NvLw8pKSkwNzcHADw5ZdfYsGCBVCpVACAmJgYTJ06FQsWLEDLli2RmJiISZMm4csvv0RwcHCpceTn5yM/P1/6np2dDQ8PD75+esLWJBUiNp2FKitPWqaQWyM80Af9fBUGjIxqGr4CJiKqGL0kgH5+foiMjMTAgQMBAH379kXbtm2xYMECfPPNN/jqq69w5syZCu+/b9++aNKkCb755pti63r06AELCwvs2LFDWrZlyxYMGDAA+fn5sLS0hIeHB6ZPn47Q0FCpzJw5c7B69WqcP3++zHHwl09xW5NUCFl9HE/+pyqq+4se0Y5JIOkM70EioorR6SvgH3/8EUIIpKamIjExEbdv34YQAvv27UO3bt3w448/QqPR4MqVK/jxxx8BAEFBQeU+jkaj0aqJe1yXLl2wZs0aaDQamJkVNnFMTk6GQqGApaUlAOD+/fvSuiLm5ubQaDTljoX+R60RiNh0tljyBwAChUlgxKaz8Pdx4+tgIiIiA9JpAtioUSMAgKWlJVxdXdGoUSMkJibCwcEBvXr1ghAC+fn5kMlkaNy4cZnG3QsLC0P//v3RsGFD5OTkYM2aNYiPj0dcXByAwgTS3d0dkZGRAICQkBAsWbIEEydOxPjx43Hx4kXMmzdPa3iXwMBAzJ07Fw0bNkTLli1x4sQJfPnll3jnnXd0eTlMzuGUO1qvfZ8kAKiy8nA45Q6UTcrf+5uIiIh0Q6cJYI8ePQAA7dq1wx9//IFp06Zh69atGDBgALp37w6gsEOHh4eH9P1ZMjIyEBQUBJVKBblcDj8/P8TFxcHf3x8AkJaWplWb5+Hhgbi4OEyePBl+fn5wd3fHxIkTMW3aNKnM4sWLMWPGDIwdOxYZGRmoX78+3nvvPcycOVNXl8IkZeSUnvxVpBwRERHph17aAJ48eRKDBw9GWloamjdvjri4OHh4eAAAPvzwQzx69AiLFi3S9WGrHNsfaTtw+Tbe/O7gM8v9MvoF1gCSTvAeJCKqGL0MA9O6dWukpqaWONDzlClT+KCuoTp6OkIht0Z6Vl6J7QBlANzkhUPCEBERkeHodCDoJ5U00LNCoYCtra0+D0sGYm4mQ3hg4dA8T3bxKPoeHujDDiBEREQGptMEMCYmpsxlr127hn379uny8FQN9PNVIHpEO7jJrbWWu8mtOQQMERFRNaHTNoA9evRARkYG3n77bQQGBqJFixZa67OysrBv3z6sXr0a27dvx/Lly/HSSy/p6vBVju2PSseZQKgq8B4kIqoYnbYBTEhIwMaNG7F48WKEhYXB1tYWrq6usLa2xt27d5Geno569eph5MiRSEpKgqurqy4PT9WIuZmMHT2IiIiqKb30AgaAW7duYe/evbh69SoePHiAevXqoW3btmjbtm2xQZiNFWsfiAyL9yARUcXopRcwANSrVw9DhgzR1+6JiIiIqIJqRlUcEREREZUZE0AiIiIiE8MEkIiIiMjEMAEkIiIiMjF6SwBnz56N+/fvF1v+4MEDzJ49W1+HJSIiIqJn0NswMObm5lCpVHBxcdFafvv2bbi4uECtVuvjsFWKQ1AQGRbvQSKiitFbDaAQAjJZ8ZkfTp48CUdHR30dloiIiIieQefjANatWxcymQwymQze3t5aSaBarca9e/fw/vvv6/qwRERERFRGOk8AFy5cCCEE3nnnHUREREAul0vrLC0t0bhxYyiVSl0floiIiIjKSOcJYHBwMADA09MTXbp0Qa1aeptshIiIiIgqQG9tAO3t7XHu3Dnp+4YNGzBkyBB8/PHHKCgo0NdhiYiIiOgZ9JYAvvfee0hOTgYAXLlyBW+88QZq166NtWvX4qOPPtLXYYmIiIjoGfSWACYnJ6NNmzYAgLVr16JHjx5Ys2YNVq5cif/+97/6OiwRERERPYNeh4HRaDQAgB07dmDAgAEAAA8PD9y6dUtfhyUiIiKiZ9BbAtihQwfMmTMHP/30ExISEjBw4EAAQEpKClxdXfV1WCIiIiJ6Br0lgAsXLsTx48cxbtw4fPLJJ/Dy8gIAxMbGonPnzvo6LBERERE9g96mgitNXl4ezM3NYWFhUZWH1YuaMg2VWiNwOOUOMnLy4GJvjY6ejjA3Kz6LC1F1U1PuQSKiqqb3QfqOHTsmDQfj4+ODdu3a6fuQVA5bk1SI2HQWqqw8aZlCbo3wQB/081UYMDIiIiLSF70lgBkZGXjjjTeQkJCAOnXqAAAyMzPRq1cvxMTEwNnZWV+HpjLamqRCyOrjeLIKOD0rDyGrjyN6RDsmgURERDWQ3toAjh8/Hvfu3cOZM2dw584d3LlzB0lJScjOzsaECRP0dVgqI7VGIGLT2WLJHwBpWcSms1BrqrSFABEREVUBvdUAbt26FTt27ECLFi2kZT4+Pli6dClefPFFfR2Wyuhwyh2t175PEgBUWXk4nHIHyiZOVRcYERER6Z3eagA1Gk2JHT0sLCyk8QHJcDJySk/+KlKOiIiIjIfeEsDevXtj4sSJuHHjhrTs+vXrmDx5Mvr06aOvw1IZudhb67QcERERGQ+9JYBLlixBdnY2GjdujCZNmqBJkybw9PREdnY2Fi9erK/DUhl19HSEQm6N0gZ7kaGwN3BHT8eqDIuIiIiqgN4SQA8PDxw/fhx//vknJk2ahEmTJmHz5s04fvw4GjRoUOb9REdHw8/PDw4ODnBwcIBSqcSWLVueuk1mZiZCQ0OhUChgZWUFb29vbN68WavM9evXMWLECDg5OcHGxgatWrXC0aNHK3SuxsjcTIbwQB8AKJYEFn0PD/TheIBEREQ1kF7HAZTJZPD394e/v3+F99GgQQNERUWhadOmEEJg1apVGDx4ME6cOIGWLVsWK19QUAB/f3+4uLggNjYW7u7uuHr1qjQUDQDcvXsXXbp0Qa9evbBlyxY4Ozvj4sWLqFu3boXjNEb9fBWIHtGu2DiAbhwHkIiIqEbT+Uwgu3btwrhx43Dw4MFiI/NnZWWhc+fOWLZsGbp161bhYzg6OmLBggUYNWpUsXXLli3DggULcP78+VJnG5k+fTr27duHPXv2VDgGoObMQsCZQMhY1ZR7kIioqun8FfDChQsxevToEh/Gcrkc7733Hr788ssK7VutViMmJga5ublQKpUlltm4cSOUSiVCQ0Ph6uoKX19fzJs3D2q1WqtMhw4d8Nprr8HFxQVt27bFd99998zj5+fnIzs7W+tTE5ibyaBs4oTBbdyhbOLE5I+IiKiG03kCePLkSfTr16/U9S+++CKOHTtWrn2ePn0adnZ2sLKywvvvv49169bBx8enxLJXrlxBbGws1Go1Nm/ejBkzZuCLL77AnDlztMpER0ejadOmiIuLQ0hICCZMmIBVq1Y9NY7IyEjI5XLp4+HhUa7zICIiIqoOdP4K2NraGklJSfDy8ipx/aVLl9CqVSs8ePCgzPssKChAWloasrKyEBsbi++//x4JCQklJoHe3t7Iy8tDSkoKzM3NAQBffvklFixYAJVKBQCwtLREhw4dsH//fmm7CRMm4MiRIzhw4ECpceTn5yM/P1/6np2dDQ8PD75+IjIQvgImIqoYndcAuru7IykpqdT1p06dgkJRvs4FlpaW8PLyQvv27REZGYnWrVtj0aJFJZZVKBTw9vaWkj8AaNGiBdLT01FQUCCVeTJ5bNGiBdLS0p4ah5WVldQbuehDREREZGx0ngAOGDAAM2bMQF5e8RkkHjx4gPDwcAwaNKhSx9BoNFo1cY/r0qULLl26pDXbSHJyMhQKBSwtLaUyFy5c0NouOTkZjRo1qlRcRERERMZA58PA/Pvf/8bvv/8Ob29vjBs3Ds2aNQMAnD9/HkuXLoVarcYnn3xS5v2FhYWhf//+aNiwIXJycrBmzRrEx8cjLi4OABAUFAR3d3dERkYCAEJCQrBkyRJMnDgR48ePx8WLFzFv3jxMmDBB2ufkyZPRuXNnzJs3D6+//joOHz6Mb7/9Ft9++60OrwQRERFR9aTzBNDV1RX79+9HSEgIwsLCUNTEUCaTISAgAEuXLoWrq2uZ95eRkYGgoCCoVCrI5XL4+fkhLi5OGlswLS0NZmb/q8j08PBAXFwcJk+eDD8/P7i7u2PixImYNm2aVOb555/HunXrEBYWhtmzZ8PT0xMLFy7E8OHDdXQViIiIiKovnXcCedzdu3dx6dIlCCHQtGnTGjfQMhugExkW70EioorR60wgdevWxfPPP6/PQxARERFROeltLmAiIiIiqp6YABIRERGZGCaARERERCaGCSARERGRiWECSERERGRimAASERERmRgmgEREREQmhgkgERERkYlhAkhERERkYpgAEhEREZkYJoBEREREJkavcwGTfqg1AodT7iAjJw8u9tbo6OkIczOZocMiIiIiI8EE0MhsTVIhYtNZqLLypGUKuTXCA33Qz1dhwMiIiIjIWPAVsBHZmqRCyOrjWskfAKRn5SFk9XFsTVIZKDIiIiIyJkwAjYRaIxCx6SxECeuKlkVsOgu1pqQSRERERP/DBNBIHE65U6zm73ECgCorD4dT7lRdUERERGSUmAAaiYyc0pO/ipQjIiIi08UE0Ei42FvrtBwRERGZLiaARqKjpyMUcmuUNtiLDIW9gTt6OlZlWERERGSEmAAaCXMzGcIDfQCgWBJY9D080IfjARIREdEzMQE0Iv18FYge0Q5ucu3XvG5ya0SPaMdxAImIiKhMOBC0kennq4C/jxtnAiEiIqIKYwJohMzNZFA2cTJ0GERERGSk+AqYiIiIyMQwASQiIiIyMUwAiYiIiEwME0AiIiIiE8MEkIiIiMjEMAEkIiIiMjFMAImIiIhMjFEkgNHR0fDz84ODgwMcHBygVCqxZcuWp26TmZmJ0NBQKBQKWFlZwdvbG5s3by6xbFRUFGQyGSZNmqSH6ImIiIiqF6MYCLpBgwaIiopC06ZNIYTAqlWrMHjwYJw4cQItW7YsVr6goAD+/v5wcXFBbGws3N3dcfXqVdSpU6dY2SNHjuCbb76Bn59fFZwJERERkeEZRQIYGBio9X3u3LmIjo7GwYMHS0wAf/jhB9y5cwf79++HhYUFAKBx48bFyt27dw/Dhw/Hd999hzlz5ugldiIiIqLqxiheAT9OrVYjJiYGubm5UCqVJZbZuHEjlEolQkND4erqCl9fX8ybNw9qtVqrXGhoKAYOHIi+fftWRehERERE1YJR1AACwOnTp6FUKpGXlwc7OzusW7cOPj4+JZa9cuUKdu3aheHDh2Pz5s24dOkSxo4di4cPHyI8PBwAEBMTg+PHj+PIkSNljiE/Px/5+fnS9+zs7MqdFBEREZEBGE0C2KxZMyQmJiIrKwuxsbEIDg5GQkJCiUmgRqOBi4sLvv32W5ibm6N9+/a4fv06FixYgPDwcFy7dg0TJ07E9u3bYW1tXeYYIiMjERERocvTIiIiIqpyMiGEMHQQFdG3b180adIE33zzTbF1PXr0gIWFBXbs2CEt27JlCwYMGID8/Hxs3rwZL7/8MszNzaX1arUaMpkMZmZmyM/P11pXpKQaQA8PD2RlZcHBwUHHZ0hEz5KdnQ25XM57kIionIymBvBJGo1GKxl7XJcuXbBmzRpoNBqYmRU2c0xOToZCoYClpSX69OmD06dPa23z9ttvo3nz5pg2bVqJyR8AWFlZwcrKSrcnQkRERFTFjCIBDAsLQ//+/dGwYUPk5ORgzZo1iI+PR1xcHAAgKCgI7u7uiIyMBACEhIRgyZIlmDhxIsaPH4+LFy9i3rx5mDBhAgDA3t4evr6+WsewtbWFk5NTseVERERENY1RJIAZGRkICgqCSqWCXC6Hn58f4uLi4O/vDwBIS0uTavoAwMPDA3FxcZg8eTL8/Pzg7u6OiRMnYtq0aYY6BSIiIqJqw2jbAFYHbH9EZFi8B4mIKsboxgEkIiIiosoxilfAxkytETiccgcZOXlwsbdGR09HmJvJDB0WERERmTAmgHq0NUmFiE1nocrKk5Yp5NYID/RBP1+FASMjIiIiU8ZXwHqyNUmFkNXHtZI/AEjPykPI6uPYmqQyUGRERERk6pgA6oFaIxCx6SxK6l1TtCxi01moNex/Q0RERFWPCaAeHE65U6zm73ECgCorD4dT7lRdUERERET/jwmgHmTklJ78VaQcERERkS4xAdQDF3trnZYjIiIi0iUmgHrQ0dMRCrk1ShvsRYbC3sAdPR2rMiwiIiIiAEwA9cLcTIbwQB8AKJYEFn0PD/TheIBERERkEEwA9aSfrwLRI9rBTa79mtdNbo3oEe04DiAREREZDAeC1qN+vgr4+7hxJhAiIiKqVpgAVoIQheP4ZWdnP7VcS2cLtHS2AADk3svRe1xEpqLo3iu6F4mIqGyYAFZCTk5hMufh4WHgSIhMW05ODuRyuaHDICIyGjLBP50rTKPR4MaNG7C3t4dMxte6T8rOzoaHhweuXbsGBwcHQ4djtHgdSyeEQE5ODurXrw8zMzZpJiIqK9YAVoKZmRkaNGhg6DCqPQcHByYuOsDrWDLW/BERlR//ZCYiIiIyMUwAiYiIiEwME0DSGysrK4SHh8PKysrQoRg1XkciItI1dgIhIiIiMjGsASQiIiIyMUwAiYiIiEwME0AiIiIiE8MEkIiIiMjEMAGkSomMjMTzzz8Pe3t7uLi4YMiQIbhw4YJWmby8PISGhsLJyQl2dnZ45ZVXcPPmTQNFbByioqIgk8kwadIkaRmvIxER6QoTQKqUhIQEhIaG4uDBg9i+fTsePnyIF198Ebm5uVKZyZMnY9OmTVi7di0SEhJw48YN/Otf/zJg1NXbkSNH8M0338DPz09rOa8jERHpCoeBIZ36559/4OLigoSEBHTv3h1ZWVlwdnbGmjVr8OqrrwIAzp8/jxYtWuDAgQN44YUXDBxx9XLv3j20a9cOX3/9NebMmYM2bdpg4cKFvI5ERKRTrAEkncrKygIAODo6AgCOHTuGhw8fom/fvlKZ5s2bo2HDhjhw4IBBYqzOQkNDMXDgQK3rBfA6EhGRbtUydABUc2g0GkyaNAldunSBr68vACA9PR2WlpaoU6eOVllXV1ekp6cbIMrqKyYmBsePH8eRI0eKreN1JCIiXWICSDoTGhqKpKQk7N2719ChGJ1r165h4sSJ2L59O6ytrQ0dDhER1XB8BUw6MW7cOPzxxx/YvXs3GjRoIC13c3NDQUEBMjMztcrfvHkTbm5uVRxl9XXs2DFkZGSgXbt2qFWrFmrVqoWEhAR89dVXqFWrFlxdXXkdiYhIZ5gAUqUIITBu3DisW7cOu3btgqenp9b69u3bw8LCAjt37pSWXbhwAWlpaVAqlVUdbrXVp08fnD59GomJidKnQ4cOGD58uPRvXkciItIVvgKmSgkNDcWaNWuwYcMG2NvbS+3R5HI5bGxsIJfLMWrUKHzwwQdwdHSEg4MDxo8fD6VSyZ6rj7G3t5faTRaxtbWFk5OTtJzXkYiIdIUJIFVKdHQ0AKBnz55ay1esWIGRI0cCAP7zn//AzMwMr7zyCvLz8xEQEICvv/66iiM1fryORESkKxwHkIiIiMjEsA0gERERkYlhAkhERERkYpgAEhEREZkYJoBEREREJoYJIBEREZGJYQJIREREZGKYABIRERGZGCaA9FQ9e/bEpEmT9H6c+Ph4yGSyYnPd1lQVva4FBQXw8vLC/v37K3X86dOnY/z48ZXaBxERGS8mgCZu5MiRkMlkxT6XLl3S2zFLSn46d+4MlUoFuVyut+MC/0s0ZTIZzMzMIJfL0bZtW3z00UdQqVR6O56uEttly5bB09MTnTt3rtR+pkyZglWrVuHKlSs6iYuIiIwLE0BCv379oFKptD6enp5VGoOlpSXc3Nwgk8mq5HgXLlzAjRs3cOTIEUybNg07duyAr68vTp8+XSXHrwghBJYsWYJRo0ZVel/16tVDQECANJUfERGZFiaABCsrK7i5uWl9zM3NSyx79+5dBAUFoW7duqhduzb69++PixcvSutv376NN998E+7u7qhduzZatWqFX375RVo/cuRIJCQkYNGiRVJNXGpqarGaspUrV6JOnTqIi4tDixYtYGdnJyWqRR49eoQJEyagTp06cHJywrRp0xAcHIwhQ4Y885xdXFzg5uYGb29vDB06FPv27YOzszNCQkK0yn3//fdo0aIFrK2t0bx5c625d1NTUyGTyRATE4POnTvD2toavr6+SEhIkNb36tULAFC3bl3IZDJpfmQA0Gg0+Oijj+Do6Ag3NzfMmjXrqTEfO3YMly9fxsCBA4vF8Ntvv6Fbt26wsbHB888/j+TkZBw5cgQdOnSAnZ0d+vfvj3/++Udrf4GBgYiJiXnmtSIiopqHCSCVy8iRI3H06FFs3LgRBw4cgBACAwYMwMOHDwEAeXl5aN++Pf78808kJSVhzJgxeOutt3D48GEAwKJFi6BUKjF69GipttHDw6PEY92/fx+ff/45fvrpJ/z1119IS0vDlClTpPXz58/Hzz//jBUrVmDfvn3Izs7G+vXrK3ReNjY2eP/997Fv3z5kZGQAAH7++WfMnDkTc+fOxblz5zBv3jzMmDEDq1at0tp26tSp+PDDD3HixAkolUoEBgbi9u3b8PDwwH//+18AhTWOKpUKixYtkrZbtWoVbG1tcejQIXz22WeYPXs2tm/fXmqMe/bsgbe3N+zt7YutCw8Px7///W8cP34ctWrVwrBhw/DRRx9h0aJF2LNnDy5duoSZM2dqbdOxY0f8/fffSE1NrdA1IyIiIybIpAUHBwtzc3Nha2srfV599VVpfY8ePcTEiROFEEIkJycLAGLfvn3S+lu3bgkbGxvx22+/lXqMgQMHig8//LDEfRbZvXu3ACDu3r0rhBBixYoVAoC4dOmSVGbp0qXC1dVV+u7q6ioWLFggfX/06JFo2LChGDx4cKmxPHmcx23ZskUAEIcOHRJCCNGkSROxZs0arTKffvqpUCqVQgghUlJSBAARFRUlrX/48KFo0KCBmD9//lOP16NHD9G1a1etZc8//7yYNm1aqbFPnDhR9O7dW2tZUQzff/+9tOyXX34RAMTOnTulZZGRkaJZs2Za22ZlZQkAIj4+vtRjEhFRzVTLUIknVR+9evXSagtma2tbYrlz586hVq1a6NSpk7TMyckJzZo1w7lz5wAAarUa8+bNw2+//Ybr16+joKAA+fn5qF27drnjql27Npo0aSJ9VygUUu1cVlYWbt68iY4dO0rrzc3N0b59e2g0mnIfCyhsYwcAMpkMubm5uHz5MkaNGoXRo0dLZR49elSso4pSqZT+XatWLXTo0EG6Hk/j5+en9f3x8yvJgwcPYG1t/cx9ubq6AgBatWqltezJfdvY2AAorGklIiLTwgSQYGtrCy8vL53sa8GCBVi0aBEWLlyIVq1awdbWFpMmTUJBQUG592VhYaH1XSaTSUmaPhQlbY0bN8a9e/cAAN99951Wwgug1PaR5VXS+T0tea1Xr16pnVQe31dRR5onlz257zt37gAAnJ2dyxc4EREZPbYBpDJr0aIFHj16hEOHDknLbt++jQsXLsDHxwcAsG/fPgwePBgjRoxA69at8dxzzyE5OVlrP5aWllCr1ZWKRS6Xw9XVFUeOHJGWqdVqHD9+vEL7e/DgAb799lt0794dzs7OcHV1Rf369XHlyhV4eXlpfZ7sIX3w4EHp348ePcKxY8fQokULAIXnWhRbZbVt2xbnz5/XWRKclJQECwsLtGzZUif7IyIi48EaQCqzpk2bYvDgwRg9ejS++eYb2NvbY/r06XB3d8fgwYOlMrGxsdi/fz/q1q2LL7/8Ejdv3pQSRKCwhu3QoUNITU2FnZ0dHB0dKxTP+PHjERkZCS8vLzRv3hyLFy/G3bt3yzSUTEZGBvLy8pCTk4Njx47hs88+w61bt/D7779LZSIiIjBhwgTI5XL069cP+fn5OHr0KO7evYsPPvhAKrd06VI0bdoULVq0wH/+8x/cvXsX77zzDgCgUaNGkMlk+OOPPzBgwADY2NjAzs6uQufbq1cv3Lt3D2fOnIGvr2+F9vG4PXv2SD2HiYjItLAGkMplxYoVaN++PQYNGgSlUgkhBDZv3iy9bvz3v/+Ndu3aISAgAD179oSbm1uxYVmmTJkCc3Nz+Pj4wNnZGWlpaRWKZdq0aXjzzTcRFBQEpVIJOzs7BAQElNpO7nHNmjVD/fr10b59e0RFRaFv375ISkrSSlTfffddfP/991ixYgVatWqFHj16YOXKlcVqAKOiohAVFYXWrVtj79692LhxI+rVqwcAcHd3R0REBKZPnw5XV1eMGzeuQucKFLa3fPnll/Hzzz9XeB+Pi4mJ0WrfSEREpkMm9NmoiqgKaTQatGjRAq+//jo+/fRTvR8vNTUVnp6eOHHiBNq0aaP34wHAqVOn4O/vj8uXL1e4JhEAtmzZgg8//BCnTp1CrVp8EUBEZGpYA0hG6+rVq/juu++QnJyM06dPIyQkBCkpKRg2bJihQ9MbPz8/zJ8/HykpKZXaT25uLlasWMHkj4jIRPHpT0bLzMwMK1euxJQpUyCEgK+vL3bs2CF1wKipHp9NpKJeffXVygdCRERGi6+AiYiIiEwMXwETERERmRgmgEREREQmhgkgERERkYlhAkhERERkYpgAEhEREZkYJoBEREREJoYJIBEREZGJYQJIREREZGKYABIRERGZmP8D9Qh1LUR96i8AAAAASUVORK5CYII=", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# First plot cost as a function of depth, touchdown_distance, and floating_cable_depth to get a\n", + "# sense for the 1d relationships\n", + "\n", + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + "}\n", + "parametric_depth = ParametricManager(config, parameters, results, product=True)\n", + "parametric_depth.run()\n", + "\n", + "parameters = {\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + "}\n", + "parametric_touchdown = ParametricManager(config, parameters, results, product=True)\n", + "parametric_touchdown.run()\n", + "\n", + "parameters = {\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + "}\n", + "parametric_floating_depth = ParametricManager(config, parameters, results, product=True)\n", + "parametric_floating_depth.run()\n", + "\n", + "x_depth = parametric_depth.results[\"site.depth\"]\n", + "z_depth = parametric_depth.results[\"array_system_system_cost\"]\n", + "x_touchdown = parametric_touchdown.results[\"array_system_design.touchdown_distance\"]\n", + "z_touchdown = parametric_touchdown.results[\"array_system_system_cost\"]\n", + "x_floating_depth = parametric_floating_depth.results[\"array_system_design.floating_cable_depth\"]\n", + "z_floating_depth = parametric_floating_depth.results[\"array_system_system_cost\"]\n", + "\n", + "fig = plt.figure()\n", + "\n", + "ax = fig.add_subplot(2, 2, 1)\n", + "ax.set_title(\"Depth\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "ax.scatter(x_depth, z_depth)\n", + "\n", + "ax = fig.add_subplot(2, 2, 2)\n", + "ax.set_title(\"Touchdown Distance\")\n", + "ax.set_xlabel(\"Touchdown Distaince (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "ax.scatter(x_touchdown, z_touchdown)\n", + "\n", + "ax = fig.add_subplot(2, 2, 3)\n", + "ax.set_title(\"Floating Depth\")\n", + "ax.set_xlabel(\"Floating Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "ax.scatter(x_floating_depth, z_floating_depth)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations." ] @@ -500,13 +590,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations." ] @@ -525,9 +615,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", "overflow encountered in coshRuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", @@ -546,9 +636,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", "overflow encountered in cosh" @@ -561,32 +651,69 @@ "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" ] - }, + } + ], + "source": [ + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 50, 10)],\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + "}\n", + "results = {\n", + " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", + "}\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "x = parametric.results[\"site.depth\"]\n", + "y_touchdown = parametric.results[\"array_system_design.touchdown_distance\"]\n", + "y_floating_depth = parametric.results[\"array_system_design.floating_cable_depth\"]\n", + "z = parametric.results[\"array_system_system_cost\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "curve_depth_touchdown = quadratic_2d(x, y_touchdown, z)\n", + "curve_depth_floatingdepth = quadratic_2d(x, y_floating_depth, z)\n", + "curve_floatingdepth_touchdown = quadratic_2d(y_touchdown, y_floating_depth, z)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ { "data": { "text/plain": [ "Text(0.5, 0, 'Cost ($)')" ] }, - "execution_count": 14, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ca8953cdfee94567a200a72992f93eee", + "model_id": "4cd2416166324e50a795eec41cfac40b", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -599,57 +726,72 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - " \"array_system_design.touchdown_distance\": [i for i in range(0, 200, 10)],\n", - " \"array_system_design.floating_cable_depth\": DEPTHS,\n", - "}\n", - "results = {\n", - " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", - "}\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", + "array_shape = (len(DEPTHS), -1, len(DEPTHS))\n", "\n", - "x = parametric.results[\"site.depth\"]\n", - "y_touchdown = parametric.results[\"array_system_design.touchdown_distance\"]\n", - "y_floating_depth = parametric.results[\"array_system_design.floating_cable_depth\"]\n", - "z = parametric.results[\"array_system_system_cost\"]\n", + "x = np.reshape(x, array_shape)\n", + "y_touchdown = np.reshape(y_touchdown, array_shape)\n", + "y_floating_depth = np.reshape(y_floating_depth, array_shape)\n", + "z = np.reshape(z, array_shape)\n", "\n", - "curve_depth_touchdown = quadratic_2d(x, y_touchdown, z)\n", - "curve_depth_floatingdepth = quadratic_2d(x, y_floating_depth, z)\n", - "curve_floatingdepth_touchdown = quadratic_2d(y_touchdown, y_floating_depth, z)\n", + "curve_depth_touchdown = np.reshape(curve_depth_touchdown, array_shape)\n", + "curve_depth_floatingdepth = np.reshape(curve_depth_floatingdepth, array_shape)\n", + "curve_floatingdepth_touchdown = np.reshape(curve_floatingdepth_touchdown, array_shape)\n", "\n", "fig = plt.figure()\n", "\n", - "ax = fig.add_subplot(1, 3, 1, projection='3d')\n", + "ax = fig.add_subplot(2, 2, 1, projection='3d')\n", "ax.set_title(\"Depth vs Touchdown Distance\")\n", - "ax.scatter(x, y_touchdown, zs=z, zdir='z')\n", + "ax.scatter(\n", + " x[:,:,0],\n", + " y_touchdown[:,:,0],\n", + " zs=z[:,:,0],\n", + " zdir='z'\n", + ")\n", "ax.plot_surface(\n", - " np.reshape(x, (len(DEPTHS), -1)),\n", - " np.reshape(y_touchdown, (len(DEPTHS), -1)),\n", - " np.reshape(curve_depth_touchdown, (len(DEPTHS), -1)),\n", + " x[:,:,0],\n", + " y_touchdown[:,:,0],\n", + " z[:,:,0],\n", " alpha=0.3,\n", ")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Touchdown distance (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", "\n", - "ax = fig.add_subplot(1, 3, 2, projection='3d')\n", + "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", "ax.set_title(\"Depth vs Floating Cable Depth\")\n", - "ax.scatter(x, y_floating_depth, zs=z, zdir='z')\n", + "ax.scatter(\n", + " x[:,0,:],\n", + " y_floating_depth[:,0,:],\n", + " zs=z[:,0,:],\n", + " zdir='z'\n", + ")\n", "ax.plot_surface(\n", - " np.reshape(x, (len(DEPTHS), -1)),\n", - " np.reshape(y_floating_depth, (len(DEPTHS), -1)),\n", - " np.reshape(curve_depth_floatingdepth, (len(DEPTHS), -1)),\n", + " x[:,0,:],\n", + " y_floating_depth[:,0,:],\n", + " z[:,0,:],\n", " alpha=0.3,\n", ")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Floating Cable Depth (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", "\n", - "# TODO: This runs the three parameters as a product. To plot, reduce the data to 2 parameters." + "ax = fig.add_subplot(2, 2, 3, projection='3d')\n", + "ax.set_title(\"Touchdown Distance vs Floating Cable Depth\")\n", + "ax.scatter(\n", + " y_touchdown[0,:,:],\n", + " y_floating_depth[0,:,:],\n", + " zs=z[0,:,:],\n", + " zdir='z'\n", + ")\n", + "ax.plot_surface(\n", + " y_touchdown[0,:,:],\n", + " y_floating_depth[0,:,:],\n", + " z[0,:,:],\n", + " alpha=0.3,\n", + ")\n", + "ax.set_xlabel(\"Touchdown distance (m)\")\n", + "ax.set_ylabel(\"Floating Cable Depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")" ] }, { @@ -669,35 +811,30 @@ "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "PathCollection.set() got an unexpected keyword argument 'zs'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 30\u001b[0m\n\u001b[1;32m 21\u001b[0m curve_cost_depth \u001b[38;5;241m=\u001b[39m linear_1d(\n\u001b[1;32m 22\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.depth\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 23\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexport_system_system_cost\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 24\u001b[0m )\n\u001b[1;32m 25\u001b[0m curve_distance_to_landfall \u001b[38;5;241m=\u001b[39m linear_1d(\n\u001b[1;32m 26\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.distance_to_landfall\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 27\u001b[0m parametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mexport_system_system_cost\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 28\u001b[0m )\n\u001b[0;32m---> 30\u001b[0m \u001b[43max\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mscatter\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 31\u001b[0m \u001b[43m \u001b[49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msite.depth\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 32\u001b[0m \u001b[43m \u001b[49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msite.distance_to_landfall\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 33\u001b[0m \u001b[43m \u001b[49m\u001b[43mzs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mparametric\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresults\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mexport_system_system_cost\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 34\u001b[0m \u001b[43m \u001b[49m\u001b[43mzdir\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mz\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 35\u001b[0m \u001b[43m \u001b[49m\u001b[43mlabel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mHVAC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 36\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m 37\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 38\u001b[0m xs\u001b[38;5;241m=\u001b[39mparametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.depth\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 39\u001b[0m ys\u001b[38;5;241m=\u001b[39mcurve_cost_depth,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 42\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHVAC cost(depth)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 43\u001b[0m )\n\u001b[1;32m 44\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\n\u001b[1;32m 45\u001b[0m xs\u001b[38;5;241m=\u001b[39mparametric\u001b[38;5;241m.\u001b[39mresults[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msite.distance_to_landfall\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[1;32m 46\u001b[0m ys\u001b[38;5;241m=\u001b[39mcurve_distance_to_landfall,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 49\u001b[0m label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHVAC cost(distance_to_landfall)\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 50\u001b[0m )\n", - "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/__init__.py:1473\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1470\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 1471\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21minner\u001b[39m(ax, \u001b[38;5;241m*\u001b[39margs, data\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 1472\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1473\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1474\u001b[0m \u001b[43m \u001b[49m\u001b[43max\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1475\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;28;43mmap\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1476\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43msanitize_sequence\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1478\u001b[0m bound \u001b[38;5;241m=\u001b[39m new_sig\u001b[38;5;241m.\u001b[39mbind(ax, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 1479\u001b[0m auto_label \u001b[38;5;241m=\u001b[39m (bound\u001b[38;5;241m.\u001b[39marguments\u001b[38;5;241m.\u001b[39mget(label_namer)\n\u001b[1;32m 1480\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m bound\u001b[38;5;241m.\u001b[39mkwargs\u001b[38;5;241m.\u001b[39mget(label_namer))\n", - "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/axes/_axes.py:4901\u001b[0m, in \u001b[0;36mAxes.scatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4897\u001b[0m keys_str \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m k \u001b[38;5;129;01min\u001b[39;00m extra_keys)\n\u001b[1;32m 4898\u001b[0m _api\u001b[38;5;241m.\u001b[39mwarn_external(\n\u001b[1;32m 4899\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNo data for colormapping provided via \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 4900\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mParameters \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkeys_str\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m will be ignored\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 4901\u001b[0m \u001b[43mcollection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_internal_update\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4903\u001b[0m \u001b[38;5;66;03m# Classic mode only:\u001b[39;00m\n\u001b[1;32m 4904\u001b[0m \u001b[38;5;66;03m# ensure there are margins to allow for the\u001b[39;00m\n\u001b[1;32m 4905\u001b[0m \u001b[38;5;66;03m# finite size of the symbols. In v2.x, margins\u001b[39;00m\n\u001b[1;32m 4906\u001b[0m \u001b[38;5;66;03m# are present by default, so we disable this\u001b[39;00m\n\u001b[1;32m 4907\u001b[0m \u001b[38;5;66;03m# scatter-specific override.\u001b[39;00m\n\u001b[1;32m 4908\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mpl\u001b[38;5;241m.\u001b[39mrcParams[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m_internal.classic_mode\u001b[39m\u001b[38;5;124m'\u001b[39m]:\n", - "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/artist.py:1216\u001b[0m, in \u001b[0;36mArtist._internal_update\u001b[0;34m(self, kwargs)\u001b[0m\n\u001b[1;32m 1209\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_internal_update\u001b[39m(\u001b[38;5;28mself\u001b[39m, kwargs):\n\u001b[1;32m 1210\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 1211\u001b[0m \u001b[38;5;124;03m Update artist properties without prenormalizing them, but generating\u001b[39;00m\n\u001b[1;32m 1212\u001b[0m \u001b[38;5;124;03m errors as if calling `set`.\u001b[39;00m\n\u001b[1;32m 1213\u001b[0m \n\u001b[1;32m 1214\u001b[0m \u001b[38;5;124;03m The lack of prenormalization is to maintain backcompatibility.\u001b[39;00m\n\u001b[1;32m 1215\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 1216\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_update_props\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1217\u001b[0m \u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{cls.__name__}\u001b[39;49;00m\u001b[38;5;124;43m.set() got an unexpected keyword argument \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\n\u001b[1;32m 1218\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;132;43;01m{prop_name!r}\u001b[39;49;00m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/bos/lib/python3.11/site-packages/matplotlib/artist.py:1190\u001b[0m, in \u001b[0;36mArtist._update_props\u001b[0;34m(self, props, errfmt)\u001b[0m\n\u001b[1;32m 1188\u001b[0m func \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mset_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mk\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m 1189\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mcallable\u001b[39m(func):\n\u001b[0;32m-> 1190\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[1;32m 1191\u001b[0m errfmt\u001b[38;5;241m.\u001b[39mformat(\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mtype\u001b[39m(\u001b[38;5;28mself\u001b[39m), prop_name\u001b[38;5;241m=\u001b[39mk))\n\u001b[1;32m 1192\u001b[0m ret\u001b[38;5;241m.\u001b[39mappend(func(v))\n\u001b[1;32m 1193\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ret:\n", - "\u001b[0;31mAttributeError\u001b[0m: PathCollection.set() got an unexpected keyword argument 'zs'" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3a36d4943fab42a89e232877c8fd73e8", + "model_id": "4a21a0f67c154c9fab570a2d2f566a5c", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -710,9 +847,6 @@ } ], "source": [ - "fig, ax = plt.subplots()\n", - "ax.set_title(\"Export System\")\n", - "\n", "config = deepcopy(base_config)\n", "config[\"design_phases\"] = [\"ExportSystemDesign\"]\n", "distance_to_landfall = [i for i in range(0, 400, 10)]\n", @@ -724,110 +858,65 @@ " \"export_system_system_cost\": lambda run: run.design_results[\"export_system\"][\"system_cost\"],\n", "}\n", "\n", + "## Run ORBIT for each hvac and hvdc export system types\n", "\n", - "## HVAC\n", "config[\"export_system_design\"][\"cables\"] = \"XLPE_1000mm_220kV\"\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", + "parametric_hvac = ParametricManager(config, parameters, results, product=True)\n", + "parametric_hvac.run()\n", "\n", - "curve_cost_depth = linear_1d(\n", - " parametric.results[\"site.depth\"],\n", - " parametric.results[\"export_system_system_cost\"]\n", - ")\n", - "curve_distance_to_landfall = linear_1d(\n", - " parametric.results[\"site.distance_to_landfall\"],\n", - " parametric.results[\"export_system_system_cost\"]\n", - ")\n", + "config[\"export_system_design\"][\"cables\"] = \"HVDC_2000mm_320kV\"\n", + "parametric_hvdc = ParametricManager(config, parameters, results, product=True)\n", + "parametric_hvdc.run()\n", "\n", - "ax.scatter(\n", - " parametric.results[\"site.depth\"],\n", - " parametric.results[\"site.distance_to_landfall\"],\n", - " zs=parametric.results[\"export_system_system_cost\"],\n", - " zdir='z',\n", - " label=\"HVAC\"\n", - ")\n", - "ax.plot(\n", - " xs=parametric.results[\"site.depth\"],\n", - " ys=curve_cost_depth,\n", - " zs=0,\n", - " zdir=\"y\",\n", - " label='HVAC cost(depth)'\n", - ")\n", - "ax.plot(\n", - " xs=parametric.results[\"site.distance_to_landfall\"],\n", - " ys=curve_distance_to_landfall,\n", - " zs=0,\n", - " zdir=\"x\",\n", - " label='HVAC cost(distance_to_landfall)'\n", - ")\n", + "## Fit the data to a curve\n", "\n", - "## HVDC\n", - "config[\"export_system_design\"][\"cables\"] = \"XLPE_1000mm_220kV\"\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", + "x_hvac = parametric_hvac.results[\"site.depth\"]\n", + "y_hvac = parametric_hvac.results[\"site.distance_to_landfall\"]\n", + "z_hvac = parametric_hvac.results[\"export_system_system_cost\"]\n", + "curve_hvac = linear_2d(x_hvac, y_hvac, z_hvac)\n", "\n", - "curve_cost_depth = linear_1d(\n", - " parametric.results[\"site.depth\"],\n", - " parametric.results[\"export_system_system_cost\"]\n", - ")\n", - "curve_distance_to_landfall = linear_1d(\n", - " parametric.results[\"site.distance_to_landfall\"],\n", - " parametric.results[\"export_system_system_cost\"]\n", - ")\n", + "x_hvdc = parametric_tlp.results[\"site.depth\"]\n", + "y_hvdc = parametric_tlp.results[\"mooring_system_design.draft_depth\"]\n", + "z_hvdc = parametric_tlp.results[\"mooring_system_system_cost\"]\n", + "curve_hvdc = linear_2d(x_hvdc, y_hvdc, z_hvdc)\n", "\n", - "ax.scatter(\n", - " parametric.results[\"site.depth\"],\n", - " parametric.results[\"site.distance_to_landfall\"],\n", - " zs=parametric.results[\"export_system_system_cost\"],\n", - " zdir='z',\n", - " label=\"HVDC\"\n", - ")\n", - "ax.plot(\n", - " xs=parametric.results[\"site.depth\"],\n", - " ys=curve_cost_depth,\n", - " zs=0,\n", - " zdir=\"y\",\n", - " label='HVDC cost(depth)'\n", - ")\n", - "ax.plot(\n", - " xs=parametric.results[\"site.distance_to_landfall\"],\n", - " ys=curve_distance_to_landfall,\n", - " zs=0,\n", - " zdir=\"x\",\n", - " label='HVDC cost(distance_to_landfall)'\n", - ")\n", + "## Plot the ORBIT data and curve fits\n", + "\n", + "fig = plt.figure()\n", "\n", + "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", + "ax.set_title(\"HVAC\")\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Distance to landfall (km)\")\n", + "ax.set_ylabel(\"Distance to Landfall (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", - "ax.legend()\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - "}\n", - "results = {\n", - " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", - "}\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", - "\n", - "curve = linear_1d(DEPTHS, parametric.results[\"array_system_system_cost\"])\n", - "\n", - "ax.scatter(DEPTHS, parametric.results[\"array_system_system_cost\"], marker=\"+\")\n", - "ax.plot(DEPTHS, curve)\n", + "ax.scatter(x_hvac, y_hvac, z_hvac)\n", + "ax.plot_surface(\n", + " np.reshape(x_hvac, (len(DEPTHS), -1)),\n", + " np.reshape(y_hvac, (len(DEPTHS), -1)),\n", + " np.reshape(curve_hvac, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + ")\n", "\n", + "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + "ax.set_title(\"HVDC\")\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Cost ($)\")\n", - "# ax.legend()" + "ax.set_ylabel(\"Distance to Landfall (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "ax.scatter(x_hvdc, y_hvdc, zs=z_hvdc, zdir='z')\n", + "ax.plot_surface(\n", + " np.reshape(x_hvdc, (len(DEPTHS), -1)),\n", + " np.reshape(y_hvdc, (len(DEPTHS), -1)),\n", + " np.reshape(curve_hvdc, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + ")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 11e3899a47bd403e5fc994477ea753bd2d046db3 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Fri, 9 Aug 2024 16:04:44 -0500 Subject: [PATCH 217/240] Add a cost model for semisubmersible substructure --- examples/cost_curves.ipynb | 122 +++++++++++++++++++++++++++++++------ 1 file changed, 103 insertions(+), 19 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 4c82dbe8..d14c42d8 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -143,7 +143,7 @@ " curve = line_eval(slope, intercept, x)\n", " return curve\n", "\n", - "def quadratic(x, y, fit_check=False):\n", + "def quadratic_1d(x, y, fit_check=False):\n", " pass\n", "\n", "def logarithmic(x, y, fit_check=False):\n", @@ -237,7 +237,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec96ade62b464c0192a3454a765ebb5b", + "model_id": "0cdeefc2f0f3471fb8418e42d633f782", "version_major": 2, "version_minor": 0 }, @@ -311,6 +311,90 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Semi-Submersible Substructure\n", + "\n", + "Since the semisubmersible is a floating structure, the water depth does not impact the mass\n", + "of the structure.\n", + "The mean wind speed does impact the mass of the structure by the load transferred from the\n", + "turbine, but this is not included in the design phase cost model directly.\n", + "The plot here shows that the cost is constant with respect to the water depth." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Cost ($)')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4cd252e362604739b74932775841664a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "config = deepcopy(base_config)\n", + "config[\"design_phases\"] = [\"SemiSubmersibleDesign\"]\n", + "parameters = {\n", + " \"site.depth\": DEPTHS,\n", + "}\n", + "results = {\n", + " \"substructure_unit_cost\": lambda run: run.design_results[\"substructure\"][\"unit_cost\"],\n", + "}\n", + "parametric = ParametricManager(config, parameters, results, product=True)\n", + "parametric.run()\n", + "\n", + "x = parametric.results[\"site.depth\"]\n", + "z = parametric.results[\"substructure_unit_cost\"]\n", + "\n", + "curve = linear_1d(x, z)\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "ax.set_title(\"Semisubmersible Substructure\")\n", + "\n", + "# Plot the ORBIT data\n", + "ax.scatter(x, z)\n", + "\n", + "# Plot the curve\n", + "ax.plot(x, curve)\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -330,23 +414,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "81b71b9f9f6343c69752883d9765966f", + "model_id": "dcf51fc167304dda903e60a661f749c6", "version_major": 2, "version_minor": 0 }, @@ -461,23 +545,23 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7e89f3a890bb42a0877628cc8b02d659", + "model_id": "8f66a12d903e40deacb547c87a0e90a0", "version_major": 2, "version_minor": 0 }, @@ -558,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -675,7 +759,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -686,7 +770,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -695,14 +779,14 @@ "Text(0.5, 0, 'Cost ($)')" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4cd2416166324e50a795eec41cfac40b", + "model_id": "12b069d883ad437982411ff7d88a45a7", "version_major": 2, "version_minor": 0 }, @@ -807,23 +891,23 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4a21a0f67c154c9fab570a2d2f566a5c", + "model_id": "8c30afeea32b4d80aeb86e54e0c4d562", "version_major": 2, "version_minor": 0 }, From f9dc724703d40f835572b7af8586a333ecd451cc Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Mon, 12 Aug 2024 22:17:53 -0500 Subject: [PATCH 218/240] Add curve types and update all curves --- examples/cost_curves.ipynb | 971 +++++++++++++++++++------------------ 1 file changed, 509 insertions(+), 462 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index d14c42d8..4d5eeb61 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -22,6 +22,7 @@ "from copy import deepcopy\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import pandas as pd\n", "from scipy import stats, optimize, linalg\n", "\n", "from ORBIT import (\n", @@ -98,110 +99,294 @@ ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 3, "metadata": {}, + "outputs": [], "source": [ - "### 2D Curves" + "class CurveFit1D():\n", + " \"\"\"\n", + " This class contains static methods for fitting data to various curve types.\n", + " Though they could exist outside of a class, consolidating them into a consistent\n", + " namespace allows for a simpler API throughout the script.\n", + " \"\"\"\n", + "\n", + " # @staticmethod\n", + " # def line_eval(slope, intercept, data_points):\n", + " # return np.array([slope * i + intercept for i in data_points])\n", + "\n", + " @staticmethod\n", + " def curve_eval(coeffs, data_points):\n", + " curve = np.zeros_like(data_points)\n", + " for i, dp in enumerate(data_points):\n", + " for j in range(len(coeffs)):\n", + " curve[i] += coeffs[j] * (dp ** (len(coeffs) - 1 - j))\n", + " return curve\n", + "\n", + " @staticmethod\n", + " def linear_linreg(x, y, fit_check=False):\n", + " \"\"\"\n", + " Fits a line to a set of 2D data points with the SciPy stats library.\n", + " \"\"\"\n", + " slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)\n", + "\n", + " if fit_check:\n", + " print(f\"Slope: {slope:.6f}\")\n", + " print(f\"Intercept: {intercept:.6f}\")\n", + " print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = CurveFit1D.curve_eval(slope, intercept, x)\n", + " return curve\n", + "\n", + " @staticmethod\n", + " def linear_1d(x, y, fit_check=False):\n", + "\n", + " def f(x, a, b):\n", + " return a * x + b\n", + "\n", + " if x is pd.Series:\n", + " x = x.to_numpy(dtype=np.float64)\n", + " elif x is np.array:\n", + " x = x.astype(np.float64)\n", + " if y is pd.Series:\n", + " y = y.to_numpy(dtype=np.float64)\n", + " elif y is np.array:\n", + " y = y.astype(np.float64)\n", + "\n", + " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", + "\n", + " if fit_check:\n", + " print(f\"mesg: {mesg}\")\n", + " print(f\"ier: {ier}\")\n", + " print(f\"Coefficients: {popt}\")\n", + " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = CurveFit1D.curve_eval(popt, x)\n", + " return curve\n", + "\n", + " def quadratic_1d(x, y, fit_check=False):\n", + "\n", + " def f(x, a, b, c):\n", + " return a * x**2 + b * x + c\n", + "\n", + " if x is pd.Series:\n", + " x = x.to_numpy(dtype=np.float64)\n", + " elif x is np.array:\n", + " x = x.astype(np.float64)\n", + " if y is pd.Series:\n", + " y = y.to_numpy(dtype=np.float64)\n", + " elif y is np.array:\n", + " y = y.astype(np.float64)\n", + "\n", + " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", + "\n", + " if fit_check:\n", + " print(f\"mesg: {mesg}\")\n", + " print(f\"ier: {ier}\")\n", + " print(f\"Coefficients: {popt}\")\n", + " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = CurveFit1D.curve_eval(popt, x)\n", + " return curve\n", + "\n", + " def poly3_1d(x, y, fit_check=False):\n", + "\n", + " def f(x, a, b, c, d):\n", + " return a * x**3 + b * x**2 + c * x + d\n", + "\n", + " if x is pd.Series:\n", + " x = x.to_numpy(dtype=np.float64)\n", + " elif x is np.array:\n", + " x = x.astype(np.float64)\n", + " if y is pd.Series:\n", + " y = y.to_numpy(dtype=np.float64)\n", + " elif y is np.array:\n", + " y = y.astype(np.float64)\n", + "\n", + " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", + "\n", + " if fit_check:\n", + " print(f\"mesg: {mesg}\")\n", + " print(f\"ier: {ier}\")\n", + " print(f\"Coefficients: {popt}\")\n", + " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + "\n", + " curve = CurveFit1D.curve_eval(popt, x)\n", + " return curve\n", + "\n", + " def logarithmic(x, y, fit_check=False):\n", + " pass\n", + "\n", + " def exponential(x, y, fit_check=False):\n", + " pass" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "def line_eval(slope, intercept, data_points):\n", - " return np.array([slope * i + intercept for i in data_points])\n", - "\n", - "def linear_1d(x, y, fit_check=False):\n", + "class CurveFit2D():\n", " \"\"\"\n", - " Fits a line to a set of 2D data points with the SciPy stats library.\n", + " This class contains static methods for fitting data to various curve types.\n", + " Though they could exist outside of a class, consolidating them into a consistent\n", + " namespace allows for a simpler API throughout the script.\n", " \"\"\"\n", - " slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)\n", "\n", - " if fit_check:\n", - " print(f\"Slope: {slope:.6f}\")\n", - " print(f\"Intercept: {intercept:.6f}\")\n", - " print(f\"R-squared: {rvalue**2:.6f}\")\n", + " @staticmethod\n", + " def linear_2d(x, y, z, fit_check=False):\n", "\n", - " curve = line_eval(slope, intercept, x)\n", - " return curve\n", + " data_to_fit = np.array(list(zip(x, y, z)))\n", "\n", - "def linear_poly(x, y, fit_check=False):\n", + " # Best-fit linear plane\n", + " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", "\n", - " def f(x, a, b):\n", - " return a * x + b\n", + " # Evaluate it on the same points as the input data\n", + " Z = C[0]*x + C[1]*y + C[2]\n", "\n", - " popt, pcov = optimize.curve_fit(f, x, y)\n", - " slope, intercept = popt[0], popt[1]\n", + " return Z\n", "\n", - " if fit_check:\n", - " print(f\"Slope: {slope:.6f}\")\n", - " print(f\"Intercept: {intercept:.6f}\")\n", - " # print(f\"R-squared: {rvalue**2:.6f}\")\n", + " @staticmethod\n", + " def quadratic_2d(x, y, z, fit_check=False):\n", + " \"\"\"\n", + " Fits a quadratic surface to the data points.\n", + " x and y are the independent variables, and data is the dependent variable.\n", + " Each of the arguments should be given directly from ORBIT and they are transformed\n", + " here into the required form for use with the curve fitting library.\n", + " \"\"\"\n", "\n", - " curve = line_eval(slope, intercept, x)\n", - " return curve\n", + " data_to_fit = np.array(list(zip(x, y, z)))\n", "\n", - "def quadratic_1d(x, y, fit_check=False):\n", - " pass\n", + " # best-fit quadratic curve\n", + " A = np.c_[\n", + " np.ones(data_to_fit.shape[0]),\n", + " data_to_fit[:,:2],\n", + " np.prod(data_to_fit[:,:2], axis=1),\n", + " data_to_fit[:,:2]**2\n", + " ]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", "\n", - "def logarithmic(x, y, fit_check=False):\n", - " pass\n", + " # Evaluate it on the same points as the input data\n", + " Z = np.dot(np.c_[np.ones(x.shape), x, y, x*y, x**2, y**2], C).reshape(x.shape)\n", "\n", - "def exponential(x, y, fit_check=False):\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 3D Surfaces" + " return Z" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "def linear_2d(x, y, z, fit_check=False):\n", - "\n", - " data_to_fit = np.array(list(zip(x, y, z)))\n", - "\n", - " # Best-fit linear plane\n", - " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", - "\n", - " # Evaluate it on the same points as the input data\n", - " Z = C[0]*x + C[1]*y + C[2]\n", - "\n", - " return Z\n", - "\n", - "def quadratic_2d(x, y, z, fit_check=False):\n", + "class CostFunction():\n", " \"\"\"\n", - " Fits a quadratic surface to the data points.\n", - " x and y are the independent variables, and data is the dependent variable.\n", - " Each of the arguments should be given directly from ORBIT and they are transformed\n", - " here into the required form for use with the curve fitting library.\n", + " This class is used to create the ORBIT parameterization, fit a curve, plot the curve, and\n", + " export the function to NRWAL format.\n", + " Use of this function is limited to parameterizations that include `site.depth` and up to\n", + " one other parameter.\n", " \"\"\"\n", - "\n", - " data_to_fit = np.array(list(zip(x, y, z)))\n", - "\n", - " # best-fit quadratic curve\n", - " A = np.c_[\n", - " np.ones(data_to_fit.shape[0]),\n", - " data_to_fit[:,:2],\n", - " np.prod(data_to_fit[:,:2], axis=1),\n", - " data_to_fit[:,:2]**2\n", - " ]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", - "\n", - " # Evaluate it on the same points as the input data\n", - " Z = np.dot(np.c_[np.ones(x.shape), x, y, x*y, x**2, y**2], C).reshape(x.shape)\n", - "\n", - " return Z" + " def __init__(self, add_config: dict, parameters: dict, results: dict):\n", + " \"\"\"\n", + " _summary_\n", + "\n", + " Args:\n", + " add_config (str): Configuration settings to added to the base_config or overwrite\n", + " in the base_config. This must include the `design_phases` config.\n", + " parameters (dict): Parameters to use with ORBIT.ParametricManeger; maximum of two\n", + " parameters are supported.\n", + " results (dict): Results to use with ORBIT.ParametricManager; this must include only\n", + " one variable.\n", + " \"\"\"\n", + " self.is_3d = False\n", + "\n", + " # NOTE: base_config is a global variable\n", + " self.config = deepcopy(base_config)\n", + " self.config.update(add_config)\n", + "\n", + " self.parameters = deepcopy(parameters)\n", + " if len(self.parameters) > 2:\n", + " raise ValueError(\"This class is limited to parameterizations with one variable in addition to site.depth\")\n", + "\n", + " # Puts the parameters and results settings into variables for use in parsing the ORBIT\n", + " # results and postprocessing the data\n", + " self.parameters = deepcopy(self.parameters)\n", + " _vars = list(self.parameters.keys())\n", + " self.x_variable = _vars.pop(0) # NOTE: This assumes the first parameter is site.depth; it's not critical to functionality but good to keep in mind\n", + " if len(_vars) == 1:\n", + " self.is_3d = True\n", + " self.y_variable = _vars.pop()\n", + " self.z_variable = list(results.keys())[0]\n", + "\n", + " self.results = deepcopy(results)\n", + " if len(results) != 1:\n", + " raise ValueError(\"This class is limited to results with one variable\")\n", + "\n", + " def run(self):\n", + " self.parametric = ParametricManager(self.config, self.parameters, self.results, product=True)\n", + " self.parametric.run()\n", + "\n", + " self.x = self.parametric.results[self.x_variable]\n", + " if self.is_3d:\n", + " self.y = self.parametric.results[self.y_variable]\n", + " self.z = self.parametric.results[self.z_variable]\n", + "\n", + " def linear_1d(self):\n", + " self._linear_1d_curve = CurveFit1D.linear_1d(self.x, self.z)\n", + "\n", + " def quadratic_1d(self):\n", + " self._quadratic_1d_curve = CurveFit1D.quadratic_1d(self.x, self.z)\n", + "\n", + " def poly3_1d(self):\n", + " self._poly3_1d_curve = CurveFit1D.poly3_1d(self.x, self.z)\n", + "\n", + " def linear_2d(self):\n", + " self._linear_2d_curve = CurveFit2D.linear_2d(self.x, self.y, self.z)\n", + "\n", + " def quadratic_2d(self):\n", + " self._quadratic_2d_curve = CurveFit2D.quadratic_2d(self.x, self.y, self.z)\n", + "\n", + " def plot(\n", + " self,\n", + " ax,\n", + " plot_data: bool = False,\n", + " plot_curves: list[str] = []\n", + " ):\n", + " if plot_data:\n", + " if self.is_3d:\n", + " ax.scatter(self.x, self.y, zs=self.z, zdir='z', label=\"Data\")\n", + " else:\n", + " ax.scatter(self.x, self.z, label=\"Data\")\n", + "\n", + " for curve in plot_curves:\n", + "\n", + " if curve == \"linear_1d\":\n", + " ax.plot(self.x, self._linear_1d_curve, label=\"Linear Fit\")\n", + "\n", + " if curve == \"quadratic_1d\":\n", + " ax.plot(self.x, self._quadratic_1d_curve, label=\"Quadratic Fit\")\n", + "\n", + " if curve == \"poly3_1d\":\n", + " ax.plot(self.x, self._poly3_1d_curve, label=\"Degree 3 Polynomial Fit\")\n", + "\n", + " if curve == \"linear_2d\":\n", + " ax.plot_surface(\n", + " np.reshape(self.x, (len(DEPTHS), -1)),\n", + " np.reshape(self.y, (len(DEPTHS), -1)),\n", + " np.reshape(self._linear_2d_curve, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Linear Fit\"\n", + " )\n", + "\n", + " if curve == \"quadratic_2d\":\n", + " ax.plot_surface(\n", + " np.reshape(self.x, (len(DEPTHS), -1)),\n", + " np.reshape(self.y, (len(DEPTHS), -1)),\n", + " np.reshape(self._quadratic_2d_curve, (len(DEPTHS), -1)),\n", + " alpha=0.3,\n", + " label=\"Quadratic Fit\"\n", + " )" ] }, { @@ -224,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -234,21 +419,31 @@ "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n" ] }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0cdeefc2f0f3471fb8418e42d633f782", + "model_id": "c7e0458d083e4ca08b93fda46215c5db", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -261,54 +456,31 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"MonopileDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", - "}\n", - "results = {\n", - " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", - " \"transition_piece_unit_cost\": lambda run: run.design_results[\"transition_piece\"][\"unit_cost\"],\n", - "}\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", - "\n", - "x = parametric.results[\"site.depth\"]\n", - "y = parametric.results[\"site.mean_windspeed\"]\n", - "z = parametric.results[\"monopile_unit_cost\"]\n", + "cost_function = CostFunction(\n", + " add_config={\"design_phases\": [\"MonopileDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", + " # \"transition_piece_unit_cost\": lambda run: run.design_results[\"transition_piece\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", "\n", - "surface_linear = linear_2d(x, y, z)\n", - "surface_quadratic = quadratic_2d(x, y, z)\n", + "cost_function.linear_2d()\n", + "cost_function.quadratic_2d()\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(projection='3d')\n", "ax.set_title(\"Monopile Substructure\")\n", - "\n", - "# Plot the ORBIT data\n", - "ax.scatter(x, y, zs=z, zdir='z')\n", - "\n", - "# Plot the surface\n", - "ax.plot_surface(\n", - " np.reshape(x, (len(DEPTHS), -1)),\n", - " np.reshape(y, (len(DEPTHS), -1)),\n", - " np.reshape(surface_linear, (len(DEPTHS), -1)),\n", - " alpha=0.3,\n", - " label=\"Planar\"\n", - ")\n", - "ax.plot_surface(\n", - " np.reshape(x, (len(DEPTHS), -1)),\n", - " np.reshape(y, (len(DEPTHS), -1)),\n", - " np.reshape(surface_quadratic, (len(DEPTHS), -1)),\n", - " alpha=0.3,\n", - " label=\"Quadratic\"\n", - ")\n", - "\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Mean wind speed (m/s)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", - "ax.legend()\n", - "plt.show()" + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_2d\", \"quadratic_2d\"])\n", + "ax.legend()" ] }, { @@ -326,34 +498,34 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Text(0, 0.5, 'Cost ($)')" + "" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4cd252e362604739b74932775841664a", + "model_id": "190a19dcca9f48928d0715341bddb3e2", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -366,33 +538,27 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"SemiSubmersibleDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - "}\n", - "results = {\n", - " \"substructure_unit_cost\": lambda run: run.design_results[\"substructure\"][\"unit_cost\"],\n", - "}\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", - "\n", - "x = parametric.results[\"site.depth\"]\n", - "z = parametric.results[\"substructure_unit_cost\"]\n", + "cost_function = CostFunction(\n", + " add_config={\"design_phases\": [\"SemiSubmersibleDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results={\n", + " \"substructure_unit_cost\": lambda run: run.design_results[\"substructure\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", "\n", - "curve = linear_1d(x, z)\n", + "cost_function.linear_1d()\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot()\n", "ax.set_title(\"Semisubmersible Substructure\")\n", - "\n", - "# Plot the ORBIT data\n", - "ax.scatter(x, z)\n", - "\n", - "# Plot the curve\n", - "ax.plot(x, curve)\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Cost ($)\")" + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\"])\n", + "ax.legend()" ] }, { @@ -414,34 +580,24 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dcf51fc167304dda903e60a661f749c6", + "model_id": "912825436c4846d8bc9fcd6d5ec5fcf3", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -454,47 +610,55 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"MooringSystemDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - "}\n", + "design_phase = \"MooringSystemDesign\"\n", "results = {\n", " \"mooring_system_system_cost\": lambda run: run.design_results[\"mooring_system\"][\"system_cost\"],\n", "}\n", "\n", - "## Run ORBIT for each mooring system type\n", - "\n", "# Catenary mooring system\n", - "parameters[\"mooring_system_design.mooring_type\"] = [\"Catenary\"]\n", - "parametric_catenary = ParametricManager(config, parameters, results, product=True)\n", - "parametric_catenary.run()\n", + "cost_catenary = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"Catenary\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_catenary.run()\n", "\n", "# Tension Leg Platform (TLP) mooring system\n", - "parameters[\"mooring_system_design.mooring_type\"] = [\"TLP\"]\n", - "parameters[\"mooring_system_design.draft_depth\"] = [i for i in range(5, 100, 5)] # Draft depth 5-100 meters\n", - "parametric_tlp = ParametricManager(config, parameters, results, product=True)\n", - "parametric_tlp.run()\n", + "cost_tlp = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"TLP\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"mooring_system_design.draft_depth\": [i for i in range(5, 100, 5)] # Draft depth 5-100 meters\n", + " },\n", + " results=results\n", + ")\n", + "cost_tlp.run()\n", "\n", "# Semi-taut mooring system\n", - "parameters[\"mooring_system_design.mooring_type\"] = [\"SemiTaut\"]\n", - "parametric_semitaut = ParametricManager(config, parameters, results, product=True)\n", - "parametric_semitaut.run()\n", + "cost_semitaut = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " \"mooring_system_design\": {\"mooring_type\": \"SemiTaut\"}\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_semitaut.run()\n", "\n", "## Fit the data to a curve\n", - "\n", - "x_catenary = parametric_catenary.results[\"site.depth\"]\n", - "z_catenary = parametric_catenary.results[\"mooring_system_system_cost\"]\n", - "curve_catenary = linear_1d(x_catenary, z_catenary)\n", - "\n", - "x_tlp = parametric_tlp.results[\"site.depth\"]\n", - "y_tlp = parametric_tlp.results[\"mooring_system_design.draft_depth\"]\n", - "z_tlp = parametric_tlp.results[\"mooring_system_system_cost\"]\n", - "curve_tlp = linear_2d(x_tlp, y_tlp, z_tlp)\n", - "\n", - "x_semitaut = parametric_semitaut.results[\"site.depth\"]\n", - "z_semitaut = parametric_semitaut.results[\"mooring_system_system_cost\"]\n", - "curve_semitaut = linear_1d(x_semitaut, z_semitaut)\n", + "cost_catenary.linear_1d()\n", + "cost_tlp.linear_2d()\n", + "cost_semitaut.linear_1d()\n", "\n", "## Plot the ORBIT data and curve fits\n", "\n", @@ -504,29 +668,23 @@ "ax.set_title(\"Catenary\")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", - "ax.scatter(x_catenary, z_catenary)\n", - "ax.plot(x_catenary, curve_catenary)\n", + "cost_catenary.plot(ax, plot_data=True)\n", + "cost_catenary.plot(ax, plot_curves=[\"linear_1d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", "ax.set_title(\"TLP\")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Draft depth (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", - "ax.scatter(x_tlp, y_tlp, zs=z_tlp, zdir='z')\n", - "ax.plot_surface(\n", - " np.reshape(x_tlp, (len(DEPTHS), -1)),\n", - " np.reshape(y_tlp, (len(DEPTHS), -1)),\n", - " np.reshape(curve_tlp, (len(DEPTHS), -1)),\n", - " alpha=0.3,\n", - " label=\"Quadratic\"\n", - ")\n", + "cost_tlp.plot(ax, plot_data=True)\n", + "cost_tlp.plot(ax, plot_curves=[\"linear_2d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 3)\n", "ax.set_title(\"Semi-Taut\")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", - "ax.scatter(x_semitaut, z_semitaut)\n", - "ax.plot(x_semitaut, curve_semitaut)" + "cost_semitaut.plot(ax, plot_data=True)\n", + "cost_semitaut.plot(ax, plot_curves=[\"linear_1d\"])" ] }, { @@ -545,34 +703,24 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8f66a12d903e40deacb547c87a0e90a0", + "model_id": "b4a2512a82fe49abbfb584b0e0355c96", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -588,141 +736,88 @@ "# First plot cost as a function of depth, touchdown_distance, and floating_cable_depth to get a\n", "# sense for the 1d relationships\n", "\n", - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", + "design_phase = \"ArraySystemDesign\"\n", "results = {\n", " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", "}\n", "\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - "}\n", - "parametric_depth = ParametricManager(config, parameters, results, product=True)\n", - "parametric_depth.run()\n", - "\n", - "parameters = {\n", - " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", - "}\n", - "parametric_touchdown = ParametricManager(config, parameters, results, product=True)\n", - "parametric_touchdown.run()\n", - "\n", - "parameters = {\n", - " \"array_system_design.floating_cable_depth\": DEPTHS,\n", - "}\n", - "parametric_floating_depth = ParametricManager(config, parameters, results, product=True)\n", - "parametric_floating_depth.run()\n", + "# Water depth\n", + "cost_depth = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth.run()\n", + "\n", + "# Touchdown distance\n", + "cost_touchdown_distance = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_touchdown_distance.run()\n", + "\n", + "# Floating cable depth\n", + "cost_cable_depth = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_cable_depth.run()\n", "\n", - "x_depth = parametric_depth.results[\"site.depth\"]\n", - "z_depth = parametric_depth.results[\"array_system_system_cost\"]\n", - "x_touchdown = parametric_touchdown.results[\"array_system_design.touchdown_distance\"]\n", - "z_touchdown = parametric_touchdown.results[\"array_system_system_cost\"]\n", - "x_floating_depth = parametric_floating_depth.results[\"array_system_design.floating_cable_depth\"]\n", - "z_floating_depth = parametric_floating_depth.results[\"array_system_system_cost\"]\n", + "cost_depth.linear_1d()\n", + "cost_touchdown_distance.quadratic_1d()\n", + "cost_cable_depth.linear_1d()\n", + "cost_cable_depth.quadratic_1d()\n", + "cost_cable_depth.poly3_1d()\n", "\n", "fig = plt.figure()\n", - "\n", "ax = fig.add_subplot(2, 2, 1)\n", "ax.set_title(\"Depth\")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", - "ax.scatter(x_depth, z_depth)\n", + "cost_depth.plot(ax, plot_data=True)\n", + "cost_depth.plot(ax, plot_curves=[\"linear_1d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 2)\n", "ax.set_title(\"Touchdown Distance\")\n", - "ax.set_xlabel(\"Touchdown Distaince (m)\")\n", + "ax.set_xlabel(\"Touchdown Distance (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", - "ax.scatter(x_touchdown, z_touchdown)\n", + "cost_touchdown_distance.plot(ax, plot_data=True)\n", + "cost_touchdown_distance.plot(ax, plot_curves=[\"quadratic_1d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 3)\n", "ax.set_title(\"Floating Depth\")\n", "ax.set_xlabel(\"Floating Depth (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", - "ax.scatter(x_floating_depth, z_floating_depth)" + "cost_cable_depth.plot(ax, plot_data=True)\n", + "cost_cable_depth.plot(ax, plot_curves=[\"linear_1d\", \"quadratic_1d\", \"poly3_1d\"])" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", - "overflow encountered in coshRuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", - "overflow encountered in cosh" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", - "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", - "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:388\n", + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", "overflow encountered in cosh" @@ -738,34 +833,51 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"ArraySystemDesign\"]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - " \"array_system_design.touchdown_distance\": [i for i in range(0, 50, 10)],\n", - " \"array_system_design.floating_cable_depth\": DEPTHS,\n", - "}\n", + "# Then create functions of two variables\n", + "\n", + "design_phase = \"ArraySystemDesign\"\n", "results = {\n", " \"array_system_system_cost\": lambda run: run.design_results[\"array_system\"][\"system_cost\"],\n", "}\n", - "parametric = ParametricManager(config, parameters, results, product=True)\n", - "parametric.run()\n", "\n", - "x = parametric.results[\"site.depth\"]\n", - "y_touchdown = parametric.results[\"array_system_design.touchdown_distance\"]\n", - "y_floating_depth = parametric.results[\"array_system_design.floating_cable_depth\"]\n", - "z = parametric.results[\"array_system_system_cost\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "curve_depth_touchdown = quadratic_2d(x, y_touchdown, z)\n", - "curve_depth_floatingdepth = quadratic_2d(x, y_floating_depth, z)\n", - "curve_floatingdepth_touchdown = quadratic_2d(y_touchdown, y_floating_depth, z)" + "# Water depth vs touchdown distance\n", + "cost_depth_touchdown_distance = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth_touchdown_distance.run()\n", + "\n", + "# Water depth vs cable depth\n", + "cost_depth_cabledepth = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " },\n", + " results=results\n", + ")\n", + "cost_depth_cabledepth.run()\n", + "\n", + "# Touchdown distance vs cable depth\n", + "cost_touchdown_cabledepth = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " },\n", + " parameters={\n", + " \"array_system_design.floating_cable_depth\": DEPTHS,\n", + " \"array_system_design.touchdown_distance\": [i for i in range(0, 100, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_touchdown_cabledepth.run()" ] }, { @@ -773,31 +885,21 @@ "execution_count": 11, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, 'Cost ($)')" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "12b069d883ad437982411ff7d88a45a7", + "model_id": "50b95e00c80f4a019b27da95f2bbd04b", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -810,72 +912,34 @@ } ], "source": [ - "array_shape = (len(DEPTHS), -1, len(DEPTHS))\n", - "\n", - "x = np.reshape(x, array_shape)\n", - "y_touchdown = np.reshape(y_touchdown, array_shape)\n", - "y_floating_depth = np.reshape(y_floating_depth, array_shape)\n", - "z = np.reshape(z, array_shape)\n", - "\n", - "curve_depth_touchdown = np.reshape(curve_depth_touchdown, array_shape)\n", - "curve_depth_floatingdepth = np.reshape(curve_depth_floatingdepth, array_shape)\n", - "curve_floatingdepth_touchdown = np.reshape(curve_floatingdepth_touchdown, array_shape)\n", + "cost_depth_touchdown_distance.quadratic_2d()\n", + "cost_depth_cabledepth.quadratic_2d()\n", + "cost_touchdown_cabledepth.quadratic_2d()\n", "\n", "fig = plt.figure()\n", - "\n", "ax = fig.add_subplot(2, 2, 1, projection='3d')\n", "ax.set_title(\"Depth vs Touchdown Distance\")\n", - "ax.scatter(\n", - " x[:,:,0],\n", - " y_touchdown[:,:,0],\n", - " zs=z[:,:,0],\n", - " zdir='z'\n", - ")\n", - "ax.plot_surface(\n", - " x[:,:,0],\n", - " y_touchdown[:,:,0],\n", - " z[:,:,0],\n", - " alpha=0.3,\n", - ")\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Touchdown distance (m)\")\n", + "ax.set_ylabel(\"Touchdown Distance (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", + "cost_depth_touchdown_distance.plot(ax, plot_data=True)\n", + "cost_depth_touchdown_distance.plot(ax, plot_curves=[\"quadratic_2d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 2, projection='3d')\n", - "ax.set_title(\"Depth vs Floating Cable Depth\")\n", - "ax.scatter(\n", - " x[:,0,:],\n", - " y_floating_depth[:,0,:],\n", - " zs=z[:,0,:],\n", - " zdir='z'\n", - ")\n", - "ax.plot_surface(\n", - " x[:,0,:],\n", - " y_floating_depth[:,0,:],\n", - " z[:,0,:],\n", - " alpha=0.3,\n", - ")\n", + "ax.set_title(\"Depth v Cable Depth\")\n", "ax.set_xlabel(\"Depth (m)\")\n", - "ax.set_ylabel(\"Floating Cable Depth (m)\")\n", + "ax.set_ylabel(\"Cable Depth (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", + "cost_depth_cabledepth.plot(ax, plot_data=True)\n", + "cost_depth_cabledepth.plot(ax, plot_curves=[\"quadratic_2d\"])\n", "\n", "ax = fig.add_subplot(2, 2, 3, projection='3d')\n", - "ax.set_title(\"Touchdown Distance vs Floating Cable Depth\")\n", - "ax.scatter(\n", - " y_touchdown[0,:,:],\n", - " y_floating_depth[0,:,:],\n", - " zs=z[0,:,:],\n", - " zdir='z'\n", - ")\n", - "ax.plot_surface(\n", - " y_touchdown[0,:,:],\n", - " y_floating_depth[0,:,:],\n", - " z[0,:,:],\n", - " alpha=0.3,\n", - ")\n", - "ax.set_xlabel(\"Touchdown distance (m)\")\n", - "ax.set_ylabel(\"Floating Cable Depth (m)\")\n", - "ax.set_zlabel(\"Cost ($)\")" + "ax.set_title(\"Touchdown Distance v Floating Depth\")\n", + "ax.set_xlabel(\"Touchdown Distance (m)\")\n", + "ax.set_ylabel(\"Floating Depth (m)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_touchdown_cabledepth.plot(ax, plot_data=True)\n", + "cost_touchdown_cabledepth.plot(ax, plot_curves=[\"quadratic_2d\"])" ] }, { @@ -894,31 +958,21 @@ "execution_count": 12, "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8c30afeea32b4d80aeb86e54e0c4d562", + "model_id": "c868e9c113cd4503b85f502dde2e0a54", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -931,38 +985,41 @@ } ], "source": [ - "config = deepcopy(base_config)\n", - "config[\"design_phases\"] = [\"ExportSystemDesign\"]\n", - "distance_to_landfall = [i for i in range(0, 400, 10)]\n", - "parameters = {\n", - " \"site.depth\": DEPTHS,\n", - " \"site.distance_to_landfall\": distance_to_landfall,\n", - "}\n", + "design_phase = \"ExportSystemDesign\"\n", "results = {\n", " \"export_system_system_cost\": lambda run: run.design_results[\"export_system\"][\"system_cost\"],\n", "}\n", "\n", "## Run ORBIT for each hvac and hvdc export system types\n", "\n", - "config[\"export_system_design\"][\"cables\"] = \"XLPE_1000mm_220kV\"\n", - "parametric_hvac = ParametricManager(config, parameters, results, product=True)\n", - "parametric_hvac.run()\n", - "\n", - "config[\"export_system_design\"][\"cables\"] = \"HVDC_2000mm_320kV\"\n", - "parametric_hvdc = ParametricManager(config, parameters, results, product=True)\n", - "parametric_hvdc.run()\n", - "\n", - "## Fit the data to a curve\n", - "\n", - "x_hvac = parametric_hvac.results[\"site.depth\"]\n", - "y_hvac = parametric_hvac.results[\"site.distance_to_landfall\"]\n", - "z_hvac = parametric_hvac.results[\"export_system_system_cost\"]\n", - "curve_hvac = linear_2d(x_hvac, y_hvac, z_hvac)\n", + "cost_hvac = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " \"export_system_design\": {\"cables\": \"XLPE_1000mm_220kV\"},\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.distance_to_landfall\": [i for i in range(0, 400, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_hvac.run()\n", + "\n", + "cost_hvdc = CostFunction(\n", + " add_config={\n", + " \"design_phases\": [design_phase],\n", + " \"export_system_design\": {\"cables\": \"HVDC_2000mm_320kV\"},\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.distance_to_landfall\": [i for i in range(0, 400, 10)],\n", + " },\n", + " results=results\n", + ")\n", + "cost_hvdc.run()\n", "\n", - "x_hvdc = parametric_tlp.results[\"site.depth\"]\n", - "y_hvdc = parametric_tlp.results[\"mooring_system_design.draft_depth\"]\n", - "z_hvdc = parametric_tlp.results[\"mooring_system_system_cost\"]\n", - "curve_hvdc = linear_2d(x_hvdc, y_hvdc, z_hvdc)\n", + "cost_hvac.linear_2d()\n", + "cost_hvdc.linear_2d()\n", "\n", "## Plot the ORBIT data and curve fits\n", "\n", @@ -973,26 +1030,16 @@ "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Distance to Landfall (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", - "ax.scatter(x_hvac, y_hvac, z_hvac)\n", - "ax.plot_surface(\n", - " np.reshape(x_hvac, (len(DEPTHS), -1)),\n", - " np.reshape(y_hvac, (len(DEPTHS), -1)),\n", - " np.reshape(curve_hvac, (len(DEPTHS), -1)),\n", - " alpha=0.3,\n", - ")\n", + "cost_hvac.plot(ax, plot_data=True)\n", + "cost_hvac.plot(ax, plot_curves=[\"linear_2d\"])\n", "\n", "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", "ax.set_title(\"HVDC\")\n", "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Distance to Landfall (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", - "ax.scatter(x_hvdc, y_hvdc, zs=z_hvdc, zdir='z')\n", - "ax.plot_surface(\n", - " np.reshape(x_hvdc, (len(DEPTHS), -1)),\n", - " np.reshape(y_hvdc, (len(DEPTHS), -1)),\n", - " np.reshape(curve_hvdc, (len(DEPTHS), -1)),\n", - " alpha=0.3,\n", - ")" + "cost_hvdc.plot(ax, plot_data=True)\n", + "cost_hvdc.plot(ax, plot_curves=[\"linear_2d\"])" ] }, { From ebd7e6447ca79fa4fe022cb0963f68cf71807340 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Tue, 13 Aug 2024 14:45:15 -0500 Subject: [PATCH 219/240] Consolidate plotting and expand docs --- examples/cost_curves.ipynb | 475 ++++++++++++++++++++----------------- 1 file changed, 256 insertions(+), 219 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 4d5eeb61..0b4788b1 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -6,41 +6,18 @@ "source": [ "# Cost Curve Creator\n", "\n", - "This notebook enables fitting curves to ORBIT cost models, visualizing them,\n", - "and exporting to the NRWAL format. Functions are included for a variety of curve\n", - "shapes and more can be added as needed." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib widget\n", + "This notebook enables fitting curves to ORBIT models to create a cost function that can be\n", + "embedded in NRWAL.\n", + "A variety of curve and surface fitting options are available, and new ones can be added easily.\n", + "There are also tools for visualizing the ORBIT data and fitted curves.\n", "\n", - "from copy import deepcopy\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from scipy import stats, optimize, linalg\n", + "## Dependencies\n", "\n", - "from ORBIT import (\n", - " ParametricManager,\n", - " load_config,\n", - ")\n", + "- ORBIT\n", + "- ipympl enables interactive matplotlib elements in jupyter notebooks via the `%matplotlib widget` magic command below\n", "\n", - "# NOTE: must install:\n", - "# ipympl # enables interactive matplotlib elements in jupyter notebooks via the `%matplotlib widget` magic command above" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ "## Instructions\n", "\n", - "This notebook is used to generate cost curves for NRWAL based on the ORBIT model.\n", "Follow the steps below to configure and run the notebook.\n", "\n", "1. Create a basic ORBIT configuration file including at least the following sections:\n", @@ -48,31 +25,145 @@ "- turbine\n", "- plant\n", "\n", - "2. Configure the notebook by setting the following variables:\n", + "2. Configure the notebook by setting the following variables in the \"Configuration\" section:\n", "- `base_config_path`: the path to the ORBIT configuration file\n", - "- `DEPTHS`: the list of dea bed depths to use for the cost curves\n", + "- `DEPTHS`: a list of water depths to use for cost curves\n", + "- `MEAN_WIND_SPEED`: a list of mean wind speed to use for cost curves\n", "- Add any additional global parameter ranges\n", "\n", - "3. Run the notebook to establish a basic fit for the ORBIT data. This will also plot the ORBIT\n", + "3. Run the notebook to establish a first-pass fit for the ORBIT data. This will also plot the ORBIT\n", "data and curves.\n", "\n", "4. Refine the curve fits by swapping the curve-fit function from the options available in\n", "the \"Curve Fit Library\" section\n", "\n", + "## Practical Guidance\n", + "\n", + "This notebook specifically models spatially varying costs typically related to water depth\n", + "but in some cases other variables are considered. The same methods could be used to model\n", + "the cost relationship for other variables. The general workflow is to first create a parameterized\n", + "ORBIT model and obtain the cost as a function of the variables of interest.\n", + "Then, fit a curve or surface to the data by starting with the linear options.\n", + "Plot the data and curve fits to evaluate whether the linear forms are sufficient.\n", + "If not, move to the quadratic or higher order curve fits.\n", + "\n", + "A class `CostFunction` is provided to simplify running the ORBIT parameterization, fit the\n", + "curves to the data, and visualize the results. An example is given below to instantiate the\n", + "class:\n", + "```python\n", + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"MonopileDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"monopile_unit_cost\": lambda run: run.design_results[\"monopile\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "```\n", + "\n", + "The config parameter is a dictionary containing additional configuration parameters to add to\n", + "the basic ORBIT configuration provided through the input file created in Step 1 in the instructions.\n", + "Any parameters given in the `CostFunction` config will be added to the base configuration or\n", + "overwritten if they already exist. The parameters dictionary contains the variables to be varied\n", + "in the cost function via `ORBIT.ParametricManager`, and the results dictionary sets the results\n", + "variables from ORBIT. Each of these dictionaries are passed directly to the\n", + "`ORBIT.ParametricManager` class.\n", + "\n", + "The fitted curves are saved on the `CostFunction` object and multiple types can exist at the\n", + "same time. Two versions of one type cannot be saved at the same time. To create a curve fit,\n", + "call one of the curve fit methods on the `CostFunction` instance. Then, an attribute is saved\n", + "on the instance with the curve fit type.\n", + "\n", + "Considerations:\n", + "- The `CostFunction` class supports parameterizations of at-most 2 variables.\n", + "- One instance of the `CostFunction` class can be used to fit multiple curves for a single\n", + " cost model.\n", + "- A new `CostFunction` instance should be created for each cost model.\n", + "\n", + "## Template workflow\n", + "\n", + "The following code block provides a template for creating a cost function for a model with\n", + "two independent parameters.\n", + "\n", + "```python\n", + "\n", + "# Create the CostFunction object with the ORBIT configuration for the parameterization\n", + "cost_function = CostFunction(\n", + " config={\n", + " \"design_phases\": [\"Design\"],\n", + " },\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", + " },\n", + " results={\n", + " \"system_cost\": lambda run: run.design_results[\"system\"][\"system_cost\"],\n", + " }\n", + ")\n", + "\n", + "# Run ORBIT via ORBIT.ParametricManager\n", + "cost_function.run()\n", + "\n", + "# Fit two curves (surfaces since there are two independent parameters) to the data.\n", + "# After running the following two commands, the CostFunction object will have two related\n", + "# attributes that store the curve fits.\n", + "cost_function.fit_curve(\"linear_2d\")\n", + "cost_function.fit_curve(\"quadratic_2d\")\n", + "\n", + "# Plot the data and curves\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "ax.set_title(\"Depth vs mean wind speed\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Mean wind speed (m/s)\")\n", + "ax.set_zlabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\", \"quadratic_1d\"]) # These curves must have been generated first\n", + "# alternatively, the two lines above could be combined into a single line:\n", + "# cost_function.plot(ax, plot_data=True, plot_curves=[\"linear_1d\", \"quadratic_1d\"])\n", + "```\n", + "\n", + "## Plotting API for 2D vs 3D plots\n", + "The `CostFunction` class handles 2D and 3D data seamlessly by using the x and z parameters for 2D\n", + "and adding y for 3D. The appropriate matplotlib API is used depending if the data is 2D or 3D.\n", + "From the calling script, be sure to configure the Axes that is given to `CostFunction.plot` with\n", + "the correct settings for 3D as listed in the table below.\n", + "\n", + "| Matplotlib setting | 2D | 3D |\n", + "|---------------------|----|----|\n", + "| Independent axis labels | `ax.set_xlabel()` | `ax.set_xlabel()`, `ax.set_zlabel()` |\n", + "| Dependent axis label | `ax.set_ylabel()` | `ax.set_zlabel()` |" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", "\n", + "from copy import deepcopy\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from scipy import stats, optimize, linalg\n", "\n", - "TODO:\n", - "- Provide a template for a 1-dimensional and 2-dimensional cost function\n", - "- Compare the different mpl APIs for 2d vs 3d plots" + "from ORBIT import (\n", + " ParametricManager,\n", + " load_config,\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Global Variables\n", + "## Configuration\n", "\n", - "Replace any of these throughout the notebook to customize a curve fit or plot." + "Replace any of these throughout the notebook to customize a cost model parameterization." ] }, { @@ -104,46 +195,36 @@ "metadata": {}, "outputs": [], "source": [ - "class CurveFit1D():\n", + "class Curves():\n", " \"\"\"\n", " This class contains static methods for fitting data to various curve types.\n", " Though they could exist outside of a class, consolidating them into a consistent\n", " namespace allows for a simpler API throughout the script.\n", " \"\"\"\n", "\n", - " # @staticmethod\n", - " # def line_eval(slope, intercept, data_points):\n", - " # return np.array([slope * i + intercept for i in data_points])\n", - "\n", " @staticmethod\n", - " def curve_eval(coeffs, data_points):\n", + " def polynomial_eval(coeffs, data_points):\n", + " \"\"\"\n", + " This method evaluates a curve given a set of coefficients and data points.\n", + "\n", + " Args:\n", + " coeffs (list): A list of coefficients for the curve. The order of the\n", + " coefficients should be from highest to lowest power.\n", + " data_points (list): A list of data points at which to evaluate the curve.\n", + "\n", + " Returns:\n", + " np.array: The curve evaluated at the given data points.\n", + " \"\"\"\n", " curve = np.zeros_like(data_points)\n", " for i, dp in enumerate(data_points):\n", + "\n", + " # This loop sums the terms of the polynomial\n", " for j in range(len(coeffs)):\n", " curve[i] += coeffs[j] * (dp ** (len(coeffs) - 1 - j))\n", " return curve\n", "\n", " @staticmethod\n", - " def linear_linreg(x, y, fit_check=False):\n", - " \"\"\"\n", - " Fits a line to a set of 2D data points with the SciPy stats library.\n", - " \"\"\"\n", - " slope, intercept, rvalue, pvalue, stderr = stats.linregress(x, y)\n", - "\n", - " if fit_check:\n", - " print(f\"Slope: {slope:.6f}\")\n", - " print(f\"Intercept: {intercept:.6f}\")\n", - " print(f\"R-squared: {rvalue**2:.6f}\")\n", - "\n", - " curve = CurveFit1D.curve_eval(slope, intercept, x)\n", - " return curve\n", - "\n", - " @staticmethod\n", - " def linear_1d(x, y, fit_check=False):\n", - "\n", - " def f(x, a, b):\n", - " return a * x + b\n", - "\n", + " def fit(func, x, y, fit_check=False):\n", " if x is pd.Series:\n", " x = x.to_numpy(dtype=np.float64)\n", " elif x is np.array:\n", @@ -153,72 +234,15 @@ " elif y is np.array:\n", " y = y.astype(np.float64)\n", "\n", - " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", + " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(func, x, y, full_output=True)\n", "\n", " if fit_check:\n", " print(f\"mesg: {mesg}\")\n", " print(f\"ier: {ier}\")\n", " print(f\"Coefficients: {popt}\")\n", " # print(f\"R-squared: {rvalue**2:.6f}\")\n", - "\n", - " curve = CurveFit1D.curve_eval(popt, x)\n", - " return curve\n", - "\n", - " def quadratic_1d(x, y, fit_check=False):\n", - "\n", - " def f(x, a, b, c):\n", - " return a * x**2 + b * x + c\n", - "\n", - " if x is pd.Series:\n", - " x = x.to_numpy(dtype=np.float64)\n", - " elif x is np.array:\n", - " x = x.astype(np.float64)\n", - " if y is pd.Series:\n", - " y = y.to_numpy(dtype=np.float64)\n", - " elif y is np.array:\n", - " y = y.astype(np.float64)\n", - "\n", - " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", - "\n", - " if fit_check:\n", - " print(f\"mesg: {mesg}\")\n", - " print(f\"ier: {ier}\")\n", - " print(f\"Coefficients: {popt}\")\n", - " # print(f\"R-squared: {rvalue**2:.6f}\")\n", - "\n", - " curve = CurveFit1D.curve_eval(popt, x)\n", - " return curve\n", - "\n", - " def poly3_1d(x, y, fit_check=False):\n", - "\n", - " def f(x, a, b, c, d):\n", - " return a * x**3 + b * x**2 + c * x + d\n", - "\n", - " if x is pd.Series:\n", - " x = x.to_numpy(dtype=np.float64)\n", - " elif x is np.array:\n", - " x = x.astype(np.float64)\n", - " if y is pd.Series:\n", - " y = y.to_numpy(dtype=np.float64)\n", - " elif y is np.array:\n", - " y = y.astype(np.float64)\n", - "\n", - " popt, pcov, nfodict, mesg, ier = optimize.curve_fit(f, x, y, full_output=True)\n", - "\n", - " if fit_check:\n", - " print(f\"mesg: {mesg}\")\n", - " print(f\"ier: {ier}\")\n", - " print(f\"Coefficients: {popt}\")\n", - " # print(f\"R-squared: {rvalue**2:.6f}\")\n", - "\n", - " curve = CurveFit1D.curve_eval(popt, x)\n", - " return curve\n", - "\n", - " def logarithmic(x, y, fit_check=False):\n", - " pass\n", - "\n", - " def exponential(x, y, fit_check=False):\n", - " pass" + " \n", + " return popt" ] }, { @@ -226,59 +250,6 @@ "execution_count": 4, "metadata": {}, "outputs": [], - "source": [ - "class CurveFit2D():\n", - " \"\"\"\n", - " This class contains static methods for fitting data to various curve types.\n", - " Though they could exist outside of a class, consolidating them into a consistent\n", - " namespace allows for a simpler API throughout the script.\n", - " \"\"\"\n", - "\n", - " @staticmethod\n", - " def linear_2d(x, y, z, fit_check=False):\n", - "\n", - " data_to_fit = np.array(list(zip(x, y, z)))\n", - "\n", - " # Best-fit linear plane\n", - " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", - "\n", - " # Evaluate it on the same points as the input data\n", - " Z = C[0]*x + C[1]*y + C[2]\n", - "\n", - " return Z\n", - "\n", - " @staticmethod\n", - " def quadratic_2d(x, y, z, fit_check=False):\n", - " \"\"\"\n", - " Fits a quadratic surface to the data points.\n", - " x and y are the independent variables, and data is the dependent variable.\n", - " Each of the arguments should be given directly from ORBIT and they are transformed\n", - " here into the required form for use with the curve fitting library.\n", - " \"\"\"\n", - "\n", - " data_to_fit = np.array(list(zip(x, y, z)))\n", - "\n", - " # best-fit quadratic curve\n", - " A = np.c_[\n", - " np.ones(data_to_fit.shape[0]),\n", - " data_to_fit[:,:2],\n", - " np.prod(data_to_fit[:,:2], axis=1),\n", - " data_to_fit[:,:2]**2\n", - " ]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", - "\n", - " # Evaluate it on the same points as the input data\n", - " Z = np.dot(np.c_[np.ones(x.shape), x, y, x*y, x**2, y**2], C).reshape(x.shape)\n", - "\n", - " return Z" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], "source": [ "class CostFunction():\n", " \"\"\"\n", @@ -287,14 +258,14 @@ " Use of this function is limited to parameterizations that include `site.depth` and up to\n", " one other parameter.\n", " \"\"\"\n", - " def __init__(self, add_config: dict, parameters: dict, results: dict):\n", + " def __init__(self, config: dict, parameters: dict, results: dict):\n", " \"\"\"\n", " _summary_\n", "\n", " Args:\n", - " add_config (str): Configuration settings to added to the base_config or overwrite\n", + " config (str): Configuration settings to added to the base_config or overwrite\n", " in the base_config. This must include the `design_phases` config.\n", - " parameters (dict): Parameters to use with ORBIT.ParametricManeger; maximum of two\n", + " parameters (dict): Parameters to use with ORBIT.ParametricManager; maximum of two\n", " parameters are supported.\n", " results (dict): Results to use with ORBIT.ParametricManager; this must include only\n", " one variable.\n", @@ -303,7 +274,7 @@ "\n", " # NOTE: base_config is a global variable\n", " self.config = deepcopy(base_config)\n", - " self.config.update(add_config)\n", + " self.config.update(config)\n", "\n", " self.parameters = deepcopy(parameters)\n", " if len(self.parameters) > 2:\n", @@ -332,20 +303,79 @@ " self.y = self.parametric.results[self.y_variable]\n", " self.z = self.parametric.results[self.z_variable]\n", "\n", + "\n", + " ### --------- Curve fit functions --------- ###\n", + "\n", " def linear_1d(self):\n", - " self._linear_1d_curve = CurveFit1D.linear_1d(self.x, self.z)\n", + " def f(x, a, b):\n", + " return a * x + b\n", + " coeffs = Curves.fit(f, self.x, self.z)\n", + " self._linear_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", "\n", " def quadratic_1d(self):\n", - " self._quadratic_1d_curve = CurveFit1D.quadratic_1d(self.x, self.z)\n", + " def f(x, a, b, c):\n", + " return a * x**2 + b * x + c\n", + " coeffs = Curves.fit(f, self.x, self.z)\n", + " self._quadratic_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", "\n", " def poly3_1d(self):\n", - " self._poly3_1d_curve = CurveFit1D.poly3_1d(self.x, self.z)\n", + " def f(x, a, b, c, d):\n", + " return a * x**3 + b * x**2 + c * x + d\n", + " coeffs = Curves.fit(f, self.x, self.z)\n", + " self._poly3_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", + "\n", + " def logarithmic_1d(self):\n", + " pass\n", + "\n", + " def exponential_1d(self):\n", + " pass\n", "\n", " def linear_2d(self):\n", - " self._linear_2d_curve = CurveFit2D.linear_2d(self.x, self.y, self.z)\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # Best-fit linear plane\n", + " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " self._linear_2d_curve = C[0]*self.x + C[1]*self.y + C[2]\n", "\n", " def quadratic_2d(self):\n", - " self._quadratic_2d_curve = CurveFit2D.quadratic_2d(self.x, self.y, self.z)\n", + " \"\"\"\n", + " Fits a quadratic surface to the data points.\n", + " x and y are the independent variables, and data is the dependent variable.\n", + " Each of the arguments should be given directly from ORBIT and they are transformed\n", + " here into the required form for use with the curve fitting library.\n", + " \"\"\"\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # best-fit quadratic curve\n", + " A = np.c_[\n", + " np.ones(data_to_fit.shape[0]),\n", + " data_to_fit[:,:2],\n", + " np.prod(data_to_fit[:,:2], axis=1),\n", + " data_to_fit[:,:2]**2\n", + " ]\n", + " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " # This dot product is equivalent to the sum of the terms of the polynomial;\n", + " # np.c_[] is used to concatenate the arrays into the correct form for the dot product\n", + " # and C is the coefficients of the polynomial\n", + " self._quadratic_2d_curve = np.dot(\n", + " np.c_[\n", + " np.ones(self.x.shape),\n", + " self.x,\n", + " self.y,\n", + " self.x*self.y,\n", + " self.x**2,\n", + " self.y**2\n", + " ],\n", + " C\n", + " ).reshape(self.x.shape)\n", + "\n", + "\n", + " ### --------- Plotting functions --------- ###\n", "\n", " def plot(\n", " self,\n", @@ -402,14 +432,14 @@ "source": [ "## Monopile Substructure\n", "\n", - "Dependent variables:\n", + "Independent variables:\n", "- Water depth: impacts the mass of the monopile since it is fixed to the ocean floor\n", "- Mean wind speed: impact the mass of the monopile by the load transferred from the turbine" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -422,17 +452,17 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c7e0458d083e4ca08b93fda46215c5db", + "model_id": "9cf690f0a12b42819b2fc5bf28e37a4a", "version_major": 2, "version_minor": 0 }, @@ -457,7 +487,7 @@ ], "source": [ "cost_function = CostFunction(\n", - " add_config={\"design_phases\": [\"MonopileDesign\"]},\n", + " config={\"design_phases\": [\"MonopileDesign\"]},\n", " parameters={\n", " \"site.depth\": DEPTHS,\n", " \"site.mean_windspeed\": MEAN_WIND_SPEED,\n", @@ -498,23 +528,23 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "190a19dcca9f48928d0715341bddb3e2", + "model_id": "7618032d4a604b60a9b96a10fee4ff56", "version_major": 2, "version_minor": 0 }, @@ -539,7 +569,7 @@ ], "source": [ "cost_function = CostFunction(\n", - " add_config={\"design_phases\": [\"SemiSubmersibleDesign\"]},\n", + " config={\"design_phases\": [\"SemiSubmersibleDesign\"]},\n", " parameters={\n", " \"site.depth\": DEPTHS,\n", " },\n", @@ -580,13 +610,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "912825436c4846d8bc9fcd6d5ec5fcf3", + "model_id": "618bb16f970e42dbb3ccfe013524a037", "version_major": 2, "version_minor": 0 }, @@ -617,7 +647,7 @@ "\n", "# Catenary mooring system\n", "cost_catenary = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " \"mooring_system_design\": {\"mooring_type\": \"Catenary\"}\n", " },\n", @@ -630,7 +660,7 @@ "\n", "# Tension Leg Platform (TLP) mooring system\n", "cost_tlp = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " \"mooring_system_design\": {\"mooring_type\": \"TLP\"}\n", " },\n", @@ -644,7 +674,7 @@ "\n", "# Semi-taut mooring system\n", "cost_semitaut = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " \"mooring_system_design\": {\"mooring_type\": \"SemiTaut\"}\n", " },\n", @@ -703,13 +733,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b4a2512a82fe49abbfb584b0e0355c96", + "model_id": "701d0394cf44497bac33ae779a29b84c", "version_major": 2, "version_minor": 0 }, @@ -743,7 +773,7 @@ "\n", "# Water depth\n", "cost_depth = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -755,7 +785,7 @@ "\n", "# Touchdown distance\n", "cost_touchdown_distance = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -767,7 +797,7 @@ "\n", "# Floating cable depth\n", "cost_cable_depth = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -808,7 +838,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -819,8 +849,7 @@ "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", - "overflow encountered in cosh" + " improvement from the last ten iterations." ] }, { @@ -830,6 +859,14 @@ "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in cosh" + ] } ], "source": [ @@ -842,7 +879,7 @@ "\n", "# Water depth vs touchdown distance\n", "cost_depth_touchdown_distance = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -855,7 +892,7 @@ "\n", "# Water depth vs cable depth\n", "cost_depth_cabledepth = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -868,7 +905,7 @@ "\n", "# Touchdown distance vs cable depth\n", "cost_touchdown_cabledepth = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " },\n", " parameters={\n", @@ -882,13 +919,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "50b95e00c80f4a019b27da95f2bbd04b", + "model_id": "f119953ddac3472186a971d9eb4208f7", "version_major": 2, "version_minor": 0 }, @@ -955,13 +992,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c868e9c113cd4503b85f502dde2e0a54", + "model_id": "c268e19ad1e94f83bb84d78f32eaa497", "version_major": 2, "version_minor": 0 }, @@ -993,7 +1030,7 @@ "## Run ORBIT for each hvac and hvdc export system types\n", "\n", "cost_hvac = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " \"export_system_design\": {\"cables\": \"XLPE_1000mm_220kV\"},\n", " },\n", @@ -1006,7 +1043,7 @@ "cost_hvac.run()\n", "\n", "cost_hvdc = CostFunction(\n", - " add_config={\n", + " config={\n", " \"design_phases\": [design_phase],\n", " \"export_system_design\": {\"cables\": \"HVDC_2000mm_320kV\"},\n", " },\n", From 614f67dc3cebd4b07a9dbdf5ca7b1743f0a29360 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Tue, 13 Aug 2024 14:54:28 -0500 Subject: [PATCH 220/240] Use autolayout for plots --- examples/cost_curves.ipynb | 45 ++++++++++++++++++++------------------ 1 file changed, 24 insertions(+), 21 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 0b4788b1..303731f8 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -154,7 +154,10 @@ "from ORBIT import (\n", " ParametricManager,\n", " load_config,\n", - ")" + ")\n", + "\n", + "import matplotlib as mpl\n", + "mpl.rcParams[\"figure.autolayout\"] = True" ] }, { @@ -452,7 +455,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -462,18 +465,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9cf690f0a12b42819b2fc5bf28e37a4a", + "model_id": "be58a1197e444ab0b1fc72a0f2ffda2a", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -534,7 +537,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -544,18 +547,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7618032d4a604b60a9b96a10fee4ff56", + "model_id": "5436178715fd44d1aef36b92b2a2ad4b", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -616,18 +619,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "618bb16f970e42dbb3ccfe013524a037", + "model_id": "2e4944b6ae704adda80c6c605318f4e8", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -739,18 +742,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "701d0394cf44497bac33ae779a29b84c", + "model_id": "e98e891f1c744b868f297878f2711e0a", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACze0lEQVR4nOzdd1xV9f/A8ddlbxBEhqKggoqKMwz3zJWplWVpaMty5CgrqV+i5swytUHL1DKzr+bMvXDkHii4cDAcIAqyZXjv+f3Bl/v1yhCZF3g/H4/70Hvu55zzvudyPvd9z/kMlaIoCkIIIYQQotowqOgAhBBCCCFE+ZIEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUAghhBCimpEEUIgSWrZsGSqVihMnTlR0KEKIMlIa57m7uzsjR44svaD0UHV4j1WFJICiUsitfHMfZmZmuLq60rt3bxYvXkxKSkqZx/D999+zbNmyMt+PENXZw+d5YY/g4OCKDrXK69q1q/Z4GxgYYGNjQ6NGjXjttdfYuXNnqe1ny5YtTJs2rdS2J4rGqKIDEOJJzJgxAw8PD7Kzs4mNjSU4OJiJEyeyYMECNm7ciI+PT5nt+/vvv6dmzZry61aIMvT777/rPP/tt9/YuXNnnuVNmjQpz7CqrTp16jBnzhwA0tLSuHLlCmvXrmXFihW89NJLrFixAmNjY235S5cuYWDwZNeWtmzZwnfffSdJYDmTBFBUKn379qVt27ba5wEBAezZs4dnn32W5557jgsXLmBubl6BEQohSmL48OE6z48cOcLOnTvzLBflw9bWNs+xnzt3LuPHj+f777/H3d2defPmaV8zNTUt7xBFMcktYFHpde/enc8++4yoqChWrFihXX7x4kVefPFF7O3tMTMzo23btmzcuFFn3dxby/v37+edd97BwcEBGxsb/P39uXfvnracu7s7586dY9++fdpbIl27dtXZVmZmJu+//z6Ojo5YWloyePBg7ty5U6bvXYjqKC0tjQ8++AA3NzdMTU1p1KgRX375JYqiaMtERkaiUqnybbahUqnyXG26efMmb775Jq6urpiamuLh4cHo0aPJysrSKVeU81xRFGbOnEmdOnWwsLCgW7dunDt3Lt/3cu3aNYYMGYK9vT0WFhY8/fTTbN68WWdbNWvW5P3339cu02g02NnZYWhoSGJionb5vHnzMDIyIjU1FYCRI0diZWXFzZs3GTRoEFZWVjg6OjJ58mTUanWhx7gwhoaGLF68GG9vb7799luSkpK0rz3aBjA7O5vp06fj6emJmZkZDg4OdOzYUXsLeeTIkXz33XeA7u3/XF9++SXt27fHwcEBc3Nz2rRpw5o1a/LEpFKpGDduHOvXr6dZs2aYmprStGlTtm3blqdsUT7rxMREJk6cqP0ba9iwIfPmzUOj0RT7uOkbuQIoqoTXXnuNTz75hB07dvD2229z7tw5OnToQO3atZkyZQqWlpb85z//YdCgQfz9998MHjxYZ/1x48ZhZ2fHtGnTuHTpEkFBQURFRREcHIxKpWLhwoW89957WFlZ8emnnwLg5OSks4333nuPGjVqEBgYSGRkJAsXLmTcuHH89ddf5XYchKjqFEXhueeeY+/evbz55pu0bNmS7du38+GHH3Lz5k2+/vrrJ97mrVu38PX1JTExkVGjRtG4cWNu3rzJmjVrSE9Px8TERFu2KOf51KlTmTlzJv369aNfv36cOnWKZ555Jk8yefv2bdq3b096ejrjx4/HwcGB5cuX89xzz7FmzRoGDx6MSqWiQ4cO7N+/X7ve2bNnSUpKwsDAgH///Zf+/fsDcODAAVq1aoWVlZW2rFqtpnfv3rRr144vv/ySXbt28dVXX9GgQQNGjx79xMcql6GhIa+88gqfffYZBw8e1MbwqGnTpjFnzhzeeustfH19SU5O5sSJE5w6dYpevXrxzjvvcOvWrXxv8wMsWrSI5557jmHDhpGVlcWqVasYMmQI//zzT559Hjx4kLVr1zJmzBisra1ZvHgxL7zwAtHR0Tg4OABF+6zT09Pp0qULN2/e5J133qFu3bocOnSIgIAAYmJiWLhwYbGPm15RhKgEli5dqgDK8ePHCyxja2urtGrVSlEURenRo4fSvHlzJSMjQ/u6RqNR2rdvr3h6eubZbps2bZSsrCzt8i+++EIBlA0bNmiXNW3aVOnSpUuBsfXs2VPRaDTa5ZMmTVIMDQ2VxMTEYr1nIYSijB07Vnn4q2r9+vUKoMycOVOn3IsvvqioVCrlypUriqIoSkREhAIoS5cuzbNNQAkMDNQ+9/f3VwwMDPKtX3LP6aKe53FxcYqJiYnSv39/nXKffPKJAigjRozQLps4caICKAcOHNAuS0lJUTw8PBR3d3dFrVYriqIo8+fPVwwNDZXk5GRFURRl8eLFSr169RRfX1/l448/VhRFUdRqtWJnZ6dMmjRJu60RI0YogDJjxgyd99SqVSulTZs2ed7ro7p06aI0bdq0wNfXrVunAMqiRYu0y+rVq6fzHlu0aKH079+/0P08+hk/LD09Xed5VlaW0qxZM6V79+46ywHFxMRE+/kriqKcOXNGAZRvvvlGu6won/Xnn3+uWFpaKuHh4TqvT5kyRTE0NFSio6MLfT+VhdwCFlWGlZUVKSkpJCQksGfPHl566SVSUlK4e/cud+/eJT4+nt69e3P58mVu3ryps+6oUaN0GjKPHj0aIyMjtmzZUuT9jxo1SufWRadOnVCr1URFRZX8zQkhgJwOA4aGhowfP15n+QcffICiKGzduvWJtqfRaFi/fj0DBgzQaV+c6+FzGh5/nu/atYusrCzee+89nXITJ07M9734+vrSsWNH7TIrKytGjRpFZGQk58+f19nHoUOHgJwrfZ06daJTp04cOHAAgLCwMBITE+nUqVOe/bz77rs6zzt16sS1a9cKPS5FkXulsbBRGOzs7Dh37hyXL18u1j4ebtN97949kpKS6NSpE6dOncpTtmfPnjRo0ED73MfHBxsbG+17LepnvXr1ajp16kSNGjW03x93796lZ8+eqNVqnauxlZkkgMWwf/9+BgwYgKurKyqVivXr1z/R+tOmTct3WANLS8uyCbiaSE1NxdramitXrqAoCp999hmOjo46j8DAQADi4uJ01vX09NR5bmVlhYuLC5GRkUXef926dXWe16hRA0CnLaEQ+k7f67eoqChcXV2xtrbWWZ7bK/hJf3DduXOH5ORkmjVrVqTyjzvPc/f/aJ3i6OioLZsrKiqKRo0a5dnHo++ldevWWFhYaJO93ASwc+fOnDhxgoyMDO1rDyeTAGZmZjg6OuaJuTTqpdy2ho9+Fg+bMWMGiYmJeHl50bx5cz788EPOnj1b5H38888/PP3005iZmWFvb4+joyNBQUE67Q5zPfrZgO57LepnffnyZbZt25bn+6Nnz55A3u+PykraABZDWloaLVq04I033uD5559/4vUnT56c5xdZjx49eOqpp0orxGrnxo0bJCUl0bBhQ20j3cmTJ9O7d+98yzds2LDUYzA0NMx3ufJQw3Qh9F1Vqd8evXKXqySdH6BiznNjY2PatWvH/v37uXLlCrGxsXTq1AknJyeys7M5evQoBw4coHHjxnmSvYLiLQ1hYWFA4fVp586duXr1Khs2bGDHjh388ssvfP311/zwww+89dZbhW7/wIEDPPfcc3Tu3Jnvv/8eFxcXjI2NWbp0KStXrsxTvrQ+G41GQ69evfjoo4/yfd3Ly+uJtqevJAEshr59+9K3b98CX8/MzOTTTz/lzz//JDExkWbNmjFv3jxtr1ErKyudRrpnzpzh/Pnz/PDDD2UdepWV23i4d+/e1K9fH8ipNHN/sT3O5cuX6datm/Z5amoqMTEx9OvXT7usoC8UIaoSfa/f6tWrx65du0hJSdG58nTx4kXt6/C/K3MP95KFvFcIHR0dsbGx0SYzpREf5NQpuXUR5Fx9evSqW7169bh06VKebTz6XiDntu28efPYtWsXNWvWpHHjxqhUKpo2bcqBAwc4cOAAzz77bKm8h6JQq9WsXLkSCwuLPFcdH2Vvb8/rr7/O66+/TmpqKp07d2batGnaBLCguvXvv//GzMyM7du36wwvs3Tp0mLFXNTPukGDBqSmphb5+6OyklvAZWDcuHEcPnyYVatWcfbsWYYMGUKfPn0KbAPxyy+/4OXllW/bDfF4e/bs4fPPP8fDw4Nhw4ZRq1Ytunbtyo8//khMTEye8vkNzfLTTz+RnZ2tfR4UFMSDBw90vggtLS3zfJkIUd1UdP3Wr18/1Go13377rc7yr7/+GpVKpT1nbWxsqFmzZp72Wt9//73OcwMDAwYNGsSmTZvynebtSa8e9ezZE2NjY7755huddfPrOdqvXz+OHTvG4cOHtcvS0tL46aefcHd3x9vbW7u8U6dOZGZmsnDhQjp27KhNmjp16sTvv//OrVu3yu07RK1WM378eC5cuMD48eOxsbEpsGx8fLzOcysrKxo2bEhmZqZ2WW7zgEfrV0NDQ1Qqlc5V28jIyCdulpCrqJ/1Sy+9xOHDh9m+fXueMomJiTx48KBY+9c3cgWwlEVHR7N06VKio6NxdXUFcm6JbNu2jaVLlzJ79myd8hkZGfzxxx9MmTKlIsKtdLZu3crFixd58OABt2/fZs+ePezcuZN69eqxceNGzMzMAPjuu+/o2LEjzZs35+2336Z+/frcvn2bw4cPc+PGDc6cOaOz3aysLHr06MFLL73EpUuX+P777+nYsSPPPfectkybNm0ICgpi5syZNGzYkFq1atG9e/dyff9CVCR9qN8GDBhAt27d+PTTT4mMjKRFixbs2LGDDRs2MHHiRJ1OAG+99RZz587lrbfeom3btuzfv5/w8PA825w9ezY7duygS5cujBo1iiZNmhATE8Pq1as5ePAgdnZ2RY4vd5y9OXPm8Oyzz9KvXz9Onz7N1q1bqVmzpk7ZKVOm8Oeff9K3b1/Gjx+Pvb09y5cvJyIigr///ltnRg0/Pz+MjIy4dOkSo0aN0i7v3LkzQUFBAGWSACYlJWnHV01PT9fOBHL16lWGDh3K559/Xuj63t7edO3alTZt2mBvb8+JEydYs2YN48aN05Zp06YNAOPHj6d3794YGhoydOhQ+vfvz4IFC+jTpw+vvvoqcXFxfPfddzRs2PCJ2hE+rCif9YcffsjGjRt59tlnGTlyJG3atCEtLY3Q0FDWrFlDZGRkns+yUqq4DshVA6CsW7dO+/yff/5RAMXS0lLnYWRkpLz00kt51l+5cqViZGSkxMbGlmPUlU/uEAy5DxMTE8XZ2Vnp1auXsmjRIu3wCA+7evWq4u/vrzg7OyvGxsZK7dq1lWeffVZZs2ZNnu3u27dPGTVqlFKjRg3FyspKGTZsmBIfH6+zvdjYWKV///6KtbW1AmiHhCloiJq9e/cqgLJ3795SPx5ClAd9qN/yGyIkJSVFmTRpkuLq6qoYGxsrnp6eyvz583WGXVGUnCFE3nzzTcXW1laxtrZWXnrpJSUuLi7PMDCKoihRUVGKv7+/4ujoqJiamir169dXxo4dq2RmZiqK8mTnuVqtVqZPn664uLgo5ubmSteuXZWwsLA8Q6QoSk499eKLLyp2dnaKmZmZ4uvrq/zzzz/5HounnnpKAZSjR49ql924cUMBFDc3tzzlR4wYoVhaWuZZHhgYWOCwKw/r0qWLTr1rZWWleHp6KsOHD1d27NiR7zqPvseZM2cqvr6+ip2dnWJubq40btxYmTVrls6wWw8ePFDee+89xdHRUVGpVDqxLVmyRPH09FRMTU2Vxo0bK0uXLs03fkAZO3bsY+NRlMd/1oqS8zcWEBCgNGzYUDExMVFq1qyptG/fXvnyyy91Yq/MVIoiLdRLQqVSsW7dOgYNGgTAX3/9xbBhwzh37lyeBqlWVlY4OzvrLOvRowc2NjasW7euvEIWD1m2bBmvv/46x48fz3dYACGqM6nfhKi65BZwKWvVqhVqtZq4uLjHXo6PiIhg7969eaYnE0IIfST1mxBVhySAxZCamsqVK1e0zyMiIggJCcHe3h4vLy+GDRuGv78/X331Fa1ateLOnTvs3r0bHx8fnalrfv31V1xcXArtcSeEEOVJ6jchqomKvgddGeW2+Xj0kdvOICsrS5k6dari7u6uGBsbKy4uLsrgwYOVs2fParehVquVOnXqKJ988kkFvQuhKEWbYk6I6kTqNyGqB2kDKIQQQghRzcg4gEIIIYQQ1YwkgEIIIYQQ1Yx0AikijUbDrVu3sLa2linBhKgkFEUhJSUFV1dXnUF1RV5SxwlRuZS0fpMEsIhu3bqFm5tbRYchhCiG69evU6dOnYoOQ69JHSdE5VTc+k0SwCLKnXT8+vXrhc57KITQH8nJybi5uWnPX1EwqeOEqFxKWr9JAlhEubdEbGxspHIUooKoNQrHIhKIS8mglrUZvh72GBo8/nal3NJ8vKLUccU9/kKIslPc+k0SQCFEpbAtLIbpm84Tk5ShXeZia0bgAG/6NHOpwMiqBzn+QlQt0ipaCKH3toXFMHrFKZ3kAyA2KYPRK06xLSymgiKrHuT4C1H1SAIohNBrao3C9E3nyW/E+txl0zedR62RMe3Lghx/IaomSQCFEHrtWERCnitPD1OAmKQMjkUklF9Q1YgcfyGqJkkAhRB6LS6l4OSjOOXEk5HjL0TVJAmgEEKvRcenF6lcLWuzMo6keirqcZXjL0TlIr2AhRB6KS45g2mbzrElNLbQcirA2TZnSBJR+nw97HGxNSM2KSPfdoBy/IWonOQKoBBCryiKwqpj0fRYsI8tobEYGqjo3dQJyEk2Hpb7PHCAt4xHV0YMDVQEDvAG5PgLUZVIAiiE0BsRd9N45ecjTFkbSkrGA5rXtmXjuA78+FpbfhjeGmdb3duMzrZmBA1vLePQlbE+zVwIkuMvRJUit4CFEBUuW63h5wPXWLjrMlkPNJgZGzD5mUaMbO+OkWHO79Q+zVzo5e0sM1FUkNzjf/RaPIeu3qVDQ0c5/kJUYpIACiEq1NkbiXz8dygXYpIB6ORZk1mDmlPXwSJPWUMDFX4NHMo7RPFfBirYdPYWfx67jqudhXwWQlRikgAKISpEetYDFuwI59d/I9AoYGdhzGf9vXm+dW2Zu1dPqVQq6tTIScwDN4bRyNmKNvWk84cQlZG0ARRClLv94Xd45uv9/HIwJ/kb2NKVXe934YU2dST503NjujagX3NnstUK7644xe1kGf9PiMpIEkAhRKlTaxQOX41nQ8hNDl+N104Tdi8ti/f/E4L/r8e4ce8+rrZmLB35FIuGtqKmlWkFR132goKC8PHxwcbGBhsbG/z8/Ni6dWuB5bt27YpKpcrz6N+/v7aMoihMnToVFxcXzM3N6dmzJ5cvXy6z96BSqZj/YgsaOVlzJyWTd34/SeYDdZntTwhRNuQWsBCiVG0Li2H6pvM604c525jSr7kLG0JuEZ+WhUoFI/zcmdy7EVam1acaqlOnDnPnzsXT0xNFUVi+fDkDBw7k9OnTNG3aNE/5tWvXkpWVpX0eHx9PixYtGDJkiHbZF198weLFi1m+fDkeHh589tln9O7dm/Pnz2NmVjaDM1uaGvGTfxue+/ZfQq4n8tn6MOa94CNXb4WoRFSKosgM3kWQnJyMra0tSUlJ2NjYVHQ4QuilbWExjF5xKt8Bg3N5OVkx9wUfWtetUebxVIbz1t7envnz5/Pmm28+tuzChQuZOnUqMTExWFpaoigKrq6ufPDBB0yePBmApKQknJycWLZsGUOHDi1yHMU5VvvD7zBy6TE0Cnw+sCmv+bkXeX9CiJIpaf0mt4CFEKVCrVGYvul8ocmflakRG8Z2LJfkT9+p1WpWrVpFWloafn5+RVpnyZIlDB06FEtLSwAiIiKIjY2lZ8+e2jK2tra0a9eOw4cPF7qtzMxMkpOTdR5PqrOXIx/3aQzA9E3nORaR8MTbEEJUDEkAhRCl4lhEgs5t3/ykZj4g5Hpi+QSkp0JDQ7GyssLU1JR3332XdevW4e3t/dj1jh07RlhYGG+99ZZ2WWxszjR5Tk5OOmWdnJy0rxVkzpw52Nraah9ubm7FeDcwqnN9BrRw5YFGYcwfJ7mVeL9Y2xFClC9JAIUQpSIupWi9QYtarqpq1KgRISEhHD16lNGjRzNixAjOnz//2PWWLFlC8+bN8fX1LZU4AgICSEpK0j6uX79erO2oVCrmvdCcJi423E3N4t0VJ8nIlk4hQug7SQCFEKUiITXr8YWAWtZl0zGhsjAxMaFhw4a0adOGOXPm0KJFCxYtWlToOmlpaaxatSpPO0FnZ2cAbt++rbP89u3b2tcKYmpqqu2NnPsoLgsTI356rQ01LIw5eyOJT9eFIc3LhdBvkgAKIUokOSObT9eFMv2fwq9iqQAX25zp28T/aDQaMjMzCy2zevVqMjMzGT58uM5yDw8PnJ2d2b17t3ZZcnIyR48eLXK7wtLiZm/Bt6+2xkAFf5+6wbJDkeW6fyHEk5EEUAhRbDvOxdJrwT7+OBoNQIeGOVODPToYSO7zwAHe1Xru2ICAAPbv309kZCShoaEEBAQQHBzMsGHDAPD39ycgICDPekuWLGHQoEE4OOhOvaZSqZg4cSIzZ85k48aNhIaG4u/vj6urK4MGDSqPt6SjQ8OafNKvCQAzN1/g8NX4co9BCFE01WcALiFEqYlLzmDapnNsCc3paOBR05LZg5vj18Ah/3EAbc0IHOBNn2YuFRWyXoiLi8Pf35+YmBhsbW3x8fFh+/bt9OrVC4Do6GgMDHR/l1+6dImDBw+yY8eOfLf50UcfkZaWxqhRo0hMTKRjx45s27atzMYAfJw3O3pw7lYy607fZOzKU2wc10E7fZwQQn/IOIBFVBnGExOirCmKwl/HrzNrywVSMh5gaKDinc71Gd/DEzNjQ205tUbhWEQCcSkZ1LLOue1bEVf+5LwtutI8VhnZal784RBhN5Np6mrDmnfbY25i+PgVhRBFVtJzVq4ACiGKJOJuGgFrz3LkWs5Ybz51bJn7vA/ernkrHkMDFX4NHPIsF9WDmbEhP77Wlue+Oci5W8kErD3L1y+3lJlChNAj0gZQCFGobLWG74Ov0Hvhfo5cS8Dc2JD/69+EtaPb55v8CQFQ286cb19tjaGBivUht1hyMKKiQxJCPEQSQCFEgc7eSOS5b//li22XyHqgoZNnTXZM6sxbnepjZCjVhyicXwMHPuuf0ylk9pYLHLx8t4IjEkLk0rsaPCgoCB8fH+24VH5+fmzdurXA8l27dkWlUuV59O/fX1tm5MiReV7v06dPebwdIfSeWqNw+Go8G0JucvhqPGqNQnrWA2b+c55B3/3LhZhk7CyMWfBSC357wxc3e2nQL4puRHt3XmxTB40C4/48xfWE9IoOSQiBHrYBrFOnDnPnzsXT0xNFUVi+fDkDBw7k9OnTNG3aNE/5tWvXkpX1vwFo4+PjadGiBUOGDNEp16dPH5YuXap9bmpqWnZvQohKIr8eu/YWxqhUKuLTcs6rgS1d+exZb2payTkjnpxKpWLmoGZcvp3CmRtJjPr9JH+P9sPCRO++foSoVvTuDBwwYIDO81mzZhEUFMSRI0fyTQDt7XUHlV21ahUWFhZ5EkBTU9PHjowvRHWyLSyG0StO8egwAAnp2QDYW5rw1Ust6NaoVvkHJ6oUM2NDfnitDQO+OciFmGQ+WnOWb15pJZ1ChKhAencL+GFqtZpVq1aRlpZW5FHtlyxZwtChQ7G0tNRZHhwcTK1atWjUqBGjR48mPl4GKBXVl1qjMH3T+TzJ38OMDVV09nQst5hE1eZia873w9pgZKDin7Mx/Lj/WkWHJES1ppcJYGhoKFZWVpiamvLuu++ybt06vL29H7vesWPHCAsL46233tJZ3qdPH3777Td2797NvHnz2LdvH3379kWtLnjC8szMTJKTk3UeQlQVxyISdG775ud2cibHIhLKKSJRHfh62BP4XM6dnC+2XWRf+J0KjkiI6ksvE8BGjRoREhLC0aNHGT16NCNGjOD8+cLnGYWcq3/NmzfH19dXZ/nQoUN57rnnaN68OYMGDeKff/7h+PHjBAcHF7itOXPmYGtrq324ubmV9G0JoTdik+4XqVxcSuFJohBPani7ugx9yg2NAu+tPEVUfFpFhyREtaSXCaCJiQkNGzakTZs2zJkzhxYtWrBo0aJC10lLS2PVqlW8+eabj91+/fr1qVmzJleuXCmwTEBAAElJSdrH9evXn/h9CKGPLsWm8F3w1SKVrWVdMdOJiapLpVIxfWBTWtW1IznjAaN+O0la5oOKDkuIakcvE8BHaTQaMjMzCy2zevVqMjMzGT58+GO3d+PGDeLj43FxKXheUlNTU+1QNLkPISqzjGw1C3Zcov/iA1yJS6Ww5vcqwMU2Zwo3IUqbqZEhPwxvg6O1KZdupzB59RlkVlIhypfeJYABAQHs37+fyMhIQkNDCQgIIDg4mGHDhgHg7+9PQEBAnvWWLFnCoEGDcHDQnX4qNTWVDz/8kCNHjhAZGcnu3bsZOHAgDRs2pHfv3uXynoSoaMciEui3+ACL91zhgUahl7cTs59vhgryJIK5zwMHeFfI/L2ienCyMeOH4W0wNlSxNSyW74t4VVoIUTr0bhiYuLg4/P39iYmJwdbWFh8fH7Zv306vXr0AiI6OxsBAN2+9dOkSBw8eZMeOHXm2Z2hoyNmzZ1m+fDmJiYm4urryzDPP8Pnnn8tYgKLKS87IZt7Wi/xxNBoAR2tTZjzXlD7NnFGpVNSwMMkzDqCzrRmBA7zp06zgK+RClIY29WowY2AzAtaG8uWOS3i72NCtsQw7JER5UCly3b1IkpOTsbW1JSkpSW4Hi0phx7lYPtsQxu3knOYTr/i6MaVPE2wtjHXKqTUKxyISiEvJoJZ1zm3fqnLlT87boqvIY/XpulD+OBqNtZkRG8d1xKOm5eNXEqKaK+k5q3dXAIUQJROXnMG0TefYEhoLgEdNS2YPbo5fA4d8yxsaqAp8TYjyEDigKZdiUzgRdY+3fzvB+rEdsDKVrychypLetQEUQhSPoiisOhZNjwX72BIai6GBijFdG7B1QidJ8IReMzEy4PvhrXGyMeVKXCqv/HSEf6/cRa2RG1RClBX5iSVEFRBxN42AtWc5ci1n4GafOrbMfd4Hb1e57Skqh1NR93igzkn4Qm8mMeyXo7hIe1QhyowkgEJUEvm11dMoCj8fuMbCXZfJeqDB3NiQD57xYmR7d4wM5QK/qBwKmpc6JimD0StOETS8tSSBQpQySQCFqAS2hcXk6a3rYGmCuYkhN+7lzOrRybMmswc3x83eoqLCFOKJPW5eagWYvuk8vbydq0znJCH0gSSAQui5gq6OxKdlQRpYmhjy+aBmDG5VG5VKviBF5VKUealjkjI4FpEgbVmFKEVyj0gIPfa4qyMAlqZGDGwpyZ+onIo63/SBy3fKOBIhqhdJAIXQY0W5OhKXksmxiIRyikiI0lXU+aaXHIzgdPS9Mo5GiOpDEkAh9Njt5PtFKlfUqyhC6BtfD3tcbM0KnZvaxMiAzAcaXl92nPDbKeUWmxBVmSSAQuipG/fSWXYoqkhli3oVRQh9Y2igInCAN5D/vNQq4IsXmtOqrh2J6dm8tuQo1xPSyztMIaqcEncCSUxMZN26dRw4cICoqCjS09NxdHSkVatW9O7dm/bt25dGnEJUG2qNwvJDkXy54xLpWepCy6rImbvX18O+fIKrZqR+Kx99mrkQNLx1ofNSd21Ui5d+PEz47VReW3KU1e+2x9Fa5nMXoriKPRfwrVu3mDp1Kn/88Qeurq74+vri6uqKubk5CQkJhIWFcfLkSerVq0dgYCAvv/xyacdermROUVEeLsYm8/HfoZy5ngiAr7s9/Zo7M33TeQCdziC5V0tkjLSCFfe8rW71G+hHHfe4ealvJ2fwQtAhbty7j7eLDaveeRobM+NCtihE1VVhcwG3atWKESNGcPLkSby9vfMtc//+fdavX8/ChQu5fv06kydPLu7uhKjSMrLVfLf3CkHBV3mgUbA2NWJKv8a88lRdDAxUONuaFXp1RJQuqd8qxuPmpXayMWPFm+148YfDnI9J5q1lJ1j+hi/mJoblGKUQVUOxrwDGx8fj4FD0MZmetLy+0Ydfx6JqOhaRwJS1Z7l2Jw2AXt5OfD6wGc62uu36Hnd1RORV3PO2utVvULnquPO3knn5p8OkZDyge+Na/PhaG4xl5htRzZT0nC12AljdVKbKUVQOyRnZzN16kZVHowFwtDZlxnNN6dPMWcb0KyVy3hZdZTtWxyMTeG3JUTKyNQxq6cqCl1piID+IRDVS0nO2TH4yXbhwgaVLlxISElIWmxei0tt+LpZeC/Zpk79XfN3YNakLfZu7SPKn50pSvwUFBeHj44ONjQ02Njb4+fmxdevWQtdJTExk7NixuLi4YGpqipeXF1u2bNG+rlar+eyzz/Dw8MDc3JwGDRrw+eefU9V/2z/lbk/QsDYYGahYH3KLGf+cr/LvWYjSVOJewDNmzMDc3JwPP/wQgL1799KnTx+sra1JSkpi2bJlDBs2rMSBClFZFHarNi45g8CN59gaFguAR01LZg9uLlNc6anSrt/q1KnD3Llz8fT0RFEUli9fzsCBAzl9+jRNmzbNUz4rK4tevXpRq1Yt1qxZQ+3atYmKisLOzk5bZt68eQQFBbF8+XKaNm3KiRMneP3117G1tWX8+PElPgb6rFvjWnz1Ugsm/hXCskOR2FkYM7GnV0WHJUSlUOJbwD4+PsyZM4f+/fsD0LNnT1q1asX8+fP58ccfWbx4MefOnSuVYCtSZbs9IirGtrCYPJ01XGzNmPpsE5LuP2DWlgukZDzA0EDFO53rM76HJ2bG0oC9rJT0vC2P+s3e3p758+fz5ptv5nnthx9+YP78+Vy8eBFj4/x7uz777LM4OTmxZMkS7bIXXngBc3NzVqxYUeQ4KnMd99vhSKZuyPkcpg3wZmQHjwqOSIiyV2G9gH/77TcURSEyMpKQkBDi4+NRFIV///2XTp068dtvv6HRaLh27Rq//fYbAP7+/sXdnRB6b1tYDKNXnMozb29MUgaj/zitfe5Tx5a5z/vg7Vq5vmSrk/Ko39RqNatXryYtLQ0/P798y2zcuBE/Pz/Gjh3Lhg0bcHR05NVXX+Xjjz/G0DDnh0P79u356aefCA8Px8vLizNnznDw4EEWLFhQsoNQifj7uXMvLZuvd4UzbdN57CxMGNSqdkWHJYReK3YCWK9ePQBMTExwcnKiXr16hISEYGNjQ7du3VAUhczMTFQqFe7u7tI2Q1Rpao3C9E3n8yR/D1MBAf0a80YHD4ykx6JeK8v6LTQ0FD8/PzIyMrCysmLdunUFDjVz7do19uzZw7Bhw9iyZQtXrlxhzJgxZGdnExgYCMCUKVNITk6mcePGGBoaolarmTVr1mNvTWdmZpKZmal9npycXOT3oI/G92jIvfQslh2K5IPVZ7AxN6J7Y6eKDksIvVXsBLBLly4AtG7dmn/++YePP/6Ybdu20a9fPzp37gzkVHRubm7a50JUVcciEnRu++ZHAZrXtpPkrxIoy/qtUaNGhISEkJSUxJo1axgxYgT79u3LNwnUaDTUqlWLn376CUNDQ9q0acPNmzeZP3++NgH8z3/+wx9//MHKlStp2rQpISEhTJw4EVdXV0aMGFFgHHPmzGH69OlPFLs+U6lUTH3Wm6T72aw7fZPRK07x+5vtZJYcIQpQ4m+i+fPnExISQocOHYiKimLGjBna15YtW0afPn1Kugsh9F5cSuHJ35OWE/qhLOo3ExMTGjZsSJs2bZgzZw4tWrRg0aJF+ZZ1cXHBy8tLe7sXoEmTJsTGxpKVlQXAhx9+yJQpUxg6dCjNmzfntddeY9KkScyZM6fQOAICAkhKStI+rl+//sTvRd8YGKj44kUfejSuReYDDW8uO865W0kVHZYQeqnEvYBbtGhBZGRkvgOhTp48udI1JhaiOGpZmz2+0BOUE/qhPOo3jUajcyv2YR06dGDlypVoNBoMDHJ+r4eHh+Pi4oKJiQkA6enp2tdyGRoaotFoCt2vqakppqZVby5dY0MDvhvWGv8lxzgWmcCIX4+x+t32eNS0rOjQhNArpXYvKr9R8F1cXLC0lJNOVG0JaVn8daLwqycqcnoDy+2oyqm06reAgAD2799PZGQkoaGhBAQEEBwcrG2v5+/vT0BAgLb86NGjSUhIYMKECYSHh7N582Zmz57N2LFjtWUGDBjArFmz2Lx5M5GRkaxbt44FCxYwePDgYr7bys/M2JBfRrbF28WGu6lZDP/lKLGPaaIhRHVT7ARw1apVRS57/fp1/v333+LuSgi9pCgKG0Ju0nPBPtafvklBwzfnLg8c4C1Tt1USZVW/xcXF4e/vT6NGjejRowfHjx9n+/bt9OrVC4Do6GhiYmK05d3c3Ni+fTvHjx/Hx8eH8ePHM2HCBKZMmaIt88033/Diiy8yZswYmjRpwuTJk3nnnXf4/PPPi/weqiIbM2OWv+GLu4MFNxPv89qSo9xLy6rosITQG8UeB7BLly7ExcXx+uuvM2DAAJo0aaLzelJSEv/++y8rVqxg586dLFmyhOeee65Ugq4IlXmMLFH6btxL59N1YewLvwNAIydr5r7QnNvJGfmOAxg4wJs+zVwqKtxqq7jnbXWr36Dq1nHXE9IZ8sNhYpMzaOlmxx9vtcPStMStn4SocBU6F/DGjRv55ptv2LNnD5aWljg5OWFmZsa9e/eIjY2lZs2ajBw5kkmTJuHkVLm741fVylE8GbVGYfmhSL7ccYn0LDUmhgaM79GQUZ0bYGJkoC1T0EwgonyV5LytTvUbVO067vLtFIb8eJjE9Gw6NqzJkpFtMTWSAdhF5VahCWCuu3fvcvDgQaKiorh//z41a9akVatWtGrVKk/j5MqqKleOomguxibz8d+hnLmeCICvuz2zn29Ow1pWFRuYKFBpnLfVoX6Dql/HhVxP5NWfj5CepaZvM2e+fbW1/DATlZpeJIDVQVWvHEXBMrLVfLvnCj/su8oDjYK1qRFT+jXmlafqYiBfIHpNztuiqw7H6uDlu7yx7DhZag39mjvz9cst5UqgqLRKes5WnZ+vQpSBo9fi6bfoAN/uvcIDjcIz3k7sfL8Lw9rVk+RPiErGr4ED47o3xNBAxZbQWEb+epzUzAcVHZYQFUJawopqraD2eskZ2czdepGVR6MBcLQ25fOBTaUjhxCV1LawmDwdtA7/9wfeujHtcbCqemMiClEYSQBFtZXfF4KLrRnPtXBl3embxKXkDM77iq8bU/o2wdbcuKJCFUKUwLawGEavOJXvXN3RCen0W3SAv8e0p04Ni3KPTYiKIgmgqJYK+kKIScrgx/3XAPCoacnswc3xa5B3EGAhROWg1ihM33Q+3+Qv1+2UTF4IOsTvb7bDy8m63GIToiKVShvAGTNmkJ6enmf5/fv3debOFEIfFOULwdLUkH/e6yjJn5D6rZI7FpGgc5W/ILeTMxnyw2FORiWUQ1RCVLxSSQCnT59OampqnuXp6elMnz69NHYhRKkpyhdCWqaaszdkEnkh9VtlF5dStCng3B0sSLqfzbBfjrL3YlwZRyVExSuVBFBRFFSqvD0iz5w5g729zH0q9EtRvxCKWk5UbVK/VW61rM2KVC5wQFO6NnIkI1vD27+dYN3pG2UcmRAVq0RtAGvUqIFKpUKlUuHl5aVTSarValJTU3n33XdLHKQQpSklo2jDPhT1i0NUTVK/VQ2+Hva42JoRm5SRb7MPFeBsa0ZnL0c6etbkozVnWXf6JpP+OkNCWjZvdvQo75CFKBclSgAXLlyIoii88cYbTJ8+HVtbW+1rJiYmuLu74+fn90TbDAoKIigoiMjISACaNm3K1KlT6du3b77lu3btyr59+/Is79evH5s3bwZyfsEHBgby888/k5iYSIcOHQgKCsLT0/OJYhOVW3rWA77aEc7SfyMKLZf7heDrIVd3qrOyqN9E+TM0UBE4wJvRK06hAp0kMDelDxzgjaGBCkNUfDWkBTUsTPj13wg+/+c88amZfNi7Ub5XgYWozEqUAI4YMQIADw8POnTogJFRyTsV16lTh7lz5+Lp6YmiKCxfvpyBAwdy+vRpmjZtmqf82rVrycrK0j6Pj4+nRYsWDBkyRLvsiy++YPHixSxfvhwPDw8+++wzevfuzfnz5zEzk6s81cG+8Dt8ui6UG/fuA+DrXoNjkfce+4Ugqq+yqN9ExejTzIWg4a3zDPvkbGtG4ABvnfE9DQxUfPZsExysTJi//RLfB18lIS2LmYOaYWQocyeIqqNUpoI7deoUxsbGNG/eHIANGzawdOlSvL29mTZtGiYmJiXavr29PfPnz+fNN998bNmFCxcydepUYmJisLS0RFEUXF1d+eCDD5g8eTIASUlJODk5sWzZMoYOHVqkGKrDNElVUUJaFjP/Oc/a0zcBqG1nzszBzejWqFaB4wA++oUgKq/SOG/Lun7TF9Whjito4PeC/Hksmk/XhaJRoHdTJxYNbYWZsUwdJ/SDXkwF98477xAeHg7AtWvXePnll7GwsGD16tV89NFHxd6uWq1m1apVpKWlFflWy5IlSxg6dCiWlpYAREREEBsbS8+ePbVlbG1tadeuHYcPHy52bEK/KYrC+tM36blgH2tP30Slgtc7uLNjUme6NaoF5FwVOPhxd/58+2kWDW3Jn28/zcGPu0vyJ3SUVf0myp+hgQq/Bg4MbFkbvwYOj73K/4pvXb4f1hoTQwO2n7vNyKXHSMnILqdohShbpZIAhoeH07JlSwBWr15Nly5dWLlyJcuWLePvv/9+4u2FhoZiZWWFqakp7777LuvWrcPb2/ux6x07doywsDDeeust7bLY2FgAnJycdMo6OTlpX8tPZmYmycnJOg9ROdy4l87IpceZ+FcICWlZNHKyZu3o9gQOaIqlqe5tvCf9QhDVT2nXb6Jy6dPMhWVvPIWVqRFHriUw9Kcj3PnvLEFCVGalNgyMRqMBYNeuXfTr1w8ANzc37t69+8Tba9SoESEhIRw9epTRo0czYsQIzp8//9j1lixZQvPmzfH19X3ifT5qzpw52Nraah9ubm4l3qYoW2qNwq8HI3jm6/3sC7+DiaEBk5/xYtN7HWlVt0ZFhycqqdKu30Tl075BTVaNehoHSxPO3UpmyA+HuJ6Qd3BwISqTUkkA27Zty8yZM/n999/Zt28f/fv3B3Juvz565a0oTExMaNiwIW3atGHOnDm0aNGCRYsWFbpOWloaq1atytNO0NnZGYDbt2/rLL99+7b2tfwEBASQlJSkfVy/fv2J34coPxdjk3k+6BAz/jlPepYaX3d7tkzoxLjunpgYScNtUXylXb+JyqlZbVvWjG5PnRrmRMan83zQIS7EyJ0hUXmVyjfjwoULOXXqFOPGjePTTz+lYcOGAKxZs4b27duXePsajYbMzMIvua9evZrMzEyGDx+us9zDwwNnZ2d2796tXZacnMzRo0cLbVdoamqKjY2NzkNUHLVG4fDVeDaE3OTw1XjUmpy+SxnZar7cfolnFx/kzPVErE2NmDW4GatGPU3DWlYVHLWoCsq6fhOVh0dNS/4e3Z5GTtbcScnkpR8PcyxCpo4TlVOp9AIuSEZGBoaGhhgbGxd5nYCAAPr27UvdunVJSUlh5cqVzJs3j+3bt9OrVy/8/f2pXbs2c+bM0VmvU6dO1K5dm1WrVuXZ5rx585g7d67OMDBnz559omFgqkMPOX1VUG/dV3zdWH/6FtfupgHwjLcTMwY2w9lWhvYROcryvC1O/abPpI4ruqT0bN5cfpwTUfcwNTLgu1db09NbrgaL8lXSc7ZUB7Y6efIkFy5cAMDb25vWrVs/8Tbi4uLw9/cnJiYGW1tbfHx8tMkfQHR0NAYGuhcuL126xMGDB9mxY0e+2/zoo49IS0tj1KhRJCYm0rFjR7Zt2yZjAFYC28JiGL3iVJ4R/GOSMliw8zIAjtamfD6wqfTeFWWqNOo3UTXYWhjz+5vtGLfyFLsvxvHOipPMe8GHF9vUqejQhCiyUrkCGBcXx8svv8y+ffuws7MDIDExkW7durFq1SocHR1LuosKJ7+Oy59ao9Bx3h6dK3+PMjc25NCU7tSwrBpjsYnSVRrnbXWo30DquOLIVmv4+O+zrD2VM87oJ/0aM6pzgwqOSlQXejEO4HvvvUdqairnzp0jISGBhIQEwsLCSE5OZvz48aWxC1ENHYtIKDT5A7ifreZibEo5RSSqI6nfREGMDQ348sUWvN0pZ77g2VsuMmfrBcqwZZUQpaZUbgFv27aNXbt20aRJE+0yb29vvvvuO5555pnS2IWohuJSCk/+nrScEMUh9ZsojIGBik/7e1PTypQ5Wy/y475rJKRmMfv55hjL1HFCj5XKX6dGo8m3IbSxsbF2/CwhntQDddF+RdeylracouxI/SaK4p0uDZj3QnNUKlh98gbPLj4oYwUKvVYqCWD37t2ZMGECt27d0i67efMmkyZNokePHqWxC1GNZKs1fLf3CgHrQgstpyKnN7Cvh335BCaqJanfRFFsC4th4a7L5N79vXQ7hc7z9zJ/+8WKDUyIApRKAvjtt9+SnJyMu7s7DRo0oEGDBnh4eJCcnMw333xTGrsQ1UTI9UQGfHOQ+dsvkfVAg7eLNZCT7D0s93ngAG+Zvk2UKanfxOPkjlbwaJtlRYHv9l7lnd9PkK2Wq8VCv5TaOICKorBr1y4uXsz5tdOkSRN69uxZGpvWC9JDrmylZT7gqx3hLDsUgUaBGhbGTB3gzaCWtdl+LjbfcQADB3jL0C+iUKV13lb1+g2kjiuuooxWANCmXg2+fbUVLrbm5RSZqOpKes6W6UDQVYlUjmUn+FIcn64L42bifQAGtXTls2e9cbAy1ZZRaxSORSQQl5JBLeuc275y5U88jpy3RSfHqngOX43nlZ+PFKlsDQtjFrzckm6NapVxVKI6qNBhYPbs2YO3tzfJyXnnQ0xKSqJp06YcOHCgJLsQVVhCWhaT/gph5NLj3Ey8T207c5a+/hQLh7bSSf4ADA1U+DVwYGDL2vg1cJDkT5Q5qd9EURR1FII6Ncy5l57N60uPM2/bRR7ILWFRwUqUAC5cuJC3334738zT1taWd955hwULFpRkF6IKUhSF9adv0nPBPtadvolKBa93cGfHpM7yy1jojbKo34KCgvDx8dHOL+7n58fWrVsLXScxMZGxY8fi4uKCqakpXl5ebNmyRafMzZs3GT58OA4ODpibm9O8eXNOnDjxRLGJ4inqKASzBjXH368eAEHBV3nl5yPEJN0vy9CEKFSJEsAzZ87Qp0+fAl9/5plnOHnyZEl2IaqY6wnpjFh6nIl/hZCQlkUjJ2vWjm5P4ICmWJqW6syEQpRIWdRvderUYe7cuZw8eZITJ07QvXt3Bg4cyLlz5/Itn5WVRa9evYiMjGTNmjVcunSJn3/+mdq1a2vL3Lt3jw4dOmBsbMzWrVs5f/48X331FTVq1Hii2ETx+HrY42JrlqejWq7c0Qo6etZkxsBmfPdqa6xMjTgeeY/+iw8SfCmuPMMVQqtE37i3b98udCJ0IyMj7ty5U5JdiEoov/Z6AMsORfLl9kvcz1ZjYmjA+B4NGdW5ASZGMliq0D9lUb8NGDBA5/msWbMICgriyJEjNG3aNE/5X3/9lYSEBA4dOqSNxd3dXafMvHnzcHNzY+nSpdplHh4eTxSXKD5DAxWBA7wZveIUKtCZtzy/0Qr6+7jQ1NWGsStPce5WMiOXHmdM1wa838sLIxk4WpSjEv211a5dm7CwsAJfP3v2LC4u0kuzOtkWFkPHeXt45ecjTFgVwis/H6Hd7F10/yqYz/85z/1sNb7u9myZ0Ilx3T0l+RN6q6zrN7VazapVq0hLS8PPzy/fMhs3bsTPz4+xY8fi5OREs2bNmD17Nmq1WqdM27ZtGTJkCLVq1aJVq1b8/PPPxY5LPLk+zVwIGt4aZ1vd28HOtmYEDW+dZ7QC95qW/D26Pa89nXNL+Pv/3hKOfUxPYiFKU4l6Ab/33nsEBwdz/PhxzMx0//Dv37+Pr68v3bp1Y/HixSUOtKJJD7nHyx0Lq6A/KDNjAz571ptXnqqLgXTiEOWgJOdtWdVvoaGh+Pn5kZGRgZWVFStXrqRfv375lm3cuDGRkZEMGzaMMWPGcOXKFcaMGcP48eMJDAwE0Mb2/vvvM2TIEI4fP86ECRP44YcfGDFiRIFxZGZmkpmZqX2enJyMm5ub1HElUJzRCv45e4spf4eSmvkAe0sTFrzUgq7SFloUQYUOA3P79m1at26NoaEh48aNo1GjRgBcvHiR7777DrVazalTp3ByciruLvSGJICFK8pYWLWsTTkc0EN68IpyU5Lztqzqt6ysLKKjo0lKSmLNmjX88ssv7Nu3D29v7zxlvby8yMjIICIiAkNDQwAWLFjA/PnziYmJAcDExIS2bdty6NAh7Xrjx4/n+PHjHD58uMA4pk2bxvTp0/Mslzqu/EXeTWPMH6c4H5PT43xstwZM6im3hEXhSpqXlKgNoJOTE4cOHWL06NEEBASQm0uqVCp69+7Nd999VyWSP/F4xyISHjsQalxKJsciEvBr4FBOUQlRfGVVv5mYmNCwYUMA2rRpw/Hjx1m0aBE//vhjnrIuLi4YGxtrkz/IGYQ6NjaWrKwsTExMcHFxyZM8NmnShL///rvQOAICAnj//fe1z3OvAIry517TkrVj2jNr8wV+PxLFd3uvcjziHotfaZXntrIQpaXE3S7r1avHli1buHfvHleuXEFRFDw9PaUHWjVT1LGwilpOCH1QHvWbRqPRuRX7sA4dOrBy5Uo0Gg0GBjlXg8LDw3FxccHExERb5tKlSzrrhYeHU69evUL3a2pqiqmpaaFlRPkxMzbk80HNaFffnil/h3IsMoF+iw/w9cst6eLlWNHhiSqo1K4v16hRg6eeegpfX19J/qqZ28kZ/HEkukhlizpmlhD6pLTqt4CAAPbv309kZCShoaEEBAQQHBzMsGHDAPD39ycgIEBbfvTo0SQkJDBhwgTCw8PZvHkzs2fPZuzYsdoykyZN4siRI8yePZsrV66wcuVKfvrpJ50yovJ41seVf97riLeLDQlpWYz49Rjzt+cMHK3WKBy+Gs+GkJscvhqPWiMTeYnik4HXRLFpNAqrjl9nztYLpGQ8KLSsipwecblDwghRHcXFxeHv709MTAy2trb4+Piwfft2evXqBUB0dLT2Sh+Am5sb27dvZ9KkSfj4+FC7dm0mTJjAxx9/rC3z1FNPsW7dOgICApgxYwYeHh4sXLhQm1SKyif3lvDMzedZcSSa7/ZeZce52yTdzyYu5X9Xi2VOdFESMhdwEUknEF1X76QSsDaUYxEJAPjUseW5Fi7M2nwRyH8srPyGQxCiLMl5W3RyrPTTpjO3+HDNGTKy804dJ3Vr9VahcwGL6idbreG7vVfou+gAxyISMDc25P/6N2HdmA681anBE42FJYQQonD9mrtgXcAsSbk/tKdvOi+3g8UTk1vAoshCricy5e+zXIxNAaCTZ01mD26Om72FtkyfZi708nZ+4rGwhBBC5HUsIoE7qVkFvq4AMUkZMsKCeGKSAIrHSst8wFc7wll2KAKNAjUsjJk6wJtBLWujUuVN7AwNVFIRCSFEKZARFkRZkQRQFCr4UhyfrgvjZuJ9AAa1dOWzZ71xsJLhI4QQoqwVdeSEvRfv0MvbCQsT+VoXRSN/KSJfCWlZfP7PedadvglAbTtzZg5uRjeZokgIIcqNr4c9LrZmxCZlFDjNJsD6kJscjYgnoF8TBvi45Ht3RoiHSSeQaiy/MaUURWH96Zv0XLCPdadvolLBGx082DGpsyR/QghRzgwNVAQOyJnp5dGULvf5u13qU6eGOTFJGYz/8zQv/3iE87eSyzVOUfnIMDBFVNWGSNgWFsP0Ted1pm9ztDbB0cpMOx9lY2dr5jzfnFZ1ZWBvUTlVtfO2LMmx0m/51dkPjwOYka3m5/3X+C74ChnZGgxU8Gq7unzQqxE1LE0qMHJRVkp6zkoCWERVqXLcFhbD6BWnCrydYGSgYlIvL0Z1ro+xTEYuKrGqdN6WNTlW+k+tUR47wsLNxPvM2XKBf87GAGBrbszkZ7x4tV09GY2hipEEsJxUlcpRrVHoOG+Pzq/IRzlamXDkk55SWYhKr6qct+VBjlXVcuRaPNM2ntMO29XExYZpA7xpV7/gERqKkmAK/VHSc1Y6gVQzxyISCk3+AO6kZsmYUkIIUYk9Xd+Bf97ryMpj0Xy1I5wLMcm8/NMRBrRwJaBvY1ztzHXKP+4Ws6h65P5eNSNjSgkhRPVgZGiAv587eyd3ZVi7uqhUOVPL9fhqH9/svkxGthr4X7OgRy8OxCZlMHrFKbaFxVRE+KKMSQJYjSTdz2ZDyK0ilS3q2FNCCCH0m72lCbMGN2fTuI485V6D+9lqvtoZTq+v97E1LIZpG8/l2yZcppqr2iQBrCa2hcXQa8E+9lyMK7ScipzL/r4e9uUTmBBCiHLRrLYt/3nHj0VDW+JsY8b1hPuMXnGK2OTMAtd5eKo5UbVIAljF3U7O4J3fT/DuilPEpWTiUdOS93t5oqLgMaUCB3hLw18hhKiCVCoVA1vWZvcHXRjbrUGR63ppFlT1SCeQKkqjUVh1/DpztlwgJfMBRgYq3ulSn/e6e2JmbIiXk3WeBr/O0uBXCCGqBUtTIz7s3RjPWtZM/CvkseWlWVDVIwlgFXT1TioBa0O1l+xb1LFl7gs+NHH5XzfxPs1c6OXtLF3+hRCiGhvQwpV52y4WOjqENAuqmiQBrEKyHmj4af9VFu+5QtYDDebGhkzu3YiR7d3zTewMDVQy1IsQQlRjuVPNFTY5QJ0a5oRcv0frujVkjuEqRBLAKiLkeiJT/j6rHfSzs5cjswY1w83eooIjE0IIoc/6NHMhaHjrPM2CjA1VZKsVjkfe44WgwzR1tcHfrx7PtaiNuYnhE+9HBprWL3o3E0hQUBBBQUFERkYC0LRpU6ZOnUrfvn0LXCcxMZFPP/2UtWvXkpCQQL169Vi4cCH9+vUDYNq0aUyfPl1nnUaNGnHx4sUix6Wvo+SnZT7gqx3hLD0UgaJADQtjAgc0ZWBLV/mlJqo9fT1v9ZEcK5FfgnYhJpnfD0exPuQmmQ80QM70ci8/5cbwdvWo61C0iwwy0HTpq3IzgdSpU4e5c+fi6emJoigsX76cgQMHcvr0aZo2bZqnfFZWFr169aJWrVqsWbOG2rVrExUVhZ2dnU65pk2bsmvXLu1zIyO9e+uFyu/EPHD5Dp+uC+Nm4n0ABreqzf/1b4KDlWkFRyuEEKKyya9ZULPatsx70YeAfo1ZfeIGvx2J5HrCfX7af42fD1yjW6Na+PvVo7OnIwYFXM0raP753IGmg4a3liSwAuhdFjRgwACd57NmzSIoKIgjR47kmwD++uuvJCQkcOjQIYyNjQFwd3fPU87IyAhnZ+cyibms5ffLyczYgIzsnF9jte3Mmf18c7p4OVZUiEIIIaowOwsT3u5cnzc6erAvPI7lh6LYF36HPRfj2HMxDncHC17zc+fFNnWwNTfWrqfWKEzfdL7AgaZV5Aw03cvbWW4HlzO9HgdQrVazatUq0tLS8PPzy7fMxo0b8fPzY+zYsTg5OdGsWTNmz56NWq3WKXf58mVcXV2pX78+w4YNIzo6utB9Z2ZmkpycrPOoCAVN0ZOb/PVoXIsdkzpL8ieEEKLMGRqo6N7YieVv+LJ3clfe6OCBtZkRkfHpfP7PeZ6evZtP1oVyMTbnO/Nx88/LQNMVR++uAAKEhobi5+dHRkYGVlZWrFu3Dm9v73zLXrt2jT179jBs2DC2bNnClStXGDNmDNnZ2QQGBgLQrl07li1bRqNGjYiJiWH69Ol06tSJsLAwrK2t893unDlz8rQbLG+F/XLKdT4mGTPjJ2+MK4QQQpSER01Lpg7w5oNnvFgfcpPfDkVx6XYKK49Gs/JoNL4e9ni7FK1tmgw0Xf70rhMI5LTri46OJikpiTVr1vDLL7+wb9++fJNALy8vMjIyiIiIwNAwJxFasGAB8+fPJyYm/wmsExMTqVevHgsWLODNN9/Mt0xmZiaZmf+bHic5ORk3N7dybSB9+Go8r/x85LHl/nz7aRnORYh8SMeGopNjJUpKUXLaqv92OIpt52KfaP7g0vgeq269jKtcJxAAExMTGjZsCECbNm04fvw4ixYt4scff8xT1sXFBWNjY23yB9CkSRNiY2PJysrCxMQkzzp2dnZ4eXlx5cqVAmMwNTXF1LRiO1Ocvn6vSOXkl5MQQoiKplKpaFffgXb1HYhJus+fR6P542g08WlZBa9DzixUJR1oWnoZPzm9bgOYS6PR6FyNe1iHDh24cuUKGo1Guyw8PBwXF5d8kz+A1NRUrl69iouLfv5RZGSrmb/9Il9tDy9SeZmiRwghhD5xsTXn/WcacSigO290cC+wnAK82dE9z9z0T6KgtvK5vYy3heV/N7C607sEMCAggP379xMZGUloaCgBAQEEBwczbNgwAPz9/QkICNCWHz16NAkJCUyYMIHw8HA2b97M7NmzGTt2rLbM5MmT2bdvH5GRkRw6dIjBgwdjaGjIK6+8Uu7v73GOXIun36IDfLf3KmpFwcyo4I9IhUzRI4QQQn+ZGhkydUBTfhjemppW+V+Umbn5Im1n7WLMHyf5/UgUV+JSKWrrtMf1MoacXsZPcju6utC7W8BxcXH4+/sTExODra0tPj4+bN++nV69egEQHR2NgcH/kiI3Nze2b9/OpEmT8PHxoXbt2kyYMIGPP/5YW+bGjRu88sorxMfH4+joSMeOHTly5AiOjvrTczbpfjZzt17kz2M5vZNrWZsyY2AzQGH0ilMAOn/gub+WAgd4V+k2DkIIISq/h+efj026T3qWmuSMBxy5Fs/xyAQS0rLYEhrLltBYIOc7sH0DB/waONC+Qc0CZ7V6kl7G0lZel152AtFHZdlAeltYLFM3hBGXknOb+9V2dfm4T2PtWErStkGI4pGODUUnx0pUlGy1hrM3Ejl0JZ7D1+I5EXWPrAcanTJ1apjjV9+B9g0d8KtfE2fbnKZPG0JuMmFVyGP3sWhoSwa2rF2iOPWtk0mV7ARSXdxOziBwwzm2ncv5xVO/piVznm9Ou/q6v1Ie/uWkL394QgghRGkwNjSgTT172tSz570enmRkqzkVfY8jV+M5dDWekOuJ3Lh3n9Unb7D65A0g5/vSr4EDDpZF66xZ0rbyVfFCjN61AawONBqFlUej6blgH9vOxWJkoOK97g3ZMqFTnuQvV+4UPQNb1savgYMkf0JUQkFBQfj4+GBjY4ONjQ1+fn5s3bq10HUSExMZO3YsLi4umJqa4uXlxZYtW/ItO3fuXFQqFRMnTiyD6IUoH2bGhrRvUJP3n2nEmtHtORP4DMvf8OWdLvVpUccWAxVcu5vGH0ejWbzncqHbKo228lW1k4lcASxnV++kErA2VDvqeQs3O+a90JzGznLLRYiqrqzmOgc4fvw4P/74Iz4+PuXwToQoP5amRnTxctTOeJV0P5tjEQkcvhrPoat3uRibUuC6CuBoZcqn60JxtDalplXOI+f/Jjham2JlaoRKlf9FldKeyk6tUUi+n03i/WzupWeRmJ5FYno299KzSUzP+u+ybCY/0wj3mpaPPzglIAlgKSuojUC2WsNP+6+xaPdlsh5osDAxZPIzjRjR3l2u5glRTZTVXOepqakMGzaMn3/+mZkzZ5ZJ7ELoC1tzY3p5O9HL2wmA+NRMfth3lT+ORpOepc5T/uzNJM7eTCpwe6ZGBtrk8OF/Ha1MSEjLLlInk18OXMPFzvyhhC7n35ykLuffxPvZJN3Ppig9L1rUseONjh5lmh9IJ5AiKkpjy4LaCPj71WNDyC3tr5QuXo7MHNSswF5NQojSoc8dG9RqNatXr2bEiBGcPn0635mO+vXrh729PRYWFmzYsAFHR0deffVVPv74Y53B70eMGIG9vT1ff/01Xbt2pWXLlixcuLDQ/evDbEdClKbcCzA37qVjamRA7RoWxKdmcjc1izspmdxNzfzfv6mZ3E3JJC2fhLE8WJkaYWtuTA1LY2pYmHA/S835mGSdBPZxbQylE4ieyG0j8Gg2HZOUwbxtlwCoYWFM4ICmDGzpWuDlZiFE1Vbac52vWrWKU6dOcfz48SeKQx/mOxeiNOW2lYeiD/eSnvWAuylZ3Hk4OXzo34i7aVyOS33sdtxqmONqZ04NCxPsLIyxszChhoXxQ//PeW5rYYyduQkmD43xW1D+kNvGMGh46zLpaCJXAIuosExbrVHoOG9PoZeJzY0N2PdhN2rZyKwdQpQXfbwCWJpznV+/fp22bduyc+dObds/uQIoROnJ/X6PTcrItx0g5FypO/hx92Ldrn1c/pA7VV5+2y9p/Sa9gEvB4waiBLifreHqnbRyikgIoa9y5zpv06YNc+bMoUWLFixatCjfsi4uLnh5eRU41/nJkyeJi4ujdevWGBkZYWRkxL59+1i8eDFGRkao1QXf3jI1NdX2Rs59CCF0GRqoCByQ8+Ps0fRO9d9HSSZkeJKBrEubJIClIC6l8OTvScsJIaqPksx13qNHD0JDQwkJCdE+2rZty7BhwwgJCdFJHIUQxdOnmQtBw1trB5/O5WxrVuLbsxWZP0gbwFJQ1AEmSzoQpRCicgsICKBv377UrVuXlJQUVq5cSXBwMNu3bwdy5jqvXbs2c+bMAXLmOv/222+ZMGEC7733HpcvX2b27NmMHz8eAGtra5o1a6azD0tLSxwcHPIsF0IUX1lNyFCR+YMkgKXA18MeF1uzAtsI5N7DL8lAlEKIyq8s5joXQpSP/3UyKT0VmT9IJ5Aielxjy9xePIDOh5j726CsevEIIQqmj51A9JUcKyEqRnHzB+kEoifKso2AEEIIIaqmisof5BZwKSqrNgJCCCGEqLoqIn+QBLCIcu+UJycnP7ZsU0djmjrmTNuUllrwHIVCiLKVe75KS5fHe5I6TghRNp4kfyhp/SYJYBGlpOR8EG5ubhUciRDiSaWkpGBra1vRYeg1qeOEqJyKW79JJ5Ai0mg03Lp1C2tra5nGrQhyZxW4fv26NCgvRXJcn4yiKKSkpODq6qrTu1bkVdQ6rrL/DUr8FUviLz0lrd/kCmARGRgYUKdOnYoOo9KRGQbKhhzXopMrf0XzpHVcZf8blPgrlsRfOkpSv8lPYiGEEEKIakYSQCGEEEKIakYSQFEmTE1NCQwMxNTUtKJDqVLkuIqKVtn/BiX+iiXx6w/pBCKEEEIIUc3IFUAhhBBCiGpGEkAhhBBCiGpGEkAhhBBCiGpGEkAhhBBCiGpGEkBRbHPmzOGpp57C2tqaWrVqMWjQIC5duqRTJiMjg7Fjx+Lg4ICVlRUvvPACt2/frqCIK6e5c+eiUqmYOHGidpkcV1FRvvvuO9zd3TEzM6Ndu3YcO3asokPKV1WqnypjHXDz5k2GDx+Og4MD5ubmNG/enBMnTmhfVxSFqVOn4uLigrm5OT179uTy5csVGPH/qNVqPvvsMzw8PDA3N6dBgwZ8/vnnOnPu6nP8RaYIUUy9e/dWli5dqoSFhSkhISFKv379lLp16yqpqanaMu+++67i5uam7N69Wzlx4oTy9NNPK+3bt6/AqCuXY8eOKe7u7oqPj48yYcIE7XI5rqIirFq1SjExMVF+/fVX5dy5c8rbb7+t2NnZKbdv367o0PKoKvVTZawDEhISlHr16ikjR45Ujh49qly7dk3Zvn27cuXKFW2ZuXPnKra2tsr69euVM2fOKM8995zi4eGh3L9/vwIjzzFr1izFwcFB+eeff5SIiAhl9erVipWVlbJo0SJtGX2Ov6gkARSlJi4uTgGUffv2KYqiKImJiYqxsbGyevVqbZkLFy4ogHL48OGKCrPSSElJUTw9PZWdO3cqXbp00Vb+clxFRfH19VXGjh2rfa5WqxVXV1dlzpw5FRhV0VTG+qmy1gEff/yx0rFjxwJf12g0irOzszJ//nztssTERMXU1FT5888/yyPEQvXv31954403dJY9//zzyrBhwxRF0f/4i0puAYtSk5SUBIC9vT0AJ0+eJDs7m549e2rLNG7cmLp163L48OEKibEyGTt2LP3799c5fiDHVVSMrKwsTp48qfN3Z2BgQM+ePSvF311lrJ8qax2wceNG2rZty5AhQ6hVqxatWrXi559/1r4eERFBbGysTvy2tra0a9dOL+Jv3749u3fvJjw8HIAzZ85w8OBB+vbtC+h//EVlVNEBiKpBo9EwceJEOnToQLNmzQCIjY3FxMQEOzs7nbJOTk7ExsZWQJSVx6pVqzh16hTHjx/P85ocV1ER7t69i1qtxsnJSWe5k5MTFy9erKCoiqYy1k+VuQ64du0aQUFBvP/++3zyySccP36c8ePHY2JiwogRI7Qx5ve3pA/xT5kyheTkZBo3boyhoSFqtZpZs2YxbNgwAL2Pv6gkARSlYuzYsYSFhXHw4MGKDqXSu379OhMmTGDnzp2YmZlVdDhCVHqVrX6q7HWARqOhbdu2zJ49G4BWrVoRFhbGDz/8wIgRIyo4usf7z3/+wx9//MHKlStp2rQpISEhTJw4EVdX10oRf1HJLWBRYuPGjeOff/5h79691KlTR7vc2dmZrKwsEhMTdcrfvn0bZ2fnco6y8jh58iRxcXG0bt0aIyMjjIyM2LdvH4sXL8bIyAgnJyc5rqLc1axZE0NDwzw9TfX9764y1k+VvQ5wcXHB29tbZ1mTJk2Ijo4G0Maor39LH374IVOmTGHo0KE0b96c1157jUmTJjFnzhxA/+MvKkkARbEpisK4ceNYt24de/bswcPDQ+f1Nm3aYGxszO7du7XLLl26RHR0NH5+fuUdbqXRo0cPQkNDCQkJ0T7atm3LsGHDtP+X4yrKm4mJCW3atNH5u9NoNOzevVsv/+4qc/1U2euADh065BlyJzw8nHr16gHg4eGBs7OzTvzJyckcPXpUL+JPT0/HwEA3PTI0NESj0QD6H3+RVXQvFFF5jR49WrG1tVWCg4OVmJgY7SM9PV1b5t1331Xq1q2r7NmzRzlx4oTi5+en+Pn5VWDUldPDPQAVRY6rqBirVq1STE1NlWXLlinnz59XRo0apdjZ2SmxsbEVHVoeVa1+qkx1wLFjxxQjIyNl1qxZyuXLl5U//vhDsbCwUFasWKEtM3fuXMXOzk7ZsGGDcvbsWWXgwIF6M4zKiBEjlNq1a2uHgVm7dq1Ss2ZN5aOPPtKW0ef4i0oSQFFsQL6PpUuXasvcv39fGTNmjFKjRg3FwsJCGTx4sBITE1NxQVdSj1b+clxFRfnmm2+UunXrKiYmJoqvr69y5MiRig4pX1WtfqpsdcCmTZuUZs2aKaampkrjxo2Vn376Sed1jUajfPbZZ4qTk5Niamqq9OjRQ7l06VIFRasrOTlZmTBhglK3bl3FzMxMqV+/vvLpp58qmZmZ2jL6HH9RqRTloaGthRBCCCFElSdtAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAIUQQgghqhlJAEW1FhkZiUqlIiQk5InX3b17N02aNEGtVhd7/1lZWbi7u3PixIlib0MIIYR4UpIAigozcuRIVCoVKpUKY2NjnJyc6NWrF7/++qt2zsXS3t+gQYNKbXsfffQR//d//4ehoWGxt2FiYsLkyZP5+OOPSy0uIUTxde3alYkTJz7xeiqVivXr15d6POVh2bJl2NnZVXQYZUZ+rOdPEkBRofr06UNMTAyRkZFs3bqVbt26MWHCBJ599lkePHhQ0eEV6ODBg1y9epUXXnihxNsaNmwYBw8e5Ny5c6UQmRCVW+6PwoIe06ZNq+gQK42Hj5ulpSWenp6MHDmSkydP6pR7+eWXCQ8PL9I2K2OyKD/W8ycJoKhQpqamODs7U7t2bVq3bs0nn3zChg0b2Lp1K8uWLdOWS0xM5K233sLR0REbGxu6d+/OmTNntK9PmzaNli1b8uOPP+Lm5oaFhQUvvfQSSUlJ2teXL1/Ohg0btBVicHCwdv1r167RrVs3LCwsaNGiBYcPHy407lWrVtGrVy/MzMzyxPDrr79St25drKysGDNmDGq1mi+++AJnZ2dq1arFrFmzdLZVo0YNOnTowKpVq0pwJIWoGmJiYrSPhQsXYmNjo7Ns8uTJFR1ipbJ06VJiYmI4d+4c3333HampqbRr147ffvtNW8bc3JxatWpVYJRlR36sF0wSQKF3unfvTosWLVi7dq122ZAhQ4iLi2Pr1q2cPHmS1q1b06NHDxISErRlrly5wn/+8x82bdrEtm3bOH36NGPGjAFg8uTJvPTSS9orjjExMbRv31677qeffsrkyZMJCQnBy8uLV155pdArkAcOHKBt27Z5ll+9epWtW7eybds2/vzzT5YsWUL//v25ceMG+/btY968efzf//0fR48e1VnP19eXAwcOFPuYCVFVODs7ax+2traoVCrt81q1arFgwQLq1KmDqakpLVu2ZNu2bdp1g4ODUalUJCYmapeFhISgUqmIjIzULvv333/p2rUrFhYW1KhRg969e3Pv3j3t6xqNho8++gh7e3ucnZ3zXHW8fPkynTt3xszMDG9vb3bu3JnnfYSGhtK9e3fMzc1xcHBg1KhRpKamAhAWFoaBgQF37twBICEhAQMDA4YOHapdf+bMmXTs2FHnfe3evZu2bdtiYWFB+/btuXTp0mOPp52dHc7Ozri7u/PMM8+wZs0ahg0bxrhx47Tv+dGremfOnKFbt25YW1tjY2NDmzZtOHHiBMHBwbz++uskJSXluSL7+++/07ZtW6ytrXF2dubVV18lLi4uz2fzuPewadMmnnrqKczMzKhZsyaDBw/WvpaZmcnkyZOpXbs2lpaWtGvXTueHfH7kx3rBJAEUeqlx48baCvvgwYMcO3aM1atX07ZtWzw9Pfnyyy+xs7NjzZo12nUyMjL47bffaNmyJZ07d+abb75h1apVxMbGYmVlhbm5ufaKo7OzMyYmJtp1J0+eTP/+/fHy8mL69OlERUVx5cqVAuOLiorC1dU1z3KNRsOvv/6Kt7c3AwYMoFu3bly6dImFCxfSqFEjXn/9dRo1asTevXt11nN1dSUqKqqER02Iqm3RokV89dVXfPnll5w9e5bevXvz3HPPcfny5SJvIyQkhB49euDt7c3hw4c5ePAgAwYM0Gkftnz5ciwtLTl69ChffPEFM2bM0CZ5Go2G559/HhMTE44ePcoPP/yQ57ZgWloavXv3pkaNGhw/fpzVq1eza9cuxo0bB0DTpk1xcHBg3759QM4PyoefA+zbt4+uXbvqbPfTTz/lq6++4sSJExgZGfHGG2880fHLNWnSJFJSUvJNXCHnSledOnU4fvw4J0+eZMqUKRgbG9O+ffs8V2Vzr8hmZ2fz+eefc+bMGdavX09kZCQjR47Ms+3C3sPmzZsZPHgw/fr14/Tp0+zevRtfX1/t6+PGjePw4cOsWrWKs2fPMmTIEPr06VPo5y8/1guhCFFBRowYoQwcODDf11566SXF29tbURRF+fbbbxUDAwPF0tJS52FgYKB89NFHiqIoSmBgoOLh4aGzjcTERAVQgoODC9xfRESEAijHjh3TLktISFAAZd++fQXGbmJiovznP//RWRYYGKiNOZe/v7/Sr18/nWWdO3dWJk2apLPsp59+UmrVqlXg/oSojpYuXarY2tpqn7u6uiqzZs3SKfPUU08pY8aMURRFUfbu3asAyr1797Svnz59WgGUiIgIRVEU5ZVXXlE6dOhQ4D67dOmidOzYMc8+Pv74Y0VRFGX79u2KkZGRcvPmTe3rW7duVQBl3bp1iqLknM81atRQUlNTtWU2b96sGBgYKLGxsYqiKMrzzz+vjB07VlEURZk4caLy4YcfKjVq1FAuXLigZGVlKRYWFsqOHTt03teuXbt0tgco9+/fL/C9PBzTw+7fv68Ayrx58xRFyXucra2tlWXLluW7zUfLFuT48eMKoKSkpBT5Pfj5+SnDhg3Ld3tRUVGKoaGhznFXFEXp0aOHEhAQUGActra2ym+//aazLDAwULGwsFCSk5O1y3r37q24u7srarVau6xRo0bKnDlzdNZdtGiR4u7uXthbrzSMKiTrFOIxLly4gIeHBwCpqam4uLjke6m/tBojGxsba/+vUqkACu2JXLNmTZ1bRvltJ3db+S17dNsJCQk4Ojo+cdxCVBfJycncunWLDh066Czv0KGDTnvgxwkJCWHIkCGFlvHx8dF57uLior2deeHCBdzc3HTuAPj5+emUv3DhAi1atMDS0lInTo1Gw6VLl3BycqJLly789NNPQM7VvtmzZxMeHk5wcDAJCQlkZ2fnea8Px+Xi4gJAXFwcdevWLerbB0BRFOB/dd2j3n//fd566y1+//13evbsyZAhQ2jQoEGh2zx58iTTpk3jzJkz3Lt3T1vHRUdH4+3tXaT3EBISwttvv53v9kNDQ1Gr1Xh5eeksz8zMxMHBocC47t+/r3P7N5e7uzvW1tba505OThgaGmJgYKCz7OHb2JDTXjI9Pb3A/VUmkgAKvbNnzx5CQ0OZNGkSAK1btyY2NhYjIyPc3d0LXC86Oppbt25pK+YjR45gYGBAo0aNgJxeXCUZBuBhrVq14vz586WyLchpE9SqVatS254Q1VHul3duggM5tyYfZm5u/tjtFOVHW0nlDjdz+fJlzp8/T8eOHbl48SLBwcHcu3dP206uoLiK8kO1IBcuXADQ/sh+1LRp03j11VfZvHkzW7duJTAwkFWrVum0x3tY7i3v3r1788cff+Do6Eh0dDS9e/cmKyuryO+hsM8mNTUVQ0NDTp48mac3r5WVVYHryY/1gkkbQFGhMjMziY2N5ebNm5w6dYrZs2czcOBAnn32Wfz9/QHo2bMnfn5+DBo0iB07dhAZGcmhQ4f49NNPdcZkMjMzY8SIEZw5c4YDBw4wfvx4XnrpJZydnYGcX3xnz57l0qVL3L17N88Xw5Po3bs3Bw8eLNmbf8iBAwd45plnSm17QlQ1NjY2uLq68u+//+os//fff7VXmHK/mGNiYrSvPzrIu4+PD7t37y52HE2aNOH69es6+zhy5EieMmfOnCEtLU0nzod/kDZv3pwaNWowc+ZMWrZsiZWVFV27dmXfvn0EBwfnaf9XmnLb8fXs2bPAMl5eXkyaNIkdO3bw/PPPs3TpUiD/H9IXL14kPj6euXPn0qlTJxo3bpznyllRFPbZtGrVCrVaTVxcHA0bNtR55NbxBa0nP9bzJwmgqFDbtm3DxcUFd3d3+vTpw969e1m8eDEbNmzQ/spTqVRs2bKFzp078/rrr+Pl5cXQoUOJiorCyclJu62GDRvy/PPP069fP5555hl8fHz4/vvvta+//fbbNGrUiLZt2+Lo6Jjni+RJDBs2jHPnzhWpF97jHD58mKSkJF588cUSb0uIquzDDz9k3rx5/PXXX1y6dIkpU6YQEhLChAkTgJw6wM3NjWnTpnH58mU2b97MV199pbONgIAAjh8/zpgxYzh79iwXL14kKCiIu3fvFimGnj174uXlpfNj89NPP9UpM2zYMO0P0rCwMPbu3ct7773Ha6+9pq2zVCoVnTt35o8//tAmez4+PmRmZrJ79266dOlSwqOVIzExkdjYWKKioti5cycvvvgiK1euJCgoKN8mNPfv32fcuHEEBwcTFRXFv//+y/Hjx2nSpAmQ80M6NTWV3bt3c/fuXdLT06lbty4mJiZ88803XLt2jY0bN/L5558/cayBgYH8+eefBAYGcuHCBUJDQ5k3bx6Qk5AOGzYMf39/1q5dS0REBMeOHWPOnDls3ry5wG3Kj/VCVHQjRCFKQ2BgoNKiRYty3efkyZOVUaNGlXg7L730Up6G7UKIvB0O1Gq1Mm3aNKV27dqKsbGx0qJFC2Xr1q066xw8eFBp3ry5YmZmpnTq1ElZvXq1TicQRVGU4OBgpX379oqpqaliZ2en9O7dW9txpEuXLsqECRN0tjlw4EBlxIgR2ueXLl1SOnbsqJiYmCheXl7Ktm3b8nS4OHv2rNKtWzfFzMxMsbe3V95++21th4hcX3/9tQLovIeBAwcqRkZGOmWL0rklP4D2YWZmpjRo0EAZMWKEcvLkyQKPc2ZmpjJ06FDFzc1NMTExUVxdXZVx48bpdDZ59913FQcHBwVQAgMDFUVRlJUrVyru7u6Kqamp4ufnp2zcuFEBlNOnTz/Re/j777+Vli1bKiYmJkrNmjWV559/XvtaVlaWMnXqVMXd3V0xNjZWXFxclMGDBytnz54t8BjEx8crZmZmysWLF7XL8vu+yK+T4KN/C4cOHVLs7OyU9PT0AvdXmagU5aHGEkJUUtOmTWP9+vXFmtO3uBITE/n++++ZMmWKTsPhJ5GVlcUXX3zBBx98UKS2SUIIIZ7Mhx9+SHJyMj/++GOJtvPyyy/TokULPvnkk1KKrGLJLWAhisnOzo5PPvmk2Mkf5LSn+b//+z9J/oQQoox8+umn1KtXr0QdebKysmjevLm2c2JVIFcAhRBCCCGqGbkCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKIQQQghRzUgCKErE3d2dkSNHVsi+p02bhkqlqpB967uRI0diZWVV0WEIIYTQU5IAinwtW7YMlUqV72PKlCnlFkd6ejrTpk0jODi43PZZFCNHjtQ5JlZWVtSvX58XX3yRv//+G41GU+Yx6OuxEUIIof+MKjoAod9mzJiBh4eHzrJmzZqV2/7T09OZPn06AF27dtV57f/+7//KNRl9lKmpKb/88gsA9+/fJyoqik2bNvHiiy/StWtXNmzYgI2NTZntv7BjI4QQQhRGEkBRqL59+9K2bduKDiNfRkZGGBlV3J+wkZERw4cP11k2c+ZM5s6dS0BAAG+//TZ//fVXBUUnhBBCFExuAYtSd+3aNYYMGYK9vT0WFhY8/fTTbN68WadMVlYWU6dOpU2bNtja2mJpaUmnTp3Yu3evtkxkZCSOjo4ATJ8+XXu7ddq0aUD+bQBVKhXjxo1j/fr1NGvWDFNTU5o2bcq2bdvyxBkcHEzbtm0xMzOjQYMG/Pjjj6XSrnDKlCk888wzrF69mvDwcJ3Xtm7dSqdOnbC0tMTa2pr+/ftz7tw5nTK57feuXbtG7969sbS0xNXVlRkzZqAoSpGOTa6bN28yaNAgrKyscHR0ZPLkyajV6hK9PyGEEJWfJICiUElJSdy9e1fnUZjbt2/Tvn17tm/fzpgxY5g1axYZGRk899xzrFu3TlsuOTmZX375ha5duzJv3jymTZvGnTt36N27NyEhIQA4OjoSFBQEwODBg/n999/5/fffef755wuN4eDBg4wZM4ahQ4fyxRdfkJGRwQsvvEB8fLy2zOnTp+nTpw/x8fFMnz6dN998kxkzZrB+/friHahHvPbaayiKws6dO7XLfv/9d/r374+VlRXz5s3js88+4/z583Ts2JHIyEid9dVqNX369MHJyYkvvviCNm3aEBgYSGBgYJGPjVqtpnfv3jg4OPDll1/SpUsXvvrqK3766adSeY9CCCEqMUWIfCxdulQB8n08rF69esqIESO0zydOnKgAyoEDB7TLUlJSFA8PD8Xd3V1Rq9WKoijKgwcPlMzMTJ1t3bt3T3FyclLeeOMN7bI7d+4ogBIYGJgnxsDAwDzxAIqJiYly5coV7bIzZ84ogPLNN99olw0YMECxsLBQbt68qV12+fJlxcjIKM828zNixAjF0tKywNdPnz6tAMqkSZO0x8DOzk55++23dcrFxsYqtra2OstHjBihAMp7772nXabRaJT+/fsrJiYmyp07dxRFKfzY5G5jxowZOstbtWqltGnT5rHvTwghRNUmVwBFob777jt27typ8yjMli1b8PX1pWPHjtplVlZWjBo1isjISM6fPw+AoaEhJiYmAGg0GhISEnjw4AFt27bl1KlTJYq5Z8+eNGjQQPvcx8cHGxsbrl27BuRcGdu1axeDBg3C1dVVW65hw4b07du3RPvOlTsES0pKCgA7d+4kMTGRV155RedqqqGhIe3atdO59Z1r3Lhx2v/n3trOyspi165dRY7j3Xff1XneqVMn7XEQQghRfUknkGLYv38/8+fP5+TJk8TExLBu3ToGDRpU5PWnTZum7b35MAsLC9LS0kox0pLz9fV9ok4gUVFRtGvXLs/yJk2aaF/P7UW8fPlyvvrqKy5evEh2dra27KO9jp9U3bp18yyrUaMG9+7dAyAuLo779+/TsGHDPOXyW1YcqampAFhbWwNw+fJlALp3755v+Ud7CxsYGFC/fn2dZV5eXgB5bhcXxMzMTNtOMNfDx0EIIUT1JQlgMaSlpdGiRQveeOONx7ZHy8/kyZPzXJnp0aMHTz31VGmFqPdWrFjByJEjGTRoEB9++CG1atXC0NCQOXPmcPXq1RJt29DQMN/lyn87UJSHsLAw4H8JZe64gL///jvOzs55ypdFb+aCjoMQQgghCWAx9O3bt9BbhZmZmXz66af8+eefJCYm0qxZM+bNm6cdq83KykpnloYzZ85w/vx5fvjhh7IOvczVq1ePS5cu5Vl+8eJF7esAa9asoX79+qxdu1an121uJ4dcZTHTR61atTAzM+PKlSt5XstvWXH8/vvvqFQqevXqBaC9JV2rVi169uz52PU1Gg3Xrl3TXvUDtD2K3d3dgbI5NkIIIaoHaQNYBsaNG8fhw4dZtWoVZ8+eZciQIfTp00d7G/BRv/zyC15eXnTq1KmcIy19/fr149ixYxw+fFi7LC0tjZ9++gl3d3e8vb2B/12deviq3NGjR3XWg5zb4gCJiYmlFqOhoSE9e/Zk/fr13Lp1S7v8ypUrbN26tcTbnzt3Ljt27ODll1/G09MTgN69e2NjY8Ps2bN1bnfnunPnTp5l3377rfb/iqLw7bffYmxsTI8ePYCyOTZCCCGqB7kCWMqio6NZunQp0dHR2g4GkydPZtu2bSxdupTZs2frlM/IyOCPP/6o0BktStOUKVP4888/6du3L+PHj8fe3p7ly5cTERHB33//jYFBzm+OZ599lrVr1zJ48GD69+9PREQEP/zwA97e3tr2cwDm5uZ4e3vz119/4eXlhb29Pc2aNSvxbCTTpk1jx44ddOjQgdGjR6NWq/n2229p1qyZdhiax3nw4AErVqwAcj7HqKgoNm7cyNmzZ+nWrZvOcCs2NjYEBQXx2muv0bp1a4YOHYqjoyPR0dFs3ryZDh066CR8ZmZmbNu2jREjRtCuXTu2bt3K5s2b+eSTT7Tt+srq2AghhKj6JAEsZaGhoajVap1bd5BzW9jBwSFP+XXr1pGSksKIESPKK8Qy5eTkxKFDh/j444/55ptvyMjIwMfHh02bNtG/f39tuZEjRxIbG8uPP/7I9u3b8fb2ZsWKFaxevTrP3La//PIL7733HpMmTSIrK4vAwMASJzlt2rRh69atTJ48mc8++ww3NzdmzJjBhQsXtLerHyczM5PXXnsNyLkaV6tWLdq0acPUqVMZPHiwNtnN9eqrr+Lq6srcuXOZP38+mZmZ1K5dm06dOvH666/rlDU0NGTbtm2MHj2aDz/8EGtrawIDA5k6dapOubI4NkIIIao+lVKeLeOrIJVKpdML+K+//mLYsGGcO3cuTyN8KyurPB0AevTogY2Njc4gyaLiDBo0iHPnzhV4u748jBw5kjVr1uhcCRVCCCFKk1wBLGWtWrVCrVYTFxf32DZ9ERER7N27l40bN5ZTdOJh9+/fx9zcXPv88uXLbNmypcpcjRVCCCEKIglgMaSmpur0Fo2IiCAkJAR7e3u8vLwYNmwY/v7+fPXVV7Rq1Yo7d+6we/dufHx8dG6D/vrrr7i4uJTa4MPiydSvX5+RI0dSv359oqKiCAoKwsTEhI8++qiiQxNCCCHKlCSAxXDixAm6deumff7+++8DMGLECJYtW8bSpUuZOXMmH3zwATdv3qRmzZo8/fTTPPvss9p1NBoNy5YtY+TIkTJeWwXp06cPf/75J7GxsZiamuLn58fs2bO1PXeFEEKIqkraAAohhBBCVDMyDqAQQgghRDUjCaAQQgghRDUjbQCLSKPRcOvWLaytrWUKLiEqCUVRSElJwdXVNc+4jEIIUZ1JAlhEt27dws3NraLDEEIUw/Xr16lTp05FhyGEEHpDEsAisra2BnK+SGxsbCo4GiFEUSQnJ+Pm5qY9f4UQQuSQBLCIcm/72tjYSAIoRCUjzTaEEEKXNIoRQgghhKhmJAEUQgghhKhmJAEUQlQaGo3CltAYTkXfq+hQhBCiUpM2gEIIvacoCtvP3WbhrnAuxqbg627PX+88LW37hBCimPTuCmBQUBA+Pj7azhZ+fn5s3bq1wPJdu3ZFpVLlefTv3x+A7OxsPv74Y5o3b46lpSWurq74+/tz69at8npLQohiUhSFXedv8+w3B3l3xUkuxqZgZWrE0w0cUGtkFkshhCguvbsCWKdOHebOnYunpyeKorB8+XIGDhzI6dOnadq0aZ7ya9euJSsrS/s8Pj6eFi1aMGTIEADS09M5deoUn332GS1atODevXtMmDCB5557jhMnTpTb+xJCFJ2iKARfusPXu8I5eyMJAEsTQ17v4MFbnTywszCp4AiFEKJyUymKovc/o+3t7Zk/fz5vvvnmY8suXLiQqVOnEhMTg6WlZb5ljh8/jq+vL1FRUdStW7dIMSQnJ2Nra0tSUpIMAyNEGVEUhQOX77JgZzgh1xMBMDc2ZER7d0Z1ro+95ZMlfnLeCiFE/vTuCuDD1Go1q1evJi0tDT8/vyKts2TJEoYOHVpg8geQlJSESqXCzs6uwDKZmZlkZmZqnycnJxc5biHEk1EUhUNX4/l6ZzgnonI6eJgZG/Da0/V4p0sDalqZVnCEQghRtehlAhgaGoqfnx8ZGRlYWVmxbt06vL29H7vesWPHCAsLY8mSJQWWycjI4OOPP+aVV14p9IrAnDlzmD59erHiF0IU3ZFr8SzYGc6xiAQATIwMGN6uHu92rU8ta7MKjk4IIaomvbwFnJWVRXR0NElJSaxZs4ZffvmFffv2PTYJfOeddzh8+DBnz57N9/Xs7GxeeOEFbty4QXBwcKEJYH5XAN3c3ORWkhCl5ERkAgt2hnPoajwAJoYGvOLrxphuDXGyKZ3ET24BCyFE/vTyCqCJiQkNGzYEoE2bNhw/fpxFixbx448/FrhOWloaq1atYsaMGfm+np2dzUsvvURUVBR79ux57JeBqakppqZy20mI0nYq+h5f7wznwOW7ABgbqnj5KTfGdG2Iq515BUcnhBDVg14mgI/SaDQ6V+Pys3r1ajIzMxk+fHie13KTv8uXL7N3714cHBzKKlQhRAHOXE/k613hBF+6A4CRgYohbeswtltD6tSwqODohBCietG7BDAgIIC+fftSt25dUlJSWLlyJcHBwWzfvh0Af39/ateuzZw5c3TWW7JkCYMGDcqT3GVnZ/Piiy9y6tQp/vnnH9RqNbGxsUBO72ITExlOQoiyFHYziYW7wtl1IQ4AQwMVz7eqzXvdPanrIImfEEJUBL1LAOPi4vD39ycmJgZbW1t8fHzYvn07vXr1AiA6OhoDA93xqy9dusTBgwfZsWNHnu3dvHmTjRs3AtCyZUud1/bu3UvXrl3L5H0IUd1diElm4a5wtp+7DYCBCga1qs347p641yy4l74QQoiyp5edQPSRNCYXomguxaawaHc4W0JzrrSrVPBcC1fG9/CkgaNVucYi560QQuRP764ACiEqpytxKSzafYV/zt4i92flsz4uTOjhiaeTdcUGJ4QQQockgEKIErl2J5XFuy+z4cz/Er++zZyZ0NOTxs5y1U0IIfSRJIBCiGKJik9j8e4rrDt9A81/E79e3k5M7OlJU1fbig1OCCFEoSQBFEI8kesJ6Xyz5zJ/n7qJ+r+ZX4/GtZjY04vmdSTxE0KIykASQCFEkdxMvM+3e66w+sR1Hvw38evi5cikXl60dLOr2OCEEEI8EUkAhRCFikm6z3d7r/DX8etkq3MSv06eNZnY04s29WpUcHRCCCGKQxJAIUS+bidnEBR8lZVHo8lSawDwq+/ApF5e+HrYV3B0QgghSkISQCGqmezMNJJTbpKSGkNKWhwp6XGkZSZRw8oV55qNUVl4suTf2/xxNIrMBzmJn6+7PZN6eeHXQKZRFEKIqkASQCEqGY36ASmpt0hJuUVK2m2S026Tkh5PSkYCyZlJJGclkZKVSsqDdJLVGaRoskjRZJOMhhQV3DdQFbp9laJQQ63Q2M0AO8WculYONKxRh+RbdTlz3xNnR29qOjTG0EimURRCiMpKEkBRrak1CsciEohLyaCWtRm+HvYYPiZBKs9tKhoNEVHBnLy8iZN3QjiVeYdYA1BUT7A9FWCY+5//sdIoWCtgjSEGakhSqYk3hCwDFQlGKhKMAO5zSn0D7t6Au0e06xopCo4acDYwxdnICmcze5wsXXC2rYezvSe1HJpyOdGeO2lZpXZcoWw+LyGEqI4kARTV1rawGKZvOk9MUoZ2mYutGYEDvOnTzKVCtql+kEX41a2cvLaVk3fDOPUgkYSHExzD//3f9L8JnC0GWBsYYW1ggrWhGTZGFlgbW2FjYoONmR3WZvZYmztgY+mEtaUTNtYuWFm5kpqlYsras2wLi+V/80FqcLeMZ9TTGpws7xCbFMXttBhiMxKIfZBKrCaTOAN4oFIRYwgxZIE6AdISIO0KxB3QbslEo+CSrcI+zZFvHrRj+DNv069F/WId19I4tkIIIf5H5gIuIplTtGrZFhbD6BWnePSPPze9Chre+omTiuJsMzszjXPh6zkRuZOTCRcJ0aSS+sgVLVONQr0MIyzv1yIxvQm37nuTrHEgWzEvVqzJGdn8ejCCH/ZdJSNbk+f1xx0D9YMs7sZfJPbOeWLvXSY2+Tqx6bHczkjgRlYqcWSTYKjKc5XSSq2htcqOXnU70tFnJDUdmxQ55uJ+XnLeCiFE/iQBLCL5Iqk61BqFjvP26FxJepgKcLY14+DH3Yt8e7Go29z5ng9hl9ZyMjqYk0mXOatkkPnIPiw1Cq0MrGhToxEt6/Vk0uYaXE/OP44niTUlI5tl/0by84FrJGc8KLRsSY+BMRk4mlynjvkZjK3OE2WZSpKhgU75phpDOtk1obPX8zRtPBgDw/xvSJTk85LzVggh8ie3gEW1cywiocBkAkABYpIyOBaRUORerwVt09rgDp6WR7GyuESyxV06rdHwIPfKmApQqaihUWhjZEdrh6a0qd+XRg37aTtYHL4az/XkI3m2+ySxpmU+YPnhSH7af43E9GwAatuZczPxfpkdg2zMuJXlya0sT0gCAx7gZX6MWtbHybCL44KhmnMGas4lh/HDiTDsj02ng0ktOrt1wa/F69ja1s13u6UVqxBCVHeSAIpqJy6l4GSiOOUeLVvDMIZmNdZxzyaaaBOFyzq3QlU4qRXamjrS2rEFbT0H4FGvGyoDg7wbLWGs6VkP+P1wFD/uv0ZCWhYA9R0tmdjTC7Vaw6T/nCnWdotTVoMRF++35+L99izq3pIOtZM5eHYZ+28d4vCDeyQYqNj04A6bItZgeG01LTClk0NzOjd5mdvJzUq8fyGEELokARTVTi1rs1ItB+BoaUIT83+xt9/NBes0QrRJnwrXLIVa923ITvfg9e6v80zb7gUmfKURa0a2mhVHovhh31XupuYkfu4OFkzo6clzLWpjaKDi8NX4Ut3/k8Za07E2g3rMYxCQnZ1OSNifHLj6DweSr3LFEE6RxamEkyz69yROaoVOrrakpzTnQmpn0pX85xt+kliFEKK6kwRQVDu+Hva42JoRm5SRp1MB/K9NWVFmu8i4f4+t/87mz+s7ueGu5sZ/t+CRAZaJzbic3JVL6jqE/3ebPdt2R/UEw5Y8SawZ2WpWHYvm++CrxKVkAlDX3oLxPTwZ1NIVo4fa4JXmMSjpNo2NLXiq1Zs81epN3gdu3jzGwbAV7L99nGPqFG4bqrhtmwy2/2KmHKTpfWNMUz04GP86YFCsWIUQorqTBFBUO4YGKgIHeDN6xSlUoJOs5KZmgQO8C+38cP36v/x1ZD7rUq+QbKACAzBRFJqkWHE3oQdn77d/4m0WN9ZP+jVm5dEovtt7ldjknNugte3MGd+jIc+3roOxYd6rjaVxDMpqm7Vr+/JybV9eJifBPh76O1su/MPx7JvcNjbgosUDGhpcgXiDEh1bIYSozqQXcBFJb8Kq50nHldOoH3DwxDf8efEv/lVStcOcuKrhJce2PN/h/zh6y6JMxqrLL1ZnG1N6NHFi78U4bv13uYutGeO6N2RIGzdMjB5/m1kfx0IsyNazN/lp619YGgST/cCOo0kvP3a7ct4KIUT+9C4BDAoKIigoiMjISACaNm3K1KlT6du3b77lu3btyr59+/Is79evH5s3bwZAURQCAwP5+eefSUxMpEOHDgQFBeHp6VnkuOSLpGoqyswSSYmRrDs4k7/ijnLD8H/LO2DB0EYv0antezrTopXVbBW5241Jus/F2BS2hMZw415OT14nG1PGdmvIy0+5YWpk+Jgt5b9dfZ0NpSTblfNWCCHyp3cJ4KZNmzA0NMTT0xNFUVi+fDnz58/n9OnTNG3aNE/5hIQEsrKytM/j4+Np0aIFv/zyCyNHjgRg3rx5zJkzh+XLl+Ph4cFnn31GaGgo58+fx8ysaA3H5Yuk+jl3cS2rTn3P1sxY7Vh91hqFQVYNeNl3MvXqdSrXeB6oNWwIucXiPZeJik8HwNHalDFdG/CKb13MjJ8s8asO5LwVQoj86V0CmB97e3vmz5/Pm2+++diyCxcuZOrUqcTExGBpaYmiKLi6uvLBBx8wefJkAJKSknBycmLZsmUMHTq0SDHIF0n1kJWZwvZDc1kVuYWzBv8bLLmxxoChdXrSt0MAFhY1yzUmtUZh05lbLNp9mYi7aQDUtDLh3S4NGNauHuYmkvgVRM5bIYTIn153AlGr1axevZq0tDT8/PyKtM6SJUsYOnQolpaWAERERBAbG0vPnj21ZWxtbWnXrh2HDx8uMAHMzMwkMzNT+zw5ObkE70Tou5hbJ/nP4TmsTb6YM/euARgpCr2MHHjF521aNnu1yEO3lBaNRmFzaAwLd4Vz9U5O4lfDwph3ujTA368eFiZ6ffoKIYTQY3r5DRIaGoqfnx8ZGRlYWVmxbt06vL29H7vesWPHCAsLY8mSJdplsbGxADg5OemUdXJy0r6Wnzlz5jB9+vRivgNRWURFHWDh/gD2qBPRqFRgkDNQ8xCHVrzQ4VNq1mxc7jFpNArbzsWycFc44bdTAbA1N2ZU5/qMaO+OlalenrZCCCEqEb38JmnUqBEhISEkJSWxZs0aRowYwb59+x6bBC5ZsoTmzZvj6+tb4hgCAgJ4//33tc+Tk5Nxc3Mr8XaFfkhPv8sv20azLPkC2SoVqFS0w4yhDZ6na7tJGBmX/6DCiqKw4/xtvt4ZzsXYFABszIx4u1N9RnZwx9rMuNxjEkIIUTXpZQJoYmJCw4YNAWjTpg3Hjx9n0aJF/PjjjwWuk5aWxqpVq5gxY4bOcmdnZwBu376Ni8v/hoq4ffs2LVu2LHB7pqammJqaluBdCH2kaDTs+HcW8y//xW3DnMSvAxZ80GE6ng37VExMisLuC3F8vSucc7dymhpYmxrxRkcP3ujoga25JH5CCCFKl14mgI/SaDQ67fHys3r1ajIzMxk+fLjOcg8PD5ydndm9e7c24UtOTubo0aOMHj26rEIWeuhaxG5m75/CUTLAUEVtNXzU+DW6PT253Nv3QU7iFxx+h693hnP2RhIAliaGvN7Bg7c6eWBnYfKYLQghhBDFo3cJYEBAAH379qVu3bqkpKSwcuVKgoOD2b59OwD+/v7Url2bOXPm6Ky3ZMkSBg0ahIODg85ylUrFxIkTmTlzJp6entphYFxdXRk0aFB5vS1RgdJSY/lh22hWpF7mgUqFiaLwpm1z3ujzPWbmNco9HkVROHD5Ll/vCud0dCIA5saGjOzgztud6mNvKYmfEEKIsqV3CWBcXBz+/v7ExMRga2uLj48P27dvp1evXgBER0dj8MjVmkuXLnHw4EF27NiR7zY/+ugj0tLSGDVqFImJiXTs2JFt27YVeQxAUTkpGg2b9wey4No67vz3dm9XlTUfdf8KN7ei9Sov1XgUhcNX41mwM5wTUfcAMDM2wN/PnVGd61PTSpocCCGEKB+VYhxAfSDjiVUu4Ve2MvvgZ5xU5TQdcFPDlKZv0bndhAqJ58i1eL7eGc7RiAQATI0MGNauHu92rU8ta/khUlbkvBVCiPzp3RVAIfJT1CnAkpOu8/32MaxKj0CtUmGmUXjboRUjnvkWUzPbco/7RGQCC3aGc+hqPAAmhga82q4uo7s2wMlGEj8hhBAVQxJAofe2hcUwfdN5YpIytMtcbM0IHOBNn2Y5Pbs16gdsDP6Ur6M35wzkrFLRy8CWD3stwsW1TbnHfCr6Hl/vDOfA5bsAGBuqePkpN8Z2a4iLrXm5xyOEEEI8rMQJYGJiIuvWrePAgQNERUWRnp6Oo6MjrVq1onfv3rRv37404hTV1LawGEavOMWj7RRikzIYveIUQcNbU9foKLMPz+CMQTYYqHBXqwjweZf2bceUe7xnrify9a5wgi/dAcDIQMWQtm6M7daAOjUsyj0eIYQQIj/FTgBv3brF1KlT+eOPP3B1dcXX15eWLVtibm5OQkICe/fu5csvv6RevXoEBgby8ssvl2bcohpQaxSmbzqfJ/kDUABbgzv8FfwSJ63uoRioMNcojHZsx/BeizE2tSzXWMNuJrFwVzi7LsQBYGig4vlWtRnfwxM3e0n8hBBC6JdiJ4CtWrVixIgRnDx5ssAZOu7fv8/69etZuHAh169fZ/LkycUOVFQ/xyISdG775jLgAU/b/0F0zXOcMDQAVPQ1tOeDPt/g5ORTrjFeiElm4a5wtp+7nRObCga3qsN73RviXrN8k1AhhBCiqIqdAJ4/fz7PmHuPMjc355VXXuGVV14hPj6+uLsS1VRcSt7kr5H5IUydNxJqBmCAW6bCi7Xf5I3+k8o1tkuxKSzaHc6W0Jz5pFUqGNjClfE9PKnvaFWusQghhBBPqtgJ4OOSv5KWF+Lh4VFMVPdp57yYELuc8fMsNRoa3vXkSLw/TXp0KbeYrsSlsGj3Ff45ewtFyUn8nvVxZUKPhjSsZV1ucQghhBAlUSa9gC9cuMCRI0do1apVofPtClEYXw97XGzNIO08tdx+JsQspzVgi2RLLsa+zr/qOjjb5gwJU9au3Ull8e7LbDiTk/gB9GvuzIQeXjRylsRPCCFE5VLiBHDGjBmYm5vz4YcfArB371769OmDtbU1SUlJLFu2jGHDhpU4UFH9GBqoGNX8OEvifueaoQHWag1OMV04mNKf3BEAAwd45zseYGmJik9j8e4rrDt9A81/E79nvJ2Y2NMLb1cZWFgIIUTlZPD4IoVbs2aNTieQWbNmMX78eO7evcu3337L7NmzS7oLUQ1p1A/4YcNwvr67giRDA+pnqiByFKdT+gPgbGtG0PDW2nEAS9v1hHQ+WnOG7l/t4+9TOclfzya1+Oe9jvzk31aSPyGEEJVasa8A/vbbbyiKQmRkJCEhIcTHx6MoCv/++y+dOnXit99+Q6PRcO3aNX777TcA/P39Sy1wUXUlJUYyZcNQDpIGKhUvmrry4Ut/ceaW+rEzgZTUzcT7fLvnCqtPXOfBfy/5dW3kyKSeXrRwsyv1/QkhhBAVodgJYL169QAwMTHBycmJevXqERISgo2NDd26dUNRFDIzM1GpVLi7uyNTDouiOHdxLe8fCuSWIZhqFP6vbn8G9ZgHgF+DsttvTNJ9vtt7hb+OXydbnfO32smzJpN6edG6bo2y27H4//buPC6rMv//+OvmZlOWW1E2AZdUFERy/4ZWpkkuZdbUVKOO2mKlpGhZ6NRkNuXGd0xLQ80ZszFz0nLU0vxpJrmluGRaKqIipihubCrbfZ/fH4z3NwJL5WZR3s/Hg8d4n3Pd1/U5pxjfXeec64iISBW44QDYtWvxk5ft2rXjiy++IC4ujq+++oo+ffpw9913A7B3715CQkLsn0WuxrDZWLruJSadXEuh2USIFd65czItQh+o0HFPZ+eRsOEwi7alUWC1AdC5aT1GR4fSsXHFP1wiIiJSFcr9EEh8fDz9+vWjS5cutGzZkrlz59r3ffjhh/Tq1au8Q8gt7vKl87z1nz+yojADTCbuMXnx9iP/xtsSUmFjZuTkMXvDET7edoz8ouLg16mJDy9Gh3LHbVqySEREbm0mw0HXZs+dO1dqrb/09HS8vb3x8Lj534iQnZ2NxWIhKysLb289AOAoaWmbGP11DMlONpwMg5H1OvJknw9wMlfICkWcy81nzrdH+GhrKnmFxcGvQ6O6jI4OpXPTephMFfdEsVQ+/d6KiJTNYX/LlrXQc2BgxTyhKbeG9Vum8urBj8h1MuFjM4hvM4pObZ+pkLEuXCxg7sYjLNiSyqUCKwBtQurwYnQodzWvr+AnIiI1yg0HwMWLF/PEE09cU9vjx4+TlpZGly5dbnQ4uYUUFebx3ooB/DM3GZxMtDVcie8zv0Le45t5qYB5G48yf/NRLv43+EUGWxgdHco9ob4KfiIiUiPd8DqACQkJhIWFMXXqVPbv319qf1ZWFqtWraJ///60a9dO7wIWAM6ePcCzH99ZHP6AP9e+jX8M2Ojw8Jd1uZB31iZz15RvmPlNChcLrLRq4M28QR1YHtOFbi38FP5ERKTGuuEZwMTERFasWMF7773HuHHj8PDwwN/fH3d3dy5cuMCpU6eoX78+Q4YMYd++ffj7+zuybrkJ7drzEWN2TuWM2URtm8GbzR6n511/degYOXmFzN+cyryNR8jOKwKgZYAXo6NDuS/cX6FPREQEBz0EcvbsWTZt2sSxY8e4fPky9evXp23btrRt2xYnp+ubZExISCAhIYHU1FQAWrVqxeuvv07v3r2v+p3MzExeffVVPv/8c86fP0+jRo2YPn06ffr0AcBqtfLGG2+wcOFCTp06RYMGDRgyZAivvfbaNQcC3Ux+4wybjX999TzTMrZgNZloajUxrdt0bmvS3WFj5OYXsWBLKh9sPELmpUIAQv09GdUjlF6tAnCqwNfFSfWl31sRkbI55CGQ+vXr89BDDzmiK4KDg5k8eTLNmzfHMAwWLFhAv3792L17N61atSrVvqCggOjoaPz8/Fi6dClBQUEcO3aMOnXq2NtMmTKFhIQEFixYQKtWrdixYwdPPvkkFouFkSNHOqRuKdvF3FP8ddkfWWvLBJOJ3mYf3nhkCbU9/RzS/6WCIj7aeoy53x7h/MUCAJr6ejCqRyj3tw5U8BMRESmDw5aBqUg+Pj7Ex8fz9NNPl9o3e/Zs4uPjOXDgAC4uLmV+/4EHHsDf359//OMf9m2PPPIItWrVYuHChddUg2YSrl/K4f/H6MQxpJoNnA2DVwLu4Yn73sV0nbPCZblcYOXjbceYnXiYs7nFwa9JfQ9i721O39sbVMhr4uTmo99bEZGyVcxiaw5itVpZsmQJFy9eJCoqqsw2K1asICoqipiYGJYvX46vry/9+/cnLi4Os9kMQOfOnZk7dy7JycmEhoayZ88eNm3axLRp0yrzcGoMq83gwy/GMvvcl+SZTfhbDf7e6TVuj7i2p8Z/S16hlUXb0khIPMyZnHwAGvrUJvbe5vRr0wBnc/nDpYiIyK2uWgbAvXv3EhUVRV5eHp6enixbtozw8PAy2x45coT169czYMAAVq1aRUpKCsOHD6ewsJDx48cDMHbsWLKzs2nZsiVmsxmr1crbb7/NgAEDrlpDfn4++fn59s/Z2dmOPchb1OofTvDZN0PZVuc4OJloeclMVtZLpNOV28vRb36RlX8nHWfWNymczi7+5xJctxYjuzfn4XZBuCj4iYiIXLNqeQm4oKCAtLQ0srKyWLp0KfPmzSMxMbHMEBgaGkpeXh5Hjx61z/hNmzaN+Ph40tPTgeI1C19++WXi4+Np1aoV33//PaNGjWLatGkMHjy4zBreeOMNJkyYUGq7LiVd3eofTvDJ+oHsrnsWgLbn/dh0eiTGf/87I2FgO3pFXN/i4AVFNj7dURz80rPyAGhgceeF7s15tH0wrs4KfnJ1ugQsIlI2hwTAN998kzFjxlC7du0S2y9fvkx8fDyvv/56ufrv0aMHTZs2Zc6cOaX2de3aFRcXF9atW2fftnr1avr06UN+fj6urq6EhIQwduxYYmJi7G3eeustFi5cyIEDB8ocs6wZwJCQEP1FchWFRYU8O7s7O7wyAbg9oymbzg217zcBARZ3NsV1v6b78wqtNj7b+TPvrU/hROZlAAK83Ynp1pTHOobg5myuiMOQW4wCoIhI2RwyfTJhwgRyc3NLbb906VKZs2jXy2azlQhjv9SlSxdSUlKw2Wz2bcnJyQQGBuLq6mqv49fL0ZjN5hLf+TU3Nze8vb1L/EjZigrziPu4Bzu8MjEZBq1PtSoR/gAMID0rj+1Hz/92X1YbS3Ycp/vfNzD2872cyLyMr5cbb/QNZ8PL9/DnqMYKfyIiIuXkkHsADcMocz29PXv24OPjc119jRs3jt69e9OwYUNycnJYtGgRGzZsYM2aNQAMGjSIoKAgJk2aBMCwYcOYOXMmsbGxjBgxgkOHDjFx4sQSy7v07duXt99+m4YNG9KqVSt2797NtGnTeOqpp8px1AJQkJ9D3Ke9WUcWZsOgRXp7tmQ9dtX2GTl5ZW632gxW7DnBjHWHSD13CYD6nq4837UpA+9ohLuLQp+IiIijlCsA1q1bF5PJhMlkIjQ0tEQItFqt5Obm8vzzz19XnxkZGQwaNIj09HQsFguRkZGsWbOG6OhoANLS0krM5oWEhLBmzRpGjx5NZGQkQUFBxMbGEhcXZ2/z3nvv8de//pXhw4eTkZFBgwYNeO6558p9abqmu3zpPKOX9GYzl3AxDJqc7MK27Ad/8zt+Xu4lPlttBl/8cJIZXx/iyJmLAPh4uPJ819sYeEcjartWy+eUREREbmrlugdwwYIFGIbBU089xfTp07FYLPZ9rq6uNG7c+KrLt9xsdC9RSbk56bzwWV92mvKpZTOYFjGcl9e14FRWHmX9C/XrewBtNoPV+04xfV0yhzKKbx+oU9uFZ+++jcFRjfFwU/CT8tPvrYhI2cr1t+yVJ2ibNGlCly5dcHbWX9o1QVZmKs8ve5h9TkV42gzebz+WtpEDGV8rnWELd2GCEiHwyrzw+L7hmICv9qUzfd0hDpzKAcDb3bk4+HVujJd72Yt5i4iIiOM45CEQLy8v9u/fb/+8fPlyHnroIf7yl79QUFDgiCGkmjh79gBPLuvHPqci6tgM5kW9SdvIgQD0iggkYWA7AiwlL/MGWNx5f0BbzE5OPPDeJp5fuIsDp3LwcnNmVI/mbBrbnRe6N1f4ExERqSQOmbJ77rnnGDt2LK1bt+bIkSM8/vjj/OEPf2DJkiVcunSJ6dOnO2IYqWKn0nfzzOpBHDODr9VgbtdpNGt6X4k2vSICiQ4PYPvR82Tk5OHr6calAiszvj7E3hNZAHi6OfNUl8Y8fedtWGor9ImIiFQ2hwTA5ORk2rRpA8CSJUvo2rUrixYtYvPmzTzxxBMKgLeAtLRNDF03jJNmaGCFD3rMpmHDO8tsa3YyccdtPnx76CxT1hxkz/FMAGq7mhnSuTFD77qNuh6ulVi9iIiI/JLDloG5sqbeunXreOCBB4DiJ3TPnj3riCGkCqUc/n8MTXyRs2YTja3wQe+PCAhsW2ZbwzDYnHKOd9Yls/PYBQBquZgZ1LkRz951G/U83SqzdBERESmDQwJghw4deOutt+jRoweJiYkkJCQAcPToUfz9/R0xhFSRHw98zvNbXyfTbKK5zYm5D/6b+vVbltl26+FzvLM2me2pxYs9uzk78ec7GvFc16b4ein4iYiIVBcOCYDTp09nwIAB/Oc//+HVV1+lWbNmACxdupTOnTs7YgipArt/WMjwnZPJdTLR2uZMwsPLsNRpXKrd9qPneWdtMluPnAPA1dmJ/p0aMvyepvh5u5dqLyIiIlXLIe8Cvpq8vDzMZjMuLjf/jf41bT2xrTtnE/vDTC47mWhvuDHr0S/w8Awo0WbnsQu8szaZTSnFl/ldzU480SmE4fc0K/UksEhVqGm/tyIi18qhC/ft3LnTvhxMeHg47dq1c2T3UknWb5nKmOSPKHQy0YXavPPYamrV/r9X+n1/PJN31iaTmHwGABeziT92CCGmWzOC6tSqqrJFRETkGjkkAGZkZPD444+TmJhInTp1AMjMzKRbt24sXrwYX19fRwwjlWBV4nj+cvQzrCYTPZwsTHlsNa5uXgDsO5HFO2uT+fpABlD8tO8f2wcT060ZIT61q7JsERERuQ4OCYAjRowgNzeXH3/8kbCwMAB++uknBg8ezMiRI/nkk08cMYxUsM/WvsSEE2swTCb6Ovvy5mOrcHZx58eTWUxfd4i1P50GwMkEf2gXzIjuzWhUz6OKqxYREZHr5ZB7AC0WC+vWraNjx44ltm/fvp377ruPzMzM8g5R5W71e4n+teo5pp7ZAsDjbsH85Y8rOXTmMtPXJbN63ymgOPj1axPEiO7NuM3XsyrLFbkmt/rvrYjIjXLIDKDNZivzQQ8XFxf7+oBSPRk2G3NXDmZm5vcAPOnRjL53fsjIf//Al3vTMQwwmaBvZANG3tucZn4KfiIiIjc7hwTA7t27ExsbyyeffEKDBg0AOHHiBKNHj+bee+91xBBSQd5d9hjzcg8C8JRHBEcLxnDfjE1cmRe+v3UgsT2aE+rvVYVVioiIiCM5JADOnDmTBx98kMaNGxMSEgLA8ePHiYiIYOHChY4YQirAgi+ftYe/7pfCeO/AQGxG8eXeXq0CiO3RnLBAXTYTERG51TgkAIaEhLBr1y7WrVvHgQMHAAgLC6NHjx6O6F4qwOxlrzAreysAbc40YvnZwQBEBluY+HBrIoIsVVmeiIiIVCCHrQNoMpmIjo4mOjraUV1KBUlYFs8HWavAZKJNZl02nn3Ovm/vz1n8fOGSAqCIiMgtzKk8X16/fj3h4eFkZ2eX2peVlUWrVq3YuHFjeYYQBzqZeZnxH8/lowsfUmgyEZHrxub0l/j1vwYTVv6E1VZhL4gRERGRKlauADh9+nSGDh1a5vIKFouF5557jmnTppVnCHGA09l5jF++jz++M59v82aQa3ai2WUTu35+BduvJoENID0rj+1Hz1dNsSIiIlLhyhUA9+zZQ69eva66/7777mPnzp3lGULKISMnjwkrf+Suqd/w+bbd1Al6n7POTgQVGBxOe5F84+qLOGfk5FVipSIiIlKZyhUAT58+Xeb6f1c4Oztz5syZ6+ozISGByMhIvL298fb2JioqitWrV//mdzIzM4mJiSEwMBA3NzdCQ0NZtWpViTYnTpxg4MCB1KtXj1q1atG6dWt27NhxXbXdLM7m5vP2lz9x99RvmL85FawXCW88jTQ3E/WsBtnHh5Jt++3X8/l5uVdOsSIiIlLpyvUQSFBQEPv27aNZs2Zl7v/hhx8IDAy8rj6Dg4OZPHkyzZs3xzAMFixYQL9+/di9ezetWrUq1b6goIDo6Gj8/PxYunQpQUFBHDt2zP5OYoALFy7QpUsXunXrxurVq/H19eXQoUPUrVv3umqr7s5fLGDut0dYsCWVy4VWANqGeNLQYzLrTUV42AxmdZnIM6c9MBXkUdZdfiYgwOJOpyY+lVq7iIiIVJ5yvQpuxIgRbNiwgaSkJNzdS84YXb58mU6dOtGtWzfefffdchXp4+NDfHw8Tz/9dKl9s2fPJj4+ngMHDlx1NnLs2LFs3ry5XA+kVOdXSmVeKuCDjUf4cHMqFwuKg9/twRZGR4eyc+9zfHgxBWfDYFbEcDp3GM5X+9IZtnAXQIkQaPrv/yYMbEeviOsL7iLVUXX+vRURqUrlCoCnT5+mXbt2mM1mXnjhBVq0aAHAgQMHmDVrFlarlV27duHv739D/VutVpYsWcLgwYPZvXs34eHhpdr06dMHHx8fateuzfLly/H19aV///7ExcVhNpsBCA8Pp2fPnvz8888kJiYSFBTE8OHDGTp06FXHzs/PJz8/3/45OzubkJCQavUXSdblQv6x6Sj/3HSU3PwiACKCvBndI5TuLf1Y9FUMkzOKQ+/Ehg/St9vb9u9+tS+dCSt/Ij3r/+71C7S4M75vuMKf3DIUAEVEylauS8D+/v5s2bKFYcOGMW7cOK5kSZPJRM+ePZk1a9YNhb+9e/cSFRVFXl4enp6eLFu2rMzwB3DkyBHWr1/PgAEDWLVqFSkpKQwfPpzCwkLGjx9vb5OQkMCLL77IX/7yF5KSkhg5ciSurq4MHjy4zH4nTZrEhAkTrrv2ypCdV8j8TanM23SEnLzi4BcW6M3oHs2JDvfHZDKxdtNEppz+FkwmYuu2KxH+AHpFBBIdHsD2o+fJyMnDz6v4sq/ZyVTWkCIiInILKdcM4C9duHCBlJQUDMOgefPm5bq/rqCggLS0NLKysli6dCnz5s0jMTGxzBAYGhpKXl4eR48etc/4TZs2jfj4eNLT0wFwdXWlQ4cObNmyxf69kSNHkpSUxNatW8usoTrOAObmF7FgSypzvz1C1uVCAEL9PRndI5SerQJw+m9427XnI4bunkqBycTjbsG8+tiXmJzK9byPyE1JM4AiImVz2JtA6tatS8eOHR3Sl6urq/3Bkvbt25OUlMSMGTOYM2dOqbaBgYG4uLjYwx8Uv4bu1KlTFBQU4OrqSmBgYKnwGBYWxmeffXbVGtzc3HBzc3PI8ZTXpYIiPtp6jDmJh7lwqTj4NfX1YFSPUO5vHWgPfgBHjn7NiF1TKXAy0c3kzbhHlyv8iYiISAkOC4AVyWazlZiN+6UuXbqwaNEibDYbTv8NOsnJyQQGBuLq6mpvc/DgwRLfS05OplGjRhVbeDldLrCy8LtjzE48zLmLBQDcVt+D2B7NeSCyQanLtWcyfmTYN6PINpuItLkw5fGVmJ1dq6J0ERERqcaqXQAcN24cvXv3pmHDhuTk5LBo0SI2bNjAmjVrABg0aBBBQUFMmjQJgGHDhjFz5kxiY2MZMWIEhw4dYuLEiYwcOdLe5+jRo+ncuTMTJ07kscceY/v27cydO5e5c+dWyTH+nrxCKx9vSyNhw2HO5hYH30b1ajOie3MeatMAZ3PpGb3cnHSGf9mfk2ZoZIWZDy2hVm0t5SIiIiKlVbsAmJGRwaBBg0hPT8disRAZGcmaNWuIjo4GIC0tzT7TBxASEsKaNWsYPXo0kZGRBAUFERsbS1xcnL1Nx44dWbZsGePGjePNN9+kSZMmTJ8+nQEDBlT68f2WvEIr/046zqxvUsjIKQ5+wXVrMfLe5jzcNgiXMoIfQGH+RV78vB8HnGz42AwSoj+grk/TyixdREREbiIOewjkVleRN5PnF1n5dMfPvP9Nin1ZlqA6tXihezMeaReMq/PV7+EzbDZeW9yDFYVnqGUzmB/1Jq1a/sGh9YncrPQQiIhI2ardDGBNUmi1sXTnz8xcn8KJzMsABHi7E9O9GY91CMbN2fw7PcB7/3mcFYVnMBsGf2/1rMKfiIiI/C4FwCpQZLXx+e4TvLf+EMfPFwc/Py83Yro14/GOIbi7/H7wA/h0TSwf5BwAYHxIH+7qNPJ3viEiIiKiAFipiqw2Vuw5yYyvD3Hs3CUA6nu6Meyepgz4n4bXHPwA1m+ZytvpX4PJxHBLJA/fO7WiyhYREZFbjAJgJbDaDL744SQz1h3iyNmLANTzcOX5rk0ZeEcjarlee/AD2LNvMXEHP8LmZOIR10Cef/BfFVG2iIiI3KIUACuQzWawal8609cdIiUjF4A6tV147u6mDIpqhIfb9Z/+1NREXkh6izwnE3ebPHnt0RVa6FlERESuiwJgBbDZDNb8eIrp6w5x8HQOAJZaLjx7920M7twYzxsIflabwYY93zF1VwyZziYibM7EP74SZxd3R5cvIiIitzgFQAfbn57Ni5/uYX96NgBe7s48c+dtPHlnY7zdXW6oz6/2pTNl5Ra8fN7gpLuJwEKD82dH8e2RQnpFOLB4ERERqREUAB3M18uN1LMX8XRz5qkujXn6ztuw1L6x4AfF4W/Ywh1EhUxirztYrDYupT3FiYL6DFu4i4SB7egVEejAIxAREZFbnQKgg9X3dCNhYDtuD65DXY/yvYfXajOYsPInutT7B3s883E2DLyOP8j+gpYAmIAJK38iOjyg1HuBRURERK5GTw9UgHta+JU7/AFsP3qeOgXr+NE3BYBWZ0LZf/lO+34DSM/KY/vR8+UeS0RERGoOBcBq7OdTB8gLXkGRyUTrHHc2nXuyzHYZOXmVXJmIiIjczBQAqylrUQGrD47irLMTQQUGe06O4mr/uPy89CSwiIiIXDvdA1hNzVk5mCRzHu42g/yf+3PRVqdUGxMQYHGnUxOfSq9PREREbl6aAayGNifNZHbWXgCGeN9Hav7t/PoRjyufx/cN1wMgIiIicl0UAKuZ9JM7GbtvNobJxGNuQcQ8Mo2Ege0IsJS8zBtgcdcSMCIiInJDdAm4GinMv8iYNc+Q6WQi3GbmlYf+DUCviECiwwPYfvQ8GTl5+HkVX/bVzJ+IiIjcCAXAauTvy5/gB6civGwGf4+ejZu7xb7P7GQiqmm9KqxOREREbhW6BFxNfPXtm3x8ORWASWFPERx8R9UWJCIiIrcsBcBq4GjqBsYf/hSAZzxb0PWOF6u4IhEREbmVVbsAmJCQQGRkJN7e3nh7exMVFcXq1at/8zuZmZnExMQQGBiIm5sboaGhrFq1qsy2kydPxmQyMWrUqAqo/vpdunSWF9eP5JKTiY6GGzEPLqzqkkREROQWV+3uAQwODmby5Mk0b94cwzBYsGAB/fr1Y/fu3bRq1apU+4KCAqKjo/Hz82Pp0qUEBQVx7Ngx6tSpU6ptUlISc+bMITIyshKO5PcZNht/W/ZHUswG9a0GU/v+C2cXLeosIiIiFavaBcC+ffuW+Pz222+TkJDAd999V2YA/Oc//8n58+fZsmULLi4uADRu3LhUu9zcXAYMGMAHH3zAW2+9VSG1X6+l617ii6KzmA2D+HZjqO8bVtUliYiISA1Q7S4B/5LVamXx4sVcvHiRqKioMtusWLGCqKgoYmJi8Pf3JyIigokTJ2K1Wku0i4mJ4f7776dHjx6VUfrv+vHA50w6uRaAkfU60aHNkKotSERERGqMajcDCLB3716ioqLIy8vD09OTZcuWER4eXmbbI0eOsH79egYMGMCqVatISUlh+PDhFBYWMn78eAAWL17Mrl27SEpKuuYa8vPzyc/Pt3/Ozs4u30H9QlZWGi9tGU+h2UQ3kzdP3j/PYX2LiIiI/J5qGQBbtGjB999/T1ZWFkuXLmXw4MEkJiaWGQJtNht+fn7MnTsXs9lM+/btOXHiBPHx8YwfP57jx48TGxvL2rVrcXe/9vvrJk2axIQJExx5WMX1Wot4dfnjnDBDkBXeemQxJqdqPRErIiIitxiTYRhGVRfxe3r06EHTpk2ZM2dOqX1du3bFxcWFdevW2betXr2aPn36kJ+fz6pVq3j44Ycxm832/VarFZPJhJOTE/n5+SX2XVHWDGBISAhZWVl4e3vf8LH8Y+WTTD+/A1fD4F93vEV4y4duuC8R+W3Z2dlYLJZy/96KiNxqquUM4K/ZbLYSYeyXunTpwqJFi7DZbDj9dyYtOTmZwMBAXF1duffee9m7d2+J7zz55JO0bNmSuLi4MsMfgJubG25ubg49jqTd/+Ddc0lgMjEu6D6FPxEREakS1S4Ajhs3jt69e9OwYUNycnJYtGgRGzZsYM2aNQAMGjSIoKAgJk2aBMCwYcOYOXMmsbGxjBgxgkOHDjFx4kRGjhwJgJeXFxERESXG8PDwoF69eqW2O4LVZpT5zt4zGT/y8u53sJlNPOjixyP3/q/DxxYRERG5FtUuAGZkZDBo0CDS09OxWCxERkayZs0aoqOjAUhLS7PP9AGEhISwZs0aRo8eTWRkJEFBQcTGxhIXF1fptX+1L50JK38iPSvPvi3Q4s5f+zTl092DOWc20dzmxGsPLdF9fyIiIlJlbop7AKuD37uX6Kt96QxbuItfn0wTcJf/39ntcwYPm8HibrNo3LhrpdQsUtPpHkARkbJpGsoBrDaDCSt/KhX+ANp5rWS3zxkA3mj2hMKfiIiIVDkFQAfYfvR8icu+VzRwPcjJwI0AtL3gg6XBsMouTURERKQUBUAHyMgpHf7cTBepFzyfXLMTzfJMbD01ssx2IiIiIpVNAdAB/LxKLzDdKXAGqW5gsdo4efxZCnEvs52IiIhIZVMAdIBOTXwItLhj+u/nO+os4ntLNibDoN7JHmQUNSHQUrwkjIiIiEhVUwB0ALOTifF9i19T19R9Nyn+ewBocy6YH3LvA2B833DMTqar9iEiIiJSWRQAHaRXRCAJA9vh5u5PSIETYRed2XhmGAEWdxIGtqNXRGBVlygiIiICaB3Aa3at64lZbQZbk49z6kIGQX5N7G8CEZHKp3UARUTKVu3eBHKzMzuZuLNlQ6BhVZciIiIiUiZdAhYRERGpYRQARURERGoYBUARERGRGkb3AF6jK8/KZGdnV3ElInKtrvy+6lk3EZGSFACvUU5ODgAhISFVXImIXK+cnBwsFktVlyEiUm1oGZhrZLPZOHnyJF5eXphMWtbl92RnZxMSEsLx48e1/IYD6bxeH8MwyMnJoUGDBjg56Y4XEZErNAN4jZycnAgODq7qMm463t7eCioVQOf12mnmT0SkNP0nsYiIiEgNowAoIiIiUsMoAEqFcHNzY/z48bi5uVV1KbcUnVcREXEEPQQiIiIiUsNoBlBERESkhlEAFBEREalhFABFREREahgFQLlhkyZNomPHjnh5eeHn58dDDz3EwYMHS7TJy8sjJiaGevXq4enpySOPPMLp06erqOKb0+TJkzGZTIwaNcq+TedVRETKQwFQblhiYiIxMTF89913rF27lsLCQu677z4uXrxobzN69GhWrlzJkiVLSExM5OTJk/zhD3+owqpvLklJScyZM4fIyMgS23VeRUSkPPQUsDjMmTNn8PPzIzExkbvvvpusrCx8fX1ZtGgRjz76KAAHDhwgLCyMrVu3cscdd1RxxdVbbm4u7dq14/333+ett96iTZs2TJ8+XedVRETKTTOA4jBZWVkA+Pj4ALBz504KCwvp0aOHvU3Lli1p2LAhW7durZIabyYxMTHcf//9Jc4f6LyKiEj56V3A4hA2m41Ro0bRpUsXIiIiADh16hSurq7UqVOnRFt/f39OnTpVBVXePBYvXsyuXbtISkoqtU/nVUREyksBUBwiJiaGffv2sWnTpqou5aZ3/PhxYmNjWbt2Le7u7lVdjoiI3IJ0CVjK7YUXXuCLL77gm2++ITg42L49ICCAgoICMjMzS7Q/ffo0AQEBlVzlzWPnzp1kZGTQrl07nJ2dcXZ2JjExkXfffRdnZ2f8/f11XkVEpFwUAOWGGYbBCy+8wLJly1i/fj1NmjQpsb99+/a4uLjw9ddf27cdPHiQtLQ0oqKiKrvcm8a9997L3r17+f777+0/HTp0YMCAAfY/67yKiEh56BKw3LCYmBgWLVrE8uXL8fLyst9/ZrFYqFWrFhaLhaeffpoXX3wRHx8fvL29GTFiBFFRUXpS9Td4eXnZ76O8wsPDg3r16tm367yKiEh5KADKDUtISADgnnvuKbF9/vz5DBkyBIB33nkHJycnHnnkEfLz8+nZsyfvv/9+JVd669F5FRGR8tA6gCIiIiI1jO4BFBEREalhFABFREREahgFQBEREZEaRgFQREREpIZRABQRERGpYRQARURERGoYBUARERGRGkYBUERERKSGUQCU33XPPfcwatSoCh9nw4YNmEwmMjMzK3ys6uBGz2tBQQHNmjVjy5Yt5Rp/7NixjBgxolx9iIjIzUkBUBgyZAgmk6nUT0pKSoWNWVb46dy5M+np6VgslgobF/4vaJpMJpycnLBYLLRt25ZXXnmF9PT0ChvPUcF29uzZNGnShM6dO5ernzFjxrBgwQKOHDnikLpEROTmoQAoAPTq1Yv09PQSP02aNKnUGlxdXQkICMBkMlXKeAcPHuTkyZMkJSURFxfHunXriIiIYO/evZUy/o0wDIOZM2fy9NNPl7uv+vXr07NnT/s7nUVEpOZQABQA3NzcCAgIKPFjNpvLbHvhwgUGDRpE3bp1qV27Nr179+bQoUP2/efOneNPf/oTQUFB1K5dm9atW/PJJ5/Y9w8ZMoTExERmzJhhn4lLTU0tNVP24YcfUqdOHdasWUNYWBienp72oHpFUVERI0eOpE6dOtSrV4+4uDgGDx7MQw899LvH7OfnR0BAAKGhoTzxxBNs3rwZX19fhg0bVqLdvHnzCAsLw93dnZYtW/L+++/b96WmpmIymVi8eDGdO3fG3d2diIgIEhMT7fu7desGQN26dTGZTAwZMsT+fZvNxiuvvIKPjw8BAQG88cYbv1nzzp07OXz4MPfff3+pGj799FPuuusuatWqRceOHUlOTiYpKYkOHTrg6elJ7969OXPmTIn++vbty+LFi3/3XImIyK1FAVCu25AhQ9ixYwcrVqxg69atGIZBnz59KCwsBCAvL4/27dvz5Zdfsm/fPp599ln+/Oc/s337dgBmzJhBVFQUQ4cOtc82hoSElDnWpUuX+N///V/+9a9/8e2335KWlsaYMWPs+6dMmcLHH3/M/Pnz2bx5M9nZ2fznP/+5oeOqVasWzz//PJs3byYjIwOAjz/+mNdff523336b/fv3M3HiRP7617+yYMGCEt99+eWXeemll9i9ezdRUVH07duXc+fOERISwmeffQYUzzimp6czY8YM+/cWLFiAh4cH27ZtY+rUqbz55pusXbv2qjVu3LiR0NBQvLy8Su0bP348r732Grt27cLZ2Zn+/fvzyiuvMGPGDDZu3EhKSgqvv/56ie906tSJn3/+mdTU1Bs6ZyIicpMypMYbPHiwYTabDQ8PD/vPo48+at/ftWtXIzY21jAMw0hOTjYAY/Pmzfb9Z8+eNWrVqmV8+umnVx3j/vvvN1566aUy+7zim2++MQDjwoULhmEYxvz58w3ASElJsbeZNWuW4e/vb//s7+9vxMfH2z8XFRUZDRs2NPr163fVWn49zi+tXr3aAIxt27YZhmEYTZs2NRYtWlSizd/+9jcjKirKMAzDOHr0qAEYkydPtu8vLCw0goODjSlTpvzmeF27djXuvPPOEts6duxoxMXFXbX22NhYo3v37iW2Xalh3rx59m2ffPKJARhff/21fdukSZOMFi1alPhuVlaWARgbNmy46pgiInLrca6q4CnVS7du3UrcC+bh4VFmu/379+Ps7Mz//M//2LfVq1ePFi1asH//fgCsVisTJ07k008/5cSJExQUFJCfn0/t2rWvu67atWvTtGlT++fAwED77FxWVhanT5+mU6dO9v1ms5n27dtjs9mueywovscOwGQycfHiRQ4fPszTTz/N0KFD7W2KiopKPagSFRVl/7OzszMdOnSwn4/fEhkZWeLzL4+vLJcvX8bd3f13+/L39wegdevWJbb9uu9atWoBxTOtIiJScygAClAc+Jo1a+aQvuLj45kxYwbTp0+ndevWeHh4MGrUKAoKCq67LxcXlxKfTSaTPaRVhCuhrXHjxuTm5gLwwQcflAi8wFXvj7xeZR3fb4XX+vXrX/UhlV/2deVBml9v+3Xf58+fB8DX1/f6ChcRkZua7gGU6xIWFkZRURHbtm2zbzt37hwHDx4kPDwcgM2bN9OvXz8GDhzI7bffzm233UZycnKJflxdXbFareWqxWKx4O/vT1JSkn2b1Wpl165dN9Tf5cuXmTt3LnfffTe+vr74+/vToEEDjhw5QrNmzUr8/PoJ6e+++87+56KiInbu3ElYWBhQfKxXaiuvtm3bcuDAAYeF4H379uHi4kKrVq0c0p+IiNwcNAMo16V58+b069ePoUOHMmfOHLy8vBg7dixBQUH069fP3mbp0qVs2bKFunXrMm3aNE6fPm0PiFA8w7Zt2zZSU1Px9PTEx8fnhuoZMWIEkyZNolmzZrRs2ZL33nuPCxcuXNNSMhkZGeTl5ZGTk8POnTuZOnUqZ8+e5fPPP7e3mTBhAiNHjsRisdCrVy/y8/PZsWMHFy5c4MUXX7S3mzVrFs2bNycsLIx33nmHCxcu8NRTTwHQqFEjTCYTX3zxBX369KFWrVp4enre0PF269aN3NxcfvzxRyIiIm6oj1/auHGj/clhERGpOTQDKNdt/vz5tG/fngceeICoqCgMw2DVqlX2y42vvfYa7dq1o2fPntxzzz0EBASUWpZlzJgxmM1mwsPD8fX1JS0t7YZqiYuL409/+hODBg0iKioKT09PevbsedX75H6pRYsWNGjQgPbt2zN58mR69OjBvn37SgTVZ555hnnz5jF//nxat25N165d+fDDD0vNAE6ePJnJkydz++23s2nTJlasWEH9+vUBCAoKYsKECYwdOxZ/f39eeOGFGzpWKL7f8uGHH+bjjz++4T5+afHixSXubxQRkZrBZFTkDVUilcxmsxEWFsZjjz3G3/72twofLzU1lSZNmrB7927atGlT4eMB/PDDD0RHR3P48OEbnkkEWL16NS+99BI//PADzs66GCAiUpNoBlBuaseOHeODDz4gOTmZvXv3MmzYMI4ePUr//v2rurQKExkZyZQpUzh69Gi5+rl48SLz589X+BMRqYH0//xyU3NycuLDDz9kzJgxGIZBREQE69atsz+Acav65dtEbtSjjz5a/kJEROSmpEvAIiIiIjWMLgGLiIiI1DAKgCIiIiI1jAKgiIiISA2jACgiIiJSwygAioiIiNQwCoAiIiIiNYwCoIiIiEgNowAoIiIiUsMoAIqIiIjUMAqAIiIiIjWMAqCIiIhIDaMAKCIiIlLDKACKiIiI1DAKgCIiIiI1zP8HJDr21rWqzrcAAAAASUVORK5CYII=", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -925,18 +928,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f119953ddac3472186a971d9eb4208f7", + "model_id": "7dd4fd57ceb74e25a5361be9bc758a2a", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -998,18 +1001,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c268e19ad1e94f83bb84d78f32eaa497", + "model_id": "ee3f68d82c564ed0a6165adfe2b616ee", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], From b4bffe0475c3be191416c5d9d3aecb563a1ef64b Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Tue, 13 Aug 2024 17:19:41 -0500 Subject: [PATCH 221/240] Clean up documentation --- examples/cost_curves.ipynb | 66 +++++++++++++++++++++++++------------- 1 file changed, 43 insertions(+), 23 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 303731f8..7a3844b3 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -257,13 +257,16 @@ "class CostFunction():\n", " \"\"\"\n", " This class is used to create the ORBIT parameterization, fit a curve, plot the curve, and\n", - " export the function to NRWAL format.\n", - " Use of this function is limited to parameterizations that include `site.depth` and up to\n", - " one other parameter.\n", + " export the function to NRWAL format. Parameterizations are limited to up to two independent\n", + " variables.\n", " \"\"\"\n", " def __init__(self, config: dict, parameters: dict, results: dict):\n", " \"\"\"\n", - " _summary_\n", + " On initialization, the config, parameters, and results dictionaries are prepared for\n", + " use in ORBIT.ParametricManager. Additionally, the independent variables are extracted\n", + " into x and y (for two-variable parameterizations) and z is extracted as the dependent\n", + " variable. Whether the cost function is 3D or 2D is determined by the length of the\n", + " parameters variable.\n", "\n", " Args:\n", " config (str): Configuration settings to added to the base_config or overwrite\n", @@ -275,13 +278,24 @@ " \"\"\"\n", " self.is_3d = False\n", "\n", + " # Other attributes\n", + " # self.parametric\n", + " # self.x\n", + " # self.y\n", + " # self.z\n", + " # self._linear_1d_curve\n", + " # self._quadratic_1d_curve\n", + " # self._poly3_1d_curve\n", + " # self._linear_2d_curve\n", + " # self._quadratic_2d_curve\n", + "\n", " # NOTE: base_config is a global variable\n", " self.config = deepcopy(base_config)\n", " self.config.update(config)\n", "\n", " self.parameters = deepcopy(parameters)\n", " if len(self.parameters) > 2:\n", - " raise ValueError(\"This class is limited to parameterizations with one variable in addition to site.depth\")\n", + " raise ValueError(\"This class is limited to parameterizations with two variables.\")\n", "\n", " # Puts the parameters and results settings into variables for use in parsing the ORBIT\n", " # results and postprocessing the data\n", @@ -327,11 +341,11 @@ " coeffs = Curves.fit(f, self.x, self.z)\n", " self._poly3_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", "\n", - " def logarithmic_1d(self):\n", - " pass\n", + " # def logarithmic_1d(self):\n", + " # pass\n", "\n", - " def exponential_1d(self):\n", - " pass\n", + " # def exponential_1d(self):\n", + " # pass\n", "\n", " def linear_2d(self):\n", " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", @@ -344,12 +358,6 @@ " self._linear_2d_curve = C[0]*self.x + C[1]*self.y + C[2]\n", "\n", " def quadratic_2d(self):\n", - " \"\"\"\n", - " Fits a quadratic surface to the data points.\n", - " x and y are the independent variables, and data is the dependent variable.\n", - " Each of the arguments should be given directly from ORBIT and they are transformed\n", - " here into the required form for use with the curve fitting library.\n", - " \"\"\"\n", " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", "\n", " # best-fit quadratic curve\n", @@ -419,7 +427,13 @@ " np.reshape(self._quadratic_2d_curve, (len(DEPTHS), -1)),\n", " alpha=0.3,\n", " label=\"Quadratic Fit\"\n", - " )" + " )\n", + "\n", + "\n", + " ### --------- Export functions --------- ###\n", + "\n", + " def export(self):\n", + " pass" ] }, { @@ -600,10 +614,9 @@ "source": [ "## Mooring System\n", "\n", + "This block creates a cost model for each type of mooring system.\n", "For all types, the line length is a function of water depth.\n", - "\n", "For TLP systems, line length is the difference between the water depth and the draft.\n", - "\n", "For SemiTaut systems, line length is the sum of rope length and chain length.\n", "Rope length is defined from a fixed relationship for depth and rope lengths.\n", "Chain length is also defined from a fixed relationship for depth and chain diameter.\n", @@ -694,7 +707,6 @@ "cost_semitaut.linear_1d()\n", "\n", "## Plot the ORBIT data and curve fits\n", - "\n", "fig = plt.figure()\n", "\n", "ax = fig.add_subplot(2, 2, 1)\n", @@ -873,7 +885,9 @@ } ], "source": [ - "# Then create functions of two variables\n", + "# Then create functions of two variables.\n", + "# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes\n", + "# some time to run.\n", "\n", "design_phase = \"ArraySystemDesign\"\n", "results = {\n", @@ -952,6 +966,9 @@ } ], "source": [ + "# NOTE: The parameterization and plotting are split in two blocks since the ORBIT model takes\n", + "# some time to run.\n", + "\n", "cost_depth_touchdown_distance.quadratic_2d()\n", "cost_depth_cabledepth.quadratic_2d()\n", "cost_touchdown_cabledepth.quadratic_2d()\n", @@ -987,10 +1004,13 @@ "metadata": {}, "source": [ "## Export System\n", + "\n", + "This block creates a cost model for systems with high voltage alternating current (HVAC) and\n", + "high voltage direct current (HVDC) cables.\n", + "\n", + "Independent variables:\n", "- site.distance_to_landfall\n", - "- Here, we must use parametric.results[\"site.depth\"] instead of the global DEPTHS because the\n", - "- local depth list is broadcast to 2D for the product of the two lists.\n", - "- Plot curves for HVAC and HVDC cable types" + "- Depth" ] }, { From 468bf0e7020025bda024b104d4770d5d1c2687aa Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Wed, 14 Aug 2024 12:24:32 -0500 Subject: [PATCH 222/240] Add export methods --- examples/cost_curves.ipynb | 143 +++++++++++++++++++++++-------------- 1 file changed, 89 insertions(+), 54 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 7a3844b3..898ef8f7 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -208,7 +208,8 @@ " @staticmethod\n", " def polynomial_eval(coeffs, data_points):\n", " \"\"\"\n", - " This method evaluates a curve given a set of coefficients and data points.\n", + " This method evaluates a curve defined by a polynomial equation given a set of\n", + " coefficients and data points.\n", "\n", " Args:\n", " coeffs (list): A list of coefficients for the curve. The order of the\n", @@ -253,6 +254,23 @@ "execution_count": 4, "metadata": {}, "outputs": [], + "source": [ + "orbit_to_nrwal_params = {\n", + " \"site.depth\": \"depth\",\n", + "\n", + " # TODO: what are the nrwal equivalents?\n", + " \"site.mean_windspeed\": \"mean_windspeed\", \n", + " \"mooring_system_design.draft_depth\": \"draft_depth\",\n", + " \"array_system_design.touchdown_distance\": \"touchdown_distance\",\n", + " \"array_system_design.floating_cable_depth\": \"floating_cable_depth\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], "source": [ "class CostFunction():\n", " \"\"\"\n", @@ -283,11 +301,13 @@ " # self.x\n", " # self.y\n", " # self.z\n", - " # self._linear_1d_curve\n", - " # self._quadratic_1d_curve\n", - " # self._poly3_1d_curve\n", - " # self._linear_2d_curve\n", - " # self._quadratic_2d_curve\n", + " # self.x_variable\n", + " # self.y_variable\n", + " self._linear_1d_curve = None\n", + " self._quadratic_1d_curve = None\n", + " self._poly3_1d_curve = None\n", + " self._linear_2d_curve = None\n", + " self._quadratic_2d_curve = None\n", "\n", " # NOTE: base_config is a global variable\n", " self.config = deepcopy(base_config)\n", @@ -326,20 +346,20 @@ " def linear_1d(self):\n", " def f(x, a, b):\n", " return a * x + b\n", - " coeffs = Curves.fit(f, self.x, self.z)\n", - " self._linear_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", "\n", " def quadratic_1d(self):\n", " def f(x, a, b, c):\n", " return a * x**2 + b * x + c\n", - " coeffs = Curves.fit(f, self.x, self.z)\n", - " self._quadratic_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._quadratic_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", "\n", " def poly3_1d(self):\n", " def f(x, a, b, c, d):\n", " return a * x**3 + b * x**2 + c * x + d\n", - " coeffs = Curves.fit(f, self.x, self.z)\n", - " self._poly3_1d_curve = Curves.polynomial_eval(coeffs, self.x)\n", + " self.coeffs = Curves.fit(f, self.x, self.z)\n", + " self._poly3_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", "\n", " # def logarithmic_1d(self):\n", " # pass\n", @@ -351,11 +371,15 @@ " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", "\n", " # Best-fit linear plane\n", - " A = np.c_[data_to_fit[:,0], data_to_fit[:,1], np.ones(data_to_fit.shape[0])]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", + " A = np.c_[\n", + " data_to_fit[:,0],\n", + " data_to_fit[:,1],\n", + " np.ones(data_to_fit.shape[0])\n", + " ]\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2]) # coefficients\n", "\n", " # Evaluate it on the same points as the input data\n", - " self._linear_2d_curve = C[0]*self.x + C[1]*self.y + C[2]\n", + " self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2]\n", "\n", " def quadratic_2d(self):\n", " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", @@ -367,7 +391,7 @@ " np.prod(data_to_fit[:,:2], axis=1),\n", " data_to_fit[:,:2]**2\n", " ]\n", - " C,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", "\n", " # Evaluate it on the same points as the input data\n", " # This dot product is equivalent to the sum of the terms of the polynomial;\n", @@ -382,7 +406,7 @@ " self.x**2,\n", " self.y**2\n", " ],\n", - " C\n", + " self.coeffs\n", " ).reshape(self.x.shape)\n", "\n", "\n", @@ -433,7 +457,32 @@ " ### --------- Export functions --------- ###\n", "\n", " def export(self):\n", - " pass" + "\n", + " x_var = orbit_to_nrwal_params[self.x_variable]\n", + " y_var = orbit_to_nrwal_params[self.y_variable]\n", + "\n", + " if self._linear_1d_curve is not None:\n", + " # y = ax + b\n", + " equation_string = f\"{self.coeffs[0]} * {x_var} + {self.coeffs[1]}\"\n", + "\n", + " if self._quadratic_1d_curve is not None:\n", + " # y = ax^2 + bx + c\n", + " equation_string = f\"{self.coeffs[0]} * {x_var}**2 + {self.coeffs[1]} * {x_var} + {self.coeffs[2]}\"\n", + "\n", + " if self._poly3_1d_curve is not None:\n", + " # y = ax^3 + bx^2 + cx + d\n", + " equation_string = f\"{self.coeffs[0]} * {x_var}**3 + {self.coeffs[1]} * {x_var}**2 + {self.coeffs[2]} * {x_var} + {self.coeffs[3]}\"\n", + "\n", + " if self._linear_2d_curve is not None:\n", + " # z = ax + by + c\n", + " equation_string = f\"{self.coeffs[0]} * {x_var} + {self.coeffs[1]} * {y_var} + {self.coeffs[2]}\"\n", + "\n", + " if self._quadratic_2d_curve is not None:\n", + " # z = ax^2 + bxy + cy^2 + dx + ey + f\n", + " equation_string = f\"{self.coeffs[0]} * {x_var}**2 + {self.coeffs[1]} * {x_var} * {y_var} + {self.coeffs[2]} * {y_var}**2 + {self.coeffs[3]} * {x_var} + {self.coeffs[4]} * {y_var} + {self.coeffs[5]}\"\n", + " \n", + " nrwal_dict = {self.config[\"design_phases\"][0]: equation_string}\n", + " print(nrwal_dict)" ] }, { @@ -456,30 +505,21 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n" + "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n", + "{'MonopileDesign': '-569653.6507413676 * depth**2 + 12505.149549216583 * depth * mean_windspeed + 545620.341771328 * mean_windspeed**2 + 6917.70682201048 * depth + 235.06932424728086 * mean_windspeed + -15478.71617007682'}\n" ] }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "be58a1197e444ab0b1fc72a0f2ffda2a", + "model_id": "6d018f3a67de41949c58d6b5154b4e32", "version_major": 2, "version_minor": 0 }, @@ -527,7 +567,9 @@ "ax.set_zlabel(\"Cost ($)\")\n", "cost_function.plot(ax, plot_data=True)\n", "cost_function.plot(ax, plot_curves=[\"linear_2d\", \"quadratic_2d\"])\n", - "ax.legend()" + "ax.legend()\n", + "\n", + "cost_function.export()" ] }, { @@ -545,23 +587,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5436178715fd44d1aef36b92b2a2ad4b", + "model_id": "a8f1ee876db441ddb9fa84fadf383048", "version_major": 2, "version_minor": 0 }, @@ -626,13 +668,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2e4944b6ae704adda80c6c605318f4e8", + "model_id": "8d8a7457d7344c2aaf38ff923c48b137", "version_major": 2, "version_minor": 0 }, @@ -748,13 +790,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e98e891f1c744b868f297878f2711e0a", + "model_id": "0dcb1b37cb5e404abbb25e7220c3197d", "version_major": 2, "version_minor": 0 }, @@ -853,7 +895,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -864,7 +906,8 @@ "The iteration is not making good progress, as measured by the \n", " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:386\n", "The iteration is not making good progress, as measured by the \n", - " improvement from the last ten iterations." + " improvement from the last ten iterations.RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", + "overflow encountered in cosh" ] }, { @@ -874,14 +917,6 @@ "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n", "Warning: Catenary calculation failed. Reverting to simple vertical profile.\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "RuntimeWarning: /Users/rmudafor/Development/orbit/ORBIT/phases/design/_cables.py:372\n", - "overflow encountered in cosh" - ] } ], "source": [ @@ -936,13 +971,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7dd4fd57ceb74e25a5361be9bc758a2a", + "model_id": "3a67af5ee5cf4406a9adfd20ab4a356a", "version_major": 2, "version_minor": 0 }, @@ -1015,13 +1050,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ee3f68d82c564ed0a6165adfe2b616ee", + "model_id": "0e1d5424ef094fe3b297ed1347bd1b17", "version_major": 2, "version_minor": 0 }, From 19508980a781d1e4ff50f6fecbf26fa962a3be79 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Wed, 14 Aug 2024 22:32:02 -0500 Subject: [PATCH 223/240] Add docs for new curve types --- examples/cost_curves.ipynb | 129 +++++++++++++++++++++++++++++-------- 1 file changed, 101 insertions(+), 28 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 898ef8f7..364a236c 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -26,7 +26,7 @@ "- plant\n", "\n", "2. Configure the notebook by setting the following variables in the \"Configuration\" section:\n", - "- `base_config_path`: the path to the ORBIT configuration file\n", + "- `BASE_CONFIG`: the ORBIT config file at a given path\n", "- `DEPTHS`: a list of water depths to use for cost curves\n", "- `MEAN_WIND_SPEED`: a list of mean wind speed to use for cost curves\n", "- Add any additional global parameter ranges\n", @@ -82,7 +82,18 @@ " cost model.\n", "- A new `CostFunction` instance should be created for each cost model.\n", "\n", - "## Template workflow\n", + "### Plotting API for 2D vs 3D plots\n", + "The `CostFunction` class handles 2D and 3D data seamlessly by using the x and z parameters for 2D\n", + "and adding y for 3D. The appropriate matplotlib API is used depending if the data is 2D or 3D.\n", + "From the calling script, be sure to configure the Axes that is given to `CostFunction.plot` with\n", + "the correct settings for 3D as listed in the table below.\n", + "\n", + "| Matplotlib setting | 2D | 3D |\n", + "|---------------------|----|----|\n", + "| Independent axis labels | `ax.set_xlabel()` | `ax.set_xlabel()`, `ax.set_zlabel()` |\n", + "| Dependent axis label | `ax.set_ylabel()` | `ax.set_zlabel()` |\n", + "\n", + "### Template workflow\n", "\n", "The following code block provides a template for creating a cost function for a model with\n", "two independent parameters.\n", @@ -125,16 +136,81 @@ "# cost_function.plot(ax, plot_data=True, plot_curves=[\"linear_1d\", \"quadratic_1d\"])\n", "```\n", "\n", - "## Plotting API for 2D vs 3D plots\n", - "The `CostFunction` class handles 2D and 3D data seamlessly by using the x and z parameters for 2D\n", - "and adding y for 3D. The appropriate matplotlib API is used depending if the data is 2D or 3D.\n", - "From the calling script, be sure to configure the Axes that is given to `CostFunction.plot` with\n", - "the correct settings for 3D as listed in the table below.\n", + "### Adding a new curve type\n", "\n", - "| Matplotlib setting | 2D | 3D |\n", - "|---------------------|----|----|\n", - "| Independent axis labels | `ax.set_xlabel()` | `ax.set_xlabel()`, `ax.set_zlabel()` |\n", - "| Dependent axis label | `ax.set_ylabel()` | `ax.set_zlabel()` |" + "There are a number of curve fit options in the `CostFunction` class, and more can be added by\n", + "creating a new method and connecting it in some key places in the class.\n", + "First, create a new method on the `CostFunction` class that follows the naming convention of\n", + "`{curve_type}_{dimension}` where `curve_type` is the name of the type of function like\n", + "\"exponential\" or \"linear\" and `dimension` is the number of independent variables the curve.\n", + "The function should return the fitted curve evaluated at the data points given to fit the curve.\n", + "A generic function signature is given below:\n", + "```python\n", + "class CostFunction:\n", + "\n", + " def curvetype_dimension(self):\n", + "\n", + " # Such as:\n", + " def linear_1d(self):\n", + "```\n", + "\n", + "To fit a curve to the data for one independent variable, it is recommended to use the\n", + "`scipy.optimize.curve_fit` function via the `Curves` class.\n", + "In general, a one-dimensional curve fit function will follow the form given below.\n", + "By setting the curve fit function `f`, you define the shape of the curve and set\n", + "the order of the coefficients in `self.coeffs` since they are returned in the order they are\n", + "given in the function signature.\n", + "The `Curves.polynomal_eval` function is available to easily evaluate polynomial curves, but other\n", + "curve-types can be evaluated by simply plugging in the data points (`self.x`) to the fitted\n", + "function.\n", + "\n", + "```python\n", + "# Define a function for a prototype curve; this is where you define the shape of the curve\n", + "def f(x, a, b):\n", + " return a * x + b\n", + "\n", + "# Call the scipy.optimize.curve_fit function and get the coefficients as a Numpy array\n", + "# Note that `self.x` and `self.z` are given since the CostFunction class adds a y\n", + "# only when there are more independent variables.\n", + "self.coeffs = Curves.fit(f, self.x, self.z)\n", + "\n", + "# Evaluate the curve at the data points (self.x)\n", + "self._linear_1d_curve = Curves.polynomial_eval(self.coeffs, self.x)\n", + "```\n", + "\n", + "A two-dimensional curve (surface) fit will typically follow a similar process, as should below.\n", + "For these types, it is recommended to use the `numpy.linalg.lstsq` function.\n", + "First, reshape the data into a new array with each element containing the three-dimensional\n", + "data points.\n", + "Then, stack the data into a column matrix in the form of the equation that you're implementing.\n", + "See the comments in the code block for more information.\n", + "Evaluate the curve at the data points (`self.x`, `self.y`) by stating the form of the curve\n", + "with the coefficients from the curve fit.\n", + "\n", + "```python\n", + " # Reshape the data into a new array with each element containing the three-dimensional data points\n", + " data_to_fit = np.array(list(zip(self.x, self.y, self.z)))\n", + "\n", + " # Stack the data into a column matrix in the form of the equation that you're implementing.\n", + " # Here, the equation is z = ax + by + c and data_to_fit[:,0] are the x values,\n", + " # data_to_fit[:,1] are the y values. The third column is all ones to account for the constant\n", + " # term.\n", + " A = np.c_[\n", + " data_to_fit[:,0],\n", + " data_to_fit[:,1],\n", + " np.ones(data_to_fit.shape[0])\n", + " ]\n", + "\n", + " # Fit the curve to the data; the data is the cost and these are always `self.z` which is data_to_fit[:,2]\n", + " self.coeffs,_,_,_ = linalg.lstsq(A, data_to_fit[:,2])\n", + "\n", + " # Evaluate it on the same points as the input data\n", + " self._linear_2d_curve = self.coeffs[0]*self.x + self.coeffs[1]*self.y + self.coeffs[2]\n", + "```\n", + "\n", + "Finally, save the coefficients to `self.coeffs`, save the evaluated curve to\n", + "`self._{curve_type}_{dimension}_curve`, and add the corresponding if-statements\n", + "in `CostFunction.plot` and `CostFunction.export`." ] }, { @@ -175,8 +251,7 @@ "metadata": {}, "outputs": [], "source": [ - "base_config_path = \"nrwal.yaml\"\n", - "base_config = load_config(base_config_path)\n", + "BASE_CONFIG = load_config(\"nrwal.yaml\")\n", "\n", "DEPTHS = [i for i in range(5, 60, 5)] # Ocean depth in meters\n", "MEAN_WIND_SPEED = [i for i in range(2, 20, 2)] # Mean wind speed in m/s" @@ -186,10 +261,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Curve Fit Library\n", - "\n", - "These functions enable fitting a curve to a set of points based on a variety of curve shapes.\n", - "They should always be generic, so the global variables should not be used here." + "## Curve Fit Library" ] }, { @@ -287,8 +359,8 @@ " parameters variable.\n", "\n", " Args:\n", - " config (str): Configuration settings to added to the base_config or overwrite\n", - " in the base_config. This must include the `design_phases` config.\n", + " config (str): Configuration settings to added to the BASE_CONFIG or overwrite\n", + " in the BASE_CONFIG. This must include the `design_phases` config.\n", " parameters (dict): Parameters to use with ORBIT.ParametricManager; maximum of two\n", " parameters are supported.\n", " results (dict): Results to use with ORBIT.ParametricManager; this must include only\n", @@ -309,8 +381,9 @@ " self._linear_2d_curve = None\n", " self._quadratic_2d_curve = None\n", "\n", - " # NOTE: base_config is a global variable\n", - " self.config = deepcopy(base_config)\n", + " # Start with a copy of the global BASE_CONFIG and update it with the configuration\n", + " # given to this class\n", + " self.config = deepcopy(BASE_CONFIG)\n", " self.config.update(config)\n", "\n", " self.parameters = deepcopy(parameters)\n", @@ -519,7 +592,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6d018f3a67de41949c58d6b5154b4e32", + "model_id": "a0f9dc6d3e374e64b87aba4f4c081aff", "version_major": 2, "version_minor": 0 }, @@ -593,7 +666,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -603,7 +676,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a8f1ee876db441ddb9fa84fadf383048", + "model_id": "5c26456f023a4c7484a1d12c8c8b4251", "version_major": 2, "version_minor": 0 }, @@ -674,7 +747,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8d8a7457d7344c2aaf38ff923c48b137", + "model_id": "95a9c0aa2f2b477392d9fcdebb922177", "version_major": 2, "version_minor": 0 }, @@ -796,7 +869,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0dcb1b37cb5e404abbb25e7220c3197d", + "model_id": "9a3411277de04e3aab6b7410f516c34b", "version_major": 2, "version_minor": 0 }, @@ -977,7 +1050,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3a67af5ee5cf4406a9adfd20ab4a356a", + "model_id": "f975cfcd853c46589bc040a230c6ed88", "version_major": 2, "version_minor": 0 }, @@ -1056,7 +1129,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0e1d5424ef094fe3b297ed1347bd1b17", + "model_id": "7b2246a607534455a3e1c9c4adf88570", "version_major": 2, "version_minor": 0 }, From 314889d45a077af9534a6ce8d9ad370911b8cda4 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 16 Aug 2024 10:17:44 -0600 Subject: [PATCH 224/240] Added test total cost to monopile. Added test total substation costs to electrical design for hvac, hvdc-monopole, hvdc-bipole. Included .upper() to various if-statements checking HVDC or HVAC selection. --- ORBIT/phases/design/electrical_export.py | 16 +++++++------- tests/phases/design/test_electrical_design.py | 21 ++++++++++++++++++- tests/phases/design/test_monopile_design.py | 11 ++++++++++ 3 files changed, 40 insertions(+), 8 deletions(-) diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index 2ca34bfe..f7cdf95b 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -274,7 +274,7 @@ def compute_number_cables(self): num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) - if "HVDC" in self.cable.cable_type: + if "HVDC" in self.cable.cable_type.upper(): num_required *= 2 num_redundant *= 2 @@ -369,7 +369,7 @@ def calc_num_substations(self): "substation_capacity", 1200 ) # MW - if "HVDC" in self.cable.cable_type: + if "HVDC" in self.cable.cable_type.upper(): self.num_substations = self._oss_design.get( "num_substations", int(self.num_cables / 2) ) @@ -406,7 +406,9 @@ def calc_mpt_cost(self): self.num_mpt = self.num_cables self.mpt_cost = ( - 0 if "HVDC" in self.cable.cable_type else self.num_mpt * _mpt_cost + 0 + if "HVDC" in self.cable.cable_type.upper() + else self.num_mpt * _mpt_cost ) self.mpt_rating = ( @@ -426,7 +428,7 @@ def calc_shunt_reactor_cost(self): _key, self.get_default_cost("substation_design", _key) ) - if "HVDC" in self.cable.cable_type: + if "HVDC" in self.cable.cable_type.upper(): self.compensation = 0 else: for cable in self.cables.values(): @@ -445,7 +447,7 @@ def calc_switchgear_costs(self): ) self.num_switchgear = ( - 0 if "HVDC" in self.cable.cable_type else self.num_cables + 0 if "HVDC" in self.cable.cable_type.upper() else self.num_cables ) self.switchgear_cost = self.num_switchgear * switchgear_cost @@ -459,7 +461,7 @@ def calc_dc_breaker_cost(self): ) num_dc_breakers = ( - self.num_cables if "HVDC" in self.cable.cable_type else 0 + self.num_cables if "HVDC" in self.cable.cable_type.upper() else 0 ) self.dc_breaker_cost = num_dc_breakers * dc_breaker_cost @@ -539,7 +541,7 @@ def calc_substructure_mass_and_cost(self): substructure_pile_mass = ( 0 - if "Floating" in self.substructure_type + if self.substructure_type.lower() == "floating" else 8 * substructure_mass**0.5574 ) diff --git a/tests/phases/design/test_electrical_design.py b/tests/phases/design/test_electrical_design.py index 2854b934..696e7af9 100644 --- a/tests/phases/design/test_electrical_design.py +++ b/tests/phases/design/test_electrical_design.py @@ -267,11 +267,23 @@ def test_new_old_hvac_substation(): assert new.shunt_reactor_cost != old.shunt_reactor_cost +def test_hvac_substation(): + config = deepcopy(base) + + hvac = ElectricalDesign(config) + hvac.run() + + assert hvac.total_substation_cost == pytest.approx(134448256, abs=1e0) + + def test_hvdc_substation(): config = deepcopy(base) config["export_system_design"] = {"cables": "HVDC_2000mm_320kV"} elect = ElectricalDesign(config) elect.run() + + assert elect.total_substation_cost == pytest.approx(451924714, abs=1e0) + assert elect.converter_cost != 0 assert elect.shunt_reactor_cost == 0 assert elect.dc_breaker_cost != 0 @@ -285,7 +297,14 @@ def test_hvdc_substation(): elect = ElectricalDesign(config) elect.run() - # assert elect.num_converters == elect.num_cables # breaks + assert elect.total_substation_cost == pytest.approx(802924714, abs=1e0) + + assert elect.converter_cost != 0 + assert elect.shunt_reactor_cost == 0 + assert elect.dc_breaker_cost != 0 + assert elect.switchgear_cost == 0 + assert elect.mpt_cost == 0 + # assert elect.num_cables / elect.num_converters == 2 # breaks def test_onshore_substation(): diff --git a/tests/phases/design/test_monopile_design.py b/tests/phases/design/test_monopile_design.py index 86394893..445059ea 100644 --- a/tests/phases/design/test_monopile_design.py +++ b/tests/phases/design/test_monopile_design.py @@ -117,3 +117,14 @@ def test_transition_piece_kwargs(): results = m._outputs["transition_piece"] assert results != base_results + + +def test_total_cost(): + """Simple unit test to track total cost of base configuration.""" + + mono = MonopileDesign(base) + mono.run() + + print(mono.total_cost) + + assert mono.total_cost == pytest.approx(68833066, abs=1e0) From 8a6fd99c72614c18184eac840be552f4527defa5 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 16 Aug 2024 11:17:53 -0600 Subject: [PATCH 225/240] Added assert system costs to catenary, tlp, and semitaut kwarg tests. Included a .lower() to anchor_type and mooring_type if-statements --- ORBIT/phases/design/mooring_system_design.py | 18 +++++++++++------- .../design/test_mooring_system_design.py | 6 ++++++ 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index ff41c1d1..d85406a1 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -161,7 +161,7 @@ def calculate_line_length_mass(self): """ # Add extra fixed line length for drag embedments - if self.anchor_type == "Drag Embedment": + if any(w in self.anchor_type.lower() for w in ["drag", "embedment"]): fixed = self._design.get("drag_embedment_fixed_length", 500) else: @@ -169,7 +169,7 @@ def calculate_line_length_mass(self): draft = self._design.get("draft_depth", 20) - if self.mooring_type == "SemiTaut": + if "semitaut" in self.mooring_type.lower(): # Interpolation of rope and chain length at project depth self.chain_length = interp1d( @@ -209,7 +209,7 @@ def calculate_line_length_mass(self): + self.rope_length * rope_mass_per_m ) / 1e3 # tonnes - elif self.mooring_type == "TLP": + elif "tlp" in self.mooring_type.lower(): self.line_length = self.depth - draft @@ -233,9 +233,11 @@ def calculate_anchor_mass_cost(self): different anchors. """ - if self.mooring_type == "SemiTaut": + if "semitaut" in self.mooring_type.lower(): - if self.anchor_type == "Drag Embedment": + if any( + w in self.anchor_type.lower() for w in ["drag", "embedment"] + ): self.anchor_mass = 20 # Interpolation of anchor cost at project depth @@ -253,7 +255,9 @@ def calculate_anchor_mass_cost(self): else: - if self.anchor_type == "Drag Embedment": + if any( + w in self.anchor_type.lower() for w in ["drag", "embedment"] + ): self.anchor_mass = 20 self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 @@ -267,7 +271,7 @@ def calculate_anchor_mass_cost(self): def line_cost(self): """Returns cost of one line mooring line.""" - if self.mooring_type == "SemiTaut": + if "semitaut" in self.mooring_type.lower(): # Interpolation of line cost at project depth line_cost = interp1d( self._semitaut_params["depths"], diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index b726a50f..8265dbc1 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -80,6 +80,8 @@ def test_catenary_mooring_system_kwargs(): base_cost = moor.detailed_output["system_cost"] + assert base_cost == pytest.approx(76173891, abs=1e0) + for k, v in test_kwargs.items(): config = deepcopy(base) config["mooring_system_design"] = {} @@ -108,6 +110,8 @@ def test_semitaut_mooring_system_kwargs(): base_cost = moor.detailed_output["system_cost"] + assert base_cost == pytest.approx(102227311, abs=1e0) + for k, v in test_kwargs.items(): config = deepcopy(semi_base) config["mooring_system_design"] = {} @@ -136,6 +140,8 @@ def test_tlp_mooring_system_kwargs(): base_cost = moor.detailed_output["system_cost"] + assert base_cost == pytest.approx(57633231, abs=1e0) + for k, v in test_kwargs.items(): config = deepcopy(tlp_base) config["mooring_system_design"] = {} From e49d4cf44809603c47be0cd42652dcb889d096d3 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 16 Aug 2024 11:28:20 -0600 Subject: [PATCH 226/240] Added test total cost to oss, semisub, and spar design. --- tests/phases/design/test_oss_design.py | 8 ++++++++ tests/phases/design/test_semisubmersible_design.py | 8 ++++++++ tests/phases/design/test_spar_design.py | 8 ++++++++ 3 files changed, 24 insertions(+) diff --git a/tests/phases/design/test_oss_design.py b/tests/phases/design/test_oss_design.py index 9f3c0ba5..619011a7 100644 --- a/tests/phases/design/test_oss_design.py +++ b/tests/phases/design/test_oss_design.py @@ -86,3 +86,11 @@ def test_oss_kwargs(): cost = o.total_cost assert cost != base_cost + + +def test_total_cost(): + + oss = OffshoreSubstationDesign(base) + oss.run() + + assert oss.total_cost == pytest.approx(158022050, abs=1e0) diff --git a/tests/phases/design/test_semisubmersible_design.py b/tests/phases/design/test_semisubmersible_design.py index 2716d627..2facbfc1 100644 --- a/tests/phases/design/test_semisubmersible_design.py +++ b/tests/phases/design/test_semisubmersible_design.py @@ -65,3 +65,11 @@ def test_design_kwargs(): cost = s.total_cost assert cost != base_cost + + +def test_total_cost(): + + semi = SemiSubmersibleDesign(base) + semi.run() + + assert semi.total_cost == pytest.approx(630709636, abs=1e0) diff --git a/tests/phases/design/test_spar_design.py b/tests/phases/design/test_spar_design.py index 5db7d582..c37b21d7 100644 --- a/tests/phases/design/test_spar_design.py +++ b/tests/phases/design/test_spar_design.py @@ -65,3 +65,11 @@ def test_design_kwargs(): cost = s.total_cost assert cost != base_cost + + +def test_total_cost(): + + spar = SparDesign(base) + spar.run() + + assert spar.total_cost == pytest.approx(698569358, abs=1e0) From 3def1e5e5defc31944652f28ac062fcaa6199f15 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 16 Aug 2024 11:28:55 -0600 Subject: [PATCH 227/240] added test total cable cost to array system design. --- tests/phases/design/test_array_system_design.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tests/phases/design/test_array_system_design.py b/tests/phases/design/test_array_system_design.py index feeab3f5..e7e1e4b4 100644 --- a/tests/phases/design/test_array_system_design.py +++ b/tests/phases/design/test_array_system_design.py @@ -239,3 +239,11 @@ def test_floating_calculations(): with_cat_length = sim3.total_length assert with_cat_length < no_cat_length + + +def test_total_cable_cost(): + + array = ArraySystemDesign(config_full_ring) + array.run() + + assert array.total_cable_cost == pytest.approx(11969999, abs=1e0) From 7f8a8f8714a42b9eb5cd9659468a565169d44eb6 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 20 Aug 2024 15:10:07 -0600 Subject: [PATCH 228/240] Changed recent lower() and upper() case checks to title() case. --- ORBIT/phases/design/_cables.py | 13 +++++++++- ORBIT/phases/design/electrical_export.py | 18 ++++++-------- ORBIT/phases/design/mooring_system_design.py | 26 ++++++++++---------- 3 files changed, 33 insertions(+), 24 deletions(-) diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 3b5be8ed..56410eea 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -84,7 +84,18 @@ def __init__(self, cable_specs, **kwargs): raise ValueError(f"{needs_value} must be defined in cable_specs") self.line_frequency = cable_specs.get("line_frequency", 60) - self.cable_type = cable_specs.get("cable_type", "HVAC") + cable_type = cable_specs.get("cable_type", "HVAC").split("-") + if len(cable_type) == 1: + self.cable_type = cable_type[0].upper() + elif len(cable_type) == 2: + self.cable_type = ( + f"{cable_type[0].upper()}-{cable_type[1].lower()}" + ) + else: + raise ValueError( + "`cable_type` should be of the form `type-subtype`," + " e.g. 'HVDC-monopole'." + ) # Calc additional cable specs if self.cable_type == "HVAC": diff --git a/ORBIT/phases/design/electrical_export.py b/ORBIT/phases/design/electrical_export.py index f7cdf95b..db06635b 100644 --- a/ORBIT/phases/design/electrical_export.py +++ b/ORBIT/phases/design/electrical_export.py @@ -140,7 +140,7 @@ def __init__(self, config, **kwargs): self.substructure_type = self._oss_design.get( "oss_substructure_type", "Monopile" - ) + ).title() self._outputs = {} @@ -274,7 +274,7 @@ def compute_number_cables(self): num_required = np.ceil(self._plant_capacity / self.cable.cable_power) num_redundant = self._design.get("num_redundant", 0) - if "HVDC" in self.cable.cable_type.upper(): + if "HVDC" in self.cable.cable_type: num_required *= 2 num_redundant *= 2 @@ -369,7 +369,7 @@ def calc_num_substations(self): "substation_capacity", 1200 ) # MW - if "HVDC" in self.cable.cable_type.upper(): + if "HVDC" in self.cable.cable_type: self.num_substations = self._oss_design.get( "num_substations", int(self.num_cables / 2) ) @@ -406,9 +406,7 @@ def calc_mpt_cost(self): self.num_mpt = self.num_cables self.mpt_cost = ( - 0 - if "HVDC" in self.cable.cable_type.upper() - else self.num_mpt * _mpt_cost + 0 if "HVDC" in self.cable.cable_type else self.num_mpt * _mpt_cost ) self.mpt_rating = ( @@ -428,7 +426,7 @@ def calc_shunt_reactor_cost(self): _key, self.get_default_cost("substation_design", _key) ) - if "HVDC" in self.cable.cable_type.upper(): + if "HVDC" in self.cable.cable_type: self.compensation = 0 else: for cable in self.cables.values(): @@ -447,7 +445,7 @@ def calc_switchgear_costs(self): ) self.num_switchgear = ( - 0 if "HVDC" in self.cable.cable_type.upper() else self.num_cables + 0 if "HVDC" in self.cable.cable_type else self.num_cables ) self.switchgear_cost = self.num_switchgear * switchgear_cost @@ -461,7 +459,7 @@ def calc_dc_breaker_cost(self): ) num_dc_breakers = ( - self.num_cables if "HVDC" in self.cable.cable_type.upper() else 0 + self.num_cables if "HVDC" in self.cable.cable_type else 0 ) self.dc_breaker_cost = num_dc_breakers * dc_breaker_cost @@ -541,7 +539,7 @@ def calc_substructure_mass_and_cost(self): substructure_pile_mass = ( 0 - if self.substructure_type.lower() == "floating" + if self.substructure_type == "Floating" else 8 * substructure_mass**0.5574 ) diff --git a/ORBIT/phases/design/mooring_system_design.py b/ORBIT/phases/design/mooring_system_design.py index d85406a1..8447d206 100644 --- a/ORBIT/phases/design/mooring_system_design.py +++ b/ORBIT/phases/design/mooring_system_design.py @@ -73,8 +73,12 @@ def __init__(self, config, **kwargs): self._design = self.config.get("mooring_system_design", {}) self.num_lines = self._design.get("num_lines", 4) - self.anchor_type = self._design.get("anchor_type", "Suction Pile") - self.mooring_type = self._design.get("mooring_type", "Catenary") + self.anchor_type = self._design.get( + "anchor_type", "Suction Pile" + ).title() + self.mooring_type = self._design.get( + "mooring_type", "Catenary" + ).title() # Semi-Taut mooring system design parameters based on depth [2]. self._semitaut_params = { @@ -161,7 +165,7 @@ def calculate_line_length_mass(self): """ # Add extra fixed line length for drag embedments - if any(w in self.anchor_type.lower() for w in ["drag", "embedment"]): + if self.anchor_type == "Drag Embedment": fixed = self._design.get("drag_embedment_fixed_length", 500) else: @@ -169,7 +173,7 @@ def calculate_line_length_mass(self): draft = self._design.get("draft_depth", 20) - if "semitaut" in self.mooring_type.lower(): + if self.mooring_type == "Semitaut": # Interpolation of rope and chain length at project depth self.chain_length = interp1d( @@ -209,7 +213,7 @@ def calculate_line_length_mass(self): + self.rope_length * rope_mass_per_m ) / 1e3 # tonnes - elif "tlp" in self.mooring_type.lower(): + elif self.mooring_type == "Tlp": self.line_length = self.depth - draft @@ -233,11 +237,9 @@ def calculate_anchor_mass_cost(self): different anchors. """ - if "semitaut" in self.mooring_type.lower(): + if self.mooring_type == "Semitaut": - if any( - w in self.anchor_type.lower() for w in ["drag", "embedment"] - ): + if self.anchor_type == "Drag Embedment": self.anchor_mass = 20 # Interpolation of anchor cost at project depth @@ -255,9 +257,7 @@ def calculate_anchor_mass_cost(self): else: - if any( - w in self.anchor_type.lower() for w in ["drag", "embedment"] - ): + if self.anchor_type == "Drag Embedment": self.anchor_mass = 20 self.anchor_cost = self.breaking_load / 9.81 / 20.0 * 2000.0 @@ -271,7 +271,7 @@ def calculate_anchor_mass_cost(self): def line_cost(self): """Returns cost of one line mooring line.""" - if "semitaut" in self.mooring_type.lower(): + if self.mooring_type == "Semitaut": # Interpolation of line cost at project depth line_cost = interp1d( self._semitaut_params["depths"], From f54fa0af58687f365d30d9b7413f4ce4219f4a87 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Tue, 20 Aug 2024 15:16:38 -0600 Subject: [PATCH 229/240] Added test total capex for fixed and floating project at PM level. --- tests/test_project_manager.py | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/test_project_manager.py b/tests/test_project_manager.py index 777f1680..140f36f6 100644 --- a/tests/test_project_manager.py +++ b/tests/test_project_manager.py @@ -26,6 +26,9 @@ config = extract_library_specs("config", "project_manager") complete_project = extract_library_specs("config", "complete_project") +complete_floating_project = extract_library_specs( + "config", "complete_floating_project" +) # Top Level @@ -921,3 +924,17 @@ def test_capex_categories(): new_breakdown["Export System Installation"] > baseline["Export System Installation"] ) + + +def test_total_capex(): + """Test total capex for baseline fixed and floating project.""" + + fix_project = ProjectManager(complete_project) + fix_project.run() + + assert fix_project.total_capex == pytest.approx(1207278397.56, abs=1e-1) + + flt_project = ProjectManager(complete_floating_project) + flt_project.run() + + assert flt_project.total_capex == pytest.approx(3284781912.73, abs=1e-1) From c6d44472d8a0c9121c363e8ef6b018fd52f1b752 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Wed, 21 Aug 2024 15:48:23 -0500 Subject: [PATCH 230/240] Add comments on inputs --- examples/nrwal.yaml | 44 +++++++++++++++++++++----------------------- 1 file changed, 21 insertions(+), 23 deletions(-) diff --git a/examples/nrwal.yaml b/examples/nrwal.yaml index 8ea2c9ee..561dbfa7 100644 --- a/examples/nrwal.yaml +++ b/examples/nrwal.yaml @@ -1,3 +1,4 @@ +# --- Minimum Required --- site: depth: 30 distance: 100 @@ -10,11 +11,7 @@ plant: row_spacing: 7 substation_distance: 1 turbine_spacing: 7 - - - - - +# --- Additional Configs --- OffshoreSubstationInstallation: feeder: example_heavy_feeder num_feeders: 1 @@ -24,28 +21,11 @@ array_system_design: - XLPE_630mm_66kV commissioning: 0.01 decommissioning: 0.15 -# design_phases: -# - MonopileDesign -# - ScourProtectionDesign -# - ArraySystemDesign -# - ExportSystemDesign -# - OffshoreSubstationDesign export_cable_bury_vessel: example_cable_lay_vessel export_cable_install_vessel: example_cable_lay_vessel export_system_design: cables: XLPE_1000mm_220kV percent_added_length: 0.05 -# install_phases: -# ArrayCableInstallation: 0 -# ExportCableInstallation: 0 -# MonopileInstallation: !!python/tuple -# - ScourProtectionInstallation -# - 0.5 -# OffshoreSubstationInstallation: 0 -# ScourProtectionInstallation: 0 -# TurbineInstallation: !!python/tuple -# - MonopileInstallation -# - 0.1 landfall: interconnection_distance: 3 trench_length: 2 @@ -59,4 +39,22 @@ wtiv: example_wtiv port: monthly_rate: 2000000.0 sub_assembly_lines: 1 - turbine_assembly_cranes: 1 \ No newline at end of file + turbine_assembly_cranes: 1 +# --- Don't specify these here since they're set in the curve generator --- +# design_phases: +# - MonopileDesign +# - ScourProtectionDesign +# - ArraySystemDesign +# - ExportSystemDesign +# - OffshoreSubstationDesign +# install_phases: +# ArrayCableInstallation: 0 +# ExportCableInstallation: 0 +# MonopileInstallation: !!python/tuple +# - ScourProtectionInstallation +# - 0.5 +# OffshoreSubstationInstallation: 0 +# ScourProtectionInstallation: 0 +# TurbineInstallation: !!python/tuple +# - MonopileInstallation +# - 0.1 From ad6e8c8eafcfdd53a12c4c6e334b902b587a709e Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Wed, 21 Aug 2024 16:55:38 -0500 Subject: [PATCH 231/240] Add offshore floating substation function --- examples/cost_curves.ipynb | 247 ++++++++++++++++++++++++++++++------- 1 file changed, 204 insertions(+), 43 deletions(-) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 364a236c..2cb7ea41 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -226,6 +226,7 @@ "import numpy as np\n", "import pandas as pd\n", "from scipy import stats, optimize, linalg\n", + "import yaml\n", "\n", "from ORBIT import (\n", " ParametricManager,\n", @@ -257,6 +258,22 @@ "MEAN_WIND_SPEED = [i for i in range(2, 20, 2)] # Mean wind speed in m/s" ] }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "orbit_to_nrwal_params = {\n", + " \"site.depth\": \"depth\",\n", + " \"site.mean_windspeed\": \"mean_windspeed\", # Not in NRWAL\n", + " \"site.distance_to_landfall\": \"dist_s_to_l\",\n", + " \"mooring_system_design.draft_depth\": \"draft_depth\", # Not in NRWAL\n", + " \"array_system_design.touchdown_distance\": \"touchdown_distance\", # Not in NRWAL\n", + " \"array_system_design.floating_cable_depth\": \"floating_cable_depth\", # Not in NRWAL\n", + "}" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -266,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -321,23 +338,6 @@ " return popt" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "orbit_to_nrwal_params = {\n", - " \"site.depth\": \"depth\",\n", - "\n", - " # TODO: what are the nrwal equivalents?\n", - " \"site.mean_windspeed\": \"mean_windspeed\", \n", - " \"mooring_system_design.draft_depth\": \"draft_depth\",\n", - " \"array_system_design.touchdown_distance\": \"touchdown_distance\",\n", - " \"array_system_design.floating_cable_depth\": \"floating_cable_depth\",\n", - "}" - ] - }, { "cell_type": "code", "execution_count": 5, @@ -529,33 +529,78 @@ "\n", " ### --------- Export functions --------- ###\n", "\n", - " def export(self):\n", + " def export(self, filename: str, key: str, comments: str = \"\"):\n", + " \"\"\"\n", + " This function writes the curve equation to a file for use in NRWAL.\n", + "\n", + " Args:\n", + " filename (str): The file to write the curve equation to. If the file exists, the\n", + " equation is appended to the end of the file.\n", + " key (str): The key to use in the NRWAL file for the curve equation. In the key-value\n", + " pair, this argument is the key and the value is the equation string.\n", + " \"\"\"\n", "\n", " x_var = orbit_to_nrwal_params[self.x_variable]\n", - " y_var = orbit_to_nrwal_params[self.y_variable]\n", + " if self.is_3d:\n", + " y_var = orbit_to_nrwal_params[self.y_variable]\n", "\n", + " F = \"{:.1f}\"\n", + " S = \"{:s}\"\n", " if self._linear_1d_curve is not None:\n", " # y = ax + b\n", - " equation_string = f\"{self.coeffs[0]} * {x_var} + {self.coeffs[1]}\"\n", + " equation_string = f\"{F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1])\n", "\n", " if self._quadratic_1d_curve is not None:\n", " # y = ax^2 + bx + c\n", - " equation_string = f\"{self.coeffs[0]} * {x_var}**2 + {self.coeffs[1]} * {x_var} + {self.coeffs[2]}\"\n", + " equation_string = f\"{F} * {S}**2 + {F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1], x_var, self.coeffs[2])\n", "\n", " if self._poly3_1d_curve is not None:\n", " # y = ax^3 + bx^2 + cx + d\n", - " equation_string = f\"{self.coeffs[0]} * {x_var}**3 + {self.coeffs[1]} * {x_var}**2 + {self.coeffs[2]} * {x_var} + {self.coeffs[3]}\"\n", + " equation_string = (\n", + " f\"{F} * {S}**3\"\n", + " f\" + {F} * {S}**2\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F}\".format(\n", + " self.coeffs[0], x_var,\n", + " self.coeffs[1], x_var,\n", + " self.coeffs[2], x_var,\n", + " self.coeffs[3]\n", + " )\n", + " )\n", "\n", " if self._linear_2d_curve is not None:\n", " # z = ax + by + c\n", - " equation_string = f\"{self.coeffs[0]} * {x_var} + {self.coeffs[1]} * {y_var} + {self.coeffs[2]}\"\n", + " equation_string = f\"{F} * {S} + {F} * {S} + {F}\".format(self.coeffs[0], x_var, self.coeffs[1], y_var, self.coeffs[2])\n", "\n", " if self._quadratic_2d_curve is not None:\n", " # z = ax^2 + bxy + cy^2 + dx + ey + f\n", - " equation_string = f\"{self.coeffs[0]} * {x_var}**2 + {self.coeffs[1]} * {x_var} * {y_var} + {self.coeffs[2]} * {y_var}**2 + {self.coeffs[3]} * {x_var} + {self.coeffs[4]} * {y_var} + {self.coeffs[5]}\"\n", - " \n", - " nrwal_dict = {self.config[\"design_phases\"][0]: equation_string}\n", - " print(nrwal_dict)" + " equation_string = (\n", + " f\"{F} * {S}**2\"\n", + " f\" + {F} * {S} * {S}\"\n", + " f\" + {F} * {S}**2\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F} * {S}\"\n", + " f\" + {F}\".format(\n", + " self.coeffs[0], x_var,\n", + " self.coeffs[1], x_var, y_var,\n", + " self.coeffs[2], y_var,\n", + " self.coeffs[3], x_var,\n", + " self.coeffs[4], y_var,\n", + " self.coeffs[5]\n", + " )\n", + " )\n", + "\n", + " # nrwal_dict = {self.config[\"design_phases\"][0]: equation_string}\n", + " nrwal_dict = {key: equation_string}\n", + "\n", + " with open(filename, \"a\") as f:\n", + " f.write(\"\\n\")\n", + " if comments:\n", + " f.write(f\"# {comments}\\n\")\n", + " # f.write(f\"# {self.config['design_phases'][0]}\\n\")\n", + " yaml.dump(nrwal_dict, f)\n", + " f.write(f\"\\n\")\n", + " print(nrwal_dict)" ] }, { @@ -586,13 +631,13 @@ "output_type": "stream", "text": [ "ORBIT library intialized at '/Users/rmudafor/Development/orbit/library'\n", - "{'MonopileDesign': '-569653.6507413676 * depth**2 + 12505.149549216583 * depth * mean_windspeed + 545620.341771328 * mean_windspeed**2 + 6917.70682201048 * depth + 235.06932424728086 * mean_windspeed + -15478.71617007682'}\n" + "{'substructure_17MW': '-569653.7 * depth**2 + 12505.1 * depth * mean_windspeed + 545620.3 * mean_windspeed**2 + 6917.7 * depth + 235.1 * mean_windspeed + -15478.7'}\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0f9dc6d3e374e64b87aba4f4c081aff", + "model_id": "d67df42313104cf1a234f208e058429d", "version_major": 2, "version_minor": 0 }, @@ -642,7 +687,7 @@ "cost_function.plot(ax, plot_curves=[\"linear_2d\", \"quadratic_2d\"])\n", "ax.legend()\n", "\n", - "cost_function.export()" + "cost_function.export(\"substructure.yaml\", \"substructure_17MW\")" ] }, { @@ -666,7 +711,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -676,7 +721,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5c26456f023a4c7484a1d12c8c8b4251", + "model_id": "4b13254c2f314312b9419d72d1c138c8", "version_major": 2, "version_minor": 0 }, @@ -744,10 +789,19 @@ "execution_count": 8, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'catenary': '199913.5 * depth + 34961743.3'}\n", + "{'tlp': '156672.0 * depth + -156672.0 * draft_depth + 27496949.2'}\n", + "{'semitaut': '227446.8 * depth + 32803637.2'}\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "95a9c0aa2f2b477392d9fcdebb922177", + "model_id": "9527723938a24d85b577e15df912cbfb", "version_major": 2, "version_minor": 0 }, @@ -844,7 +898,11 @@ "ax.set_xlabel(\"Depth (m)\")\n", "ax.set_ylabel(\"Cost ($)\")\n", "cost_semitaut.plot(ax, plot_data=True)\n", - "cost_semitaut.plot(ax, plot_curves=[\"linear_1d\"])" + "cost_semitaut.plot(ax, plot_curves=[\"linear_1d\"])\n", + "\n", + "cost_catenary.export(\"mooring_system.yaml\", \"catenary\")\n", + "cost_tlp.export(\"mooring_system.yaml\", \"tlp\")\n", + "cost_semitaut.export(\"mooring_system.yaml\", \"semitaut\")" ] }, { @@ -869,7 +927,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9a3411277de04e3aab6b7410f516c34b", + "model_id": "daeda722d6574a2198151c690f55f0cc", "version_major": 2, "version_minor": 0 }, @@ -1050,7 +1108,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f975cfcd853c46589bc040a230c6ed88", + "model_id": "a228ee4b8be142bdb82efb0c18561d66", "version_major": 2, "version_minor": 0 }, @@ -1107,6 +1165,23 @@ "cost_touchdown_cabledepth.plot(ax, plot_curves=[\"quadratic_2d\"])" ] }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'floating': '36269853.8 * floating_cable_depth**2 + 28303.7 * floating_cable_depth * touchdown_distance + -9366.7 * touchdown_distance**2 + -117.4 * floating_cable_depth + -249.9 * touchdown_distance + 83.8'}\n" + ] + } + ], + "source": [ + "cost_touchdown_cabledepth.export(\"array_system.yaml\", \"floating\")" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1123,13 +1198,21 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'floating_hvac': '2840.0 * depth + 2840000.0 * dist_s_to_l + 8520000.0'}\n", + "{'floating_hvdc': '828.0 * depth + 828000.0 * dist_s_to_l + 2484000.0'}\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7b2246a607534455a3e1c9c4adf88570", + "model_id": "cf34930026454aa1a7d8511a87c5cce3", "version_major": 2, "version_minor": 0 }, @@ -1207,15 +1290,93 @@ "ax.set_ylabel(\"Distance to Landfall (m)\")\n", "ax.set_zlabel(\"Cost ($)\")\n", "cost_hvdc.plot(ax, plot_data=True)\n", - "cost_hvdc.plot(ax, plot_curves=[\"linear_2d\"])" + "cost_hvdc.plot(ax, plot_curves=[\"linear_2d\"])\n", + "\n", + "\n", + "multiline_comment = \"\\n# \".join([\n", + " \"The floating HVAC mooring system is \",\n", + " \"special because it's the only one that \",\n", + " \"is like it is.\"\n", + "])\n", + "cost_hvac.export(\"export_system.yaml\", \"floating_hvac\", comments=multiline_comment)\n", + "\n", + "singleline_comment = \"HVDC export system\"\n", + "cost_hvdc.export(\"export_system.yaml\", \"floating_hvdc\", comments=singleline_comment)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Offshore Floating Substation\n", + "\n", + "This component is not a function of a spatially varying parameter, but it is included to complete\n", + "the export of the capex breakdown components." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'oss_substructure': '0.0 * depth + 2005200.0'}\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4960b52c4ec14543a4d3f0cf4ba7b7aa", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cost_function = CostFunction(\n", + " config={\"design_phases\": [\"OffshoreFloatingSubstationDesign\"]},\n", + " parameters={\n", + " \"site.depth\": DEPTHS,\n", + " },\n", + " results={\n", + " \"offshore_substation_substructure\": lambda run: run.design_results[\"offshore_substation_substructure\"][\"unit_cost\"],\n", + " }\n", + ")\n", + "cost_function.run()\n", + "\n", + "cost_function.linear_1d()\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "ax.set_title(\"Offshore Floating Substation\")\n", + "ax.set_xlabel(\"Depth (m)\")\n", + "ax.set_ylabel(\"Cost ($)\")\n", + "cost_function.plot(ax, plot_data=True)\n", + "cost_function.plot(ax, plot_curves=[\"linear_1d\"])\n", + "ax.legend()\n", + "\n", + "cost_function.export(\"oss.yaml\", \"oss_substructure\")" + ] } ], "metadata": { From fba2cc34f61105c387c9a3bf4e71f3b14adfd734 Mon Sep 17 00:00:00 2001 From: Rafael M Mudafort Date: Wed, 21 Aug 2024 17:02:54 -0500 Subject: [PATCH 232/240] Add export equation line to template workflow --- examples/cost_curves.ipynb | 3 +++ 1 file changed, 3 insertions(+) diff --git a/examples/cost_curves.ipynb b/examples/cost_curves.ipynb index 2cb7ea41..8620b1af 100644 --- a/examples/cost_curves.ipynb +++ b/examples/cost_curves.ipynb @@ -134,6 +134,9 @@ "cost_function.plot(ax, plot_curves=[\"linear_1d\", \"quadratic_1d\"]) # These curves must have been generated first\n", "# alternatively, the two lines above could be combined into a single line:\n", "# cost_function.plot(ax, plot_data=True, plot_curves=[\"linear_1d\", \"quadratic_1d\"])\n", + "\n", + "# Export the curve function to a NRWAL-compatible file\n", + "cost_function.export(\"design.yaml\", \"design_system\")\n", "```\n", "\n", "### Adding a new curve type\n", From 35ec7489b6ce9dcdb0adb0aa05b0c9c0d069ec79 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Wed, 11 Sep 2024 16:43:38 -0600 Subject: [PATCH 233/240] Reverting monopile mass assertion after load_factor was adjusted. --- tests/phases/design/test_monopile_design.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/phases/design/test_monopile_design.py b/tests/phases/design/test_monopile_design.py index 445059ea..436879e3 100644 --- a/tests/phases/design/test_monopile_design.py +++ b/tests/phases/design/test_monopile_design.py @@ -54,7 +54,7 @@ def test_paramater_sweep(depth, mean_ws, turbine): assert 4 < m._outputs["monopile"]["diameter"] < 13 # Check valid monopile mass - assert 200 < m._outputs["monopile"]["mass"] < 5000 + assert 200 < m._outputs["monopile"]["mass"] < 2500 # Check valid transition piece diameter assert 4 < m._outputs["transition_piece"]["diameter"] < 14 From aa048235e6f9891303f936b6b5a663840b2a053c Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 13 Sep 2024 10:55:47 -0600 Subject: [PATCH 234/240] Cleaned up Floating Example to include semitaut options. Removed semitaut classes and redundant files. Deleted old cable file. --- .../design/SemiTaut_mooring_system_design.py | 189 ------ ...5. Example Floating Project-SemiTaut.ipynb | 642 ------------------ examples/5. Example Floating Project.ipynb | 295 +++++--- .../configs/example_floating_project.yaml | 4 +- .../example_floating_project_SemiTaut.yaml | 58 -- library/cables/XLPE_1000m_220kV_dynamic.yaml | 10 - 6 files changed, 214 insertions(+), 984 deletions(-) delete mode 100644 ORBIT/phases/design/SemiTaut_mooring_system_design.py delete mode 100644 examples/5. Example Floating Project-SemiTaut.ipynb delete mode 100644 examples/configs/example_floating_project_SemiTaut.yaml delete mode 100644 library/cables/XLPE_1000m_220kV_dynamic.yaml diff --git a/ORBIT/phases/design/SemiTaut_mooring_system_design.py b/ORBIT/phases/design/SemiTaut_mooring_system_design.py deleted file mode 100644 index 11c0edcc..00000000 --- a/ORBIT/phases/design/SemiTaut_mooring_system_design.py +++ /dev/null @@ -1,189 +0,0 @@ -"""`MooringSystemDesign` and related functionality.""" - -__author__ = "Jake Nunemaker, modified by Becca F." -__copyright__ = "Copyright 2020, National Renewable Energy Laboratory" -__maintainer__ = "Jake Nunemaker" -__email__ = "jake.nunemaker@nrel.gov & rebecca.fuchs@nrel.gov" - -import numpy as np -from scipy.interpolate import interp1d - -from ORBIT.phases.design import DesignPhase - - -class SemiTautMooringSystemDesign(DesignPhase): - """SemiTaut Mooring System and Anchor Design.""" - - expected_config = { - "site": {"depth": "float"}, - "turbine": {"turbine_rating": "int | float"}, - "plant": {"num_turbines": "int"}, - "mooring_system_design": { - "num_lines": "int | float (optional, default: 4)", - "anchor_type": "str (optional, default: 'Drag Embedment')", - "mooring_line_cost_rate": "int | float (optional)", - "drag_embedment_fixed_length": "int | float (optional, default: .5km)", - }, - } - - output_config = { - "mooring_system": { - "num_lines": "int", - # "line_diam": "m, float", # this is not needed for mooring.py - "line_mass": "t", # you need this for mooring.py (mooring installation module) - "line_cost": "USD", # you can calculate this based on each rope&chain length & diameter. - "line_length": "m", # this can be calculated from rope length and chain length (which you get from an empirical eqn as function of depth) - "anchor_mass": "t", # you need this for mooring.py (mooring installation module) - "anchor_type": "str", # keep, changed default to drag embedment. - "anchor_cost": "USD", # this can be calculated also as a function of (depth?) from the empirical data you have. - }, - } - - def __init__(self, config, **kwargs): - """ - Creates an instance of SemiTautMooringSystemDesign. - - Parameters - ---------- - config : dict - """ - - config = self.initialize_library(config, **kwargs) - self.config = self.validate_config(config) - self.num_turbines = self.config["plant"]["num_turbines"] - - self._design = self.config.get("mooring_system_design", {}) - self.num_lines = self._design.get("num_lines", 4) - self.anchor_type = self._design.get("anchor_type", "Drag Embedment") - - self._outputs = {} - - def run(self): - """Main run function.""" - - self.calculate_line_length_mass() - self.determine_mooring_line_cost() - self.calculate_anchor_mass_cost() - - self._outputs["mooring_system"] = {**self.design_result} - - def calculate_line_length_mass(self): - """Returns the mooring line length and mass.""" - - depth = self.config["site"]["depth"] - - # Input hybrid mooring system design from Cooperman et al. (2022), - # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore - # Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy - # Areas, California - depths = np.array([500, 750, 1000, 1250, 1500]) - rope_lengths = np.array([478.41, 830.34, 1229.98, 1183.93, 1079.62]) - rope_diameters = np.array( - [0.2, 0.2, 0.2, 0.2, 0.2] - ) # you need the diameter for the cost data - chain_lengths = np.array([917.11, 800.36, 609.07, 896.42, 1280.57]) - chain_diameters = np.array([0.13, 0.17, 0.22, 0.22, 0.22]) - - # Interpolate - finterp_rope = interp1d(depths, rope_lengths) - finterp_chain = interp1d(depths, chain_lengths) - finterp_rope_diam = interp1d(depths, rope_diameters) - finterp_chain_diam = interp1d(depths, chain_diameters) - - # Rope and chain length at project depth - self.chain_length = finterp_chain(depth) - self.rope_length = finterp_rope(depth) - # Rope and chain diameter at project depth - self.rope_diameter = finterp_rope_diam(depth) - self.chain_diameter = finterp_chain_diam(depth) - - self.line_length = self.rope_length + self.chain_length - - chain_kg_per_m = 19900 * ( - self.chain_diameter**2 - ) # 19,900 kg/m^2 (diameter)/m (length) - rope_kg_per_m = 797.8 * ( - self.rope_diameter**2 - ) # 797.8 kg/ m^2 (diameter) / m (length) - self.line_mass = (self.chain_length * chain_kg_per_m) + ( - self.rope_length * rope_kg_per_m - ) # kg - # print('total hybrid line mass is ' + str(self.line_mass) + 'kg') - # convert kg to metric tonnes - self.line_mass = self.line_mass / 1e3 - - def calculate_anchor_mass_cost(self): - """ - Returns the mass and cost of anchors. - - TODO: Anchor masses are rough estimates based on initial literature - review. Should be revised when this module is overhauled in the future. - """ - - if self.anchor_type == "Drag Embedment": - - # TODO: Update this when data is available - self.anchor_mass = 20 # t - - # Input hybrid mooring system design from Cooperman et al. (2022), - # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of - # Offshore Wind Energy Leasing Areas for Humboldt and Moorow Bay - # Wind Energy Areas, California - depths = np.array([500, 750, 1000, 1250, 1500]) - anchor_costs = np.array( - [112766, 125511, 148703, 204988, 246655] - ) # [USD] - - # interpolate anchor cost to project depth - depth = self.config["site"]["depth"] - finterp_anchor_cost = interp1d(depths, anchor_costs) - self.anchor_cost = finterp_anchor_cost( - depth - ) # TODO: replace with interp. function based on depth of hybrid mooring line # noqa: E501 - - def determine_mooring_line_cost(self): - """Returns cost of one line mooring line.""" - # Input hybrid mooring system design from Cooperman et al. (2022), - # https://www.nrel.gov/docs/fy22osti/82341.pdf 'Assessment of Offshore - # Wind Energy Leasing Areas for Humboldt and Moorow Bay Wind Energy - # Areas, California - depths = np.array([500, 750, 1000, 1250, 1500]) # [m] - total_line_costs = np.array( - [826598, 1221471, 1682208, 2380035, 3229700] - ) # [USD] - finterp_total_line_cost = interp1d(depths, total_line_costs) - depth = self.config["site"]["depth"] - self.line_cost = finterp_total_line_cost(depth) - return self.line_cost - - @property - def total_cost(self): - """Returns the total cost of the mooring system.""" - - return ( - self.num_lines - * self.num_turbines - * (self.anchor_cost + self.line_cost) - ) - - @property - def detailed_output(self): - """Returns detailed phase information.""" - - return { - "num_lines": self.num_lines, - # "line_diam": self.line_diam, - "line_mass": self.line_mass, - "line_length": self.line_length, - "line_cost": self.line_cost, - "anchor_type": self.anchor_type, - "anchor_mass": self.anchor_mass, - "anchor_cost": self.anchor_cost, - "system_cost": self.total_cost, - } - - @property - def design_result(self): - """Returns the results of the design phase.""" - - return {"mooring_system": self.detailed_output} diff --git a/examples/5. Example Floating Project-SemiTaut.ipynb b/examples/5. Example Floating Project-SemiTaut.ipynb deleted file mode 100644 index d3090455..00000000 --- a/examples/5. Example Floating Project-SemiTaut.ipynb +++ /dev/null @@ -1,642 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Jake Nunemaker\n", - "\n", - "National Renewable Energy Lab\n", - "\n", - "Last updated: 12/23/2020" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_31846/3472246521.py:7\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 pandas as pd\n", - "from pprint import pprint\n", - "from ORBIT import ProjectManager, load_config\n", - "\n", - "import warnings\n", - "warnings.filterwarnings(\"default\")\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" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num turbines: 50\n", - "Turbine: 12MW_generic\n", - "\n", - "Site: {'depth': 900, 'distance': 100, 'distance_to_landfall': 100}\n" - ] - } - ], - "source": [ - "fixed_config = load_config(\"configs/example_floating_project_SemiTaut.yaml\")\n", - "\n", - "print(f\"Num turbines: {fixed_config['plant']['num_turbines']}\")\n", - "print(f\"Turbine: {fixed_config['turbine']}\")\n", - "print(f\"\\nSite: {fixed_config['site']}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Phases" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'SemiTautMooringSystemDesign', 'SemiSubmersibleDesign']\n", - "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation']\n" - ] - } - ], - "source": [ - "print(f\"Design phases: {fixed_config['design_phases']}\")\n", - "print(f\"\\nInstall phases: {list(fixed_config['install_phases'].keys())}\")\n", - "# This now says \"SemiTautMooringSystemDesign\" in the design phases" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Run" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:193\n", - "No ['ahts_vessel'] specified. num_ahts set to 0. ahts_vessel will be required in future releases.\n", - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", - "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", - "station_keeping_vessels will be deprecated and replaced with towing_vessels and ahts_vessels in the towing groups.\n" - ] - } - ], - "source": [ - "project = ProjectManager(fixed_config, weather=weather)\n", - "project.run()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Top Level Outputs" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Installation CapEx: 345 M\n", - "System CapEx: 1333 M\n", - "Turbine CapEx: 780 M\n", - "Soft CapEx: 387 M\n", - "Total CapEx: 2997 M\n", - "\n", - "Installation Time: 35527 h\n" - ] - } - ], - "source": [ - "print(f\"Installation CapEx: {project.installation_capex/1e6:.0f} M\")\n", - "print(f\"System CapEx: {project.system_capex/1e6:.0f} M\")\n", - "print(f\"Turbine CapEx: {project.turbine_capex/1e6:.0f} M\")\n", - "print(f\"Soft CapEx: {project.soft_capex/1e6:.0f} M\")\n", - "print(f\"Total CapEx: {project.total_capex/1e6:.0f} M\")\n", - "\n", - "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### CapEx Breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Array System': 56983076.60642063,\n", - " 'Export System': 259281192.288,\n", - " 'Substructure': 630709636.6,\n", - " 'Mooring System': 327467880.0,\n", - " 'Offshore Substation': 58536861.93724438,\n", - " 'Array System Installation': 63027746.845681354,\n", - " 'Export System Installation': 148076127.6910655,\n", - " 'Substructure Installation': 78801350.29354209,\n", - " 'Mooring System Installation': 48485331.05022831,\n", - " 'Offshore Substation Installation': 7070795.281582953,\n", - " 'Turbine': 780000000,\n", - " 'Soft': 387000000,\n", - " 'Project': 151250000.0}" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Array System': 94.97179434403438,\n", - " 'Export System': 432.13532047999996,\n", - " 'Substructure': 1051.1827276666668,\n", - " 'Mooring System': 545.7798,\n", - " 'Offshore Substation': 97.56143656207396,\n", - " 'Array System Installation': 105.04624474280226,\n", - " 'Export System Installation': 246.79354615177581,\n", - " 'Substructure Installation': 131.33558382257016,\n", - " 'Mooring System Installation': 80.80888508371386,\n", - " 'Offshore Substation Installation': 11.784658802638255,\n", - " 'Turbine': 1300.0,\n", - " 'Soft': 645.0,\n", - " 'Project': 252.08333333333334}" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "project.capex_breakdown_per_kw" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Installation Actions" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "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", - "
cost_multiplieragentactiondurationcostleveltimephaselocationphase_namemax_waveheightmax_windspeedtransit_speednum_vesselsnum_ahts_vessels
00.5Array Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ArrayCableInstallationNaNNaNNaNNaNNaNNaNNaN
10.5Export Cable Installation VesselMobilize72.0000003.375000e+05ACTION0.000000ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2NaNOnshore ConstructionOnshore Construction0.0000001.665604e+06ACTION0.000000ExportCableInstallationLandfallNaNNaNNaNNaNNaNNaN
31.0Mooring System Installation VesselMobilize168.0000007.000000e+05ACTION0.000000MooringSystemInstallationNaNNaNNaNNaNNaNNaNNaN
4NaNSubstation Assembly Line 1Substation Substructure Assembly0.0000000.000000e+00ACTION0.000000FloatingSubstationInstallationNaNNaNNaNNaNNaNNaNNaN
................................................
2988NaNExport Cable Installation VesselPull In Cable5.5000005.156250e+04ACTION12017.280762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2989NaNExport Cable Installation VesselTerminate Cable5.5000005.156250e+04ACTION12022.780762ExportCableInstallationNaNExportCableInstallationNaNNaNNaNNaNNaN
2990NaNExport Cable Installation VesselTransit8.0000007.500000e+04ACTION12030.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2991NaNExport Cable Installation VesselDelay26.0000002.437500e+05ACTION12056.780762ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
2992NaNExport Cable Installation VesselTransit0.6956526.521739e+03ACTION12057.476414ExportCableInstallationNaNNaNNaNNaNNaNNaNNaN
\n", - "

2993 rows \u00d7 15 columns

\n", - "
" - ], - "text/plain": [ - " cost_multiplier agent \\\n", - "0 0.5 Array Cable Installation Vessel \n", - "1 0.5 Export Cable Installation Vessel \n", - "2 NaN Onshore Construction \n", - "3 1.0 Mooring System Installation Vessel \n", - "4 NaN Substation Assembly Line 1 \n", - "... ... ... \n", - "2988 NaN Export Cable Installation Vessel \n", - "2989 NaN Export Cable Installation Vessel \n", - "2990 NaN Export Cable Installation Vessel \n", - "2991 NaN Export Cable Installation Vessel \n", - "2992 NaN Export Cable Installation Vessel \n", - "\n", - " action duration cost level \\\n", - "0 Mobilize 72.000000 3.375000e+05 ACTION \n", - "1 Mobilize 72.000000 3.375000e+05 ACTION \n", - "2 Onshore Construction 0.000000 1.665604e+06 ACTION \n", - "3 Mobilize 168.000000 7.000000e+05 ACTION \n", - "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", - "... ... ... ... ... \n", - "2988 Pull In Cable 5.500000 5.156250e+04 ACTION \n", - "2989 Terminate Cable 5.500000 5.156250e+04 ACTION \n", - "2990 Transit 8.000000 7.500000e+04 ACTION \n", - "2991 Delay 26.000000 2.437500e+05 ACTION \n", - "2992 Transit 0.695652 6.521739e+03 ACTION \n", - "\n", - " time phase location \\\n", - "0 0.000000 ArrayCableInstallation NaN \n", - "1 0.000000 ExportCableInstallation NaN \n", - "2 0.000000 ExportCableInstallation Landfall \n", - "3 0.000000 MooringSystemInstallation NaN \n", - "4 0.000000 FloatingSubstationInstallation NaN \n", - "... ... ... ... \n", - "2988 12017.280762 ExportCableInstallation NaN \n", - "2989 12022.780762 ExportCableInstallation NaN \n", - "2990 12030.780762 ExportCableInstallation NaN \n", - "2991 12056.780762 ExportCableInstallation NaN \n", - "2992 12057.476414 ExportCableInstallation NaN \n", - "\n", - " phase_name max_waveheight max_windspeed transit_speed \\\n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "2988 ExportCableInstallation NaN NaN NaN \n", - "2989 ExportCableInstallation NaN NaN NaN \n", - "2990 NaN NaN NaN NaN \n", - "2991 NaN NaN NaN NaN \n", - "2992 NaN NaN NaN NaN \n", - "\n", - " num_vessels num_ahts_vessels \n", - "0 NaN NaN \n", - "1 NaN NaN \n", - "2 NaN NaN \n", - "3 NaN NaN \n", - "4 NaN NaN \n", - "... ... ... \n", - "2988 NaN NaN \n", - "2989 NaN NaN \n", - "2990 NaN NaN \n", - "2991 NaN NaN \n", - "2992 NaN NaN \n", - "\n", - "[2993 rows x 15 columns]" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pd.DataFrame(project.actions)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'deck_space': 1,\n", - " 'length': 0,\n", - " 'mass': 1192.0,\n", - " 'type': 'Floating',\n", - " 'unit_cost': 3576000.0}\n", - "{'deck_space': 1, 'mass': 2980.0, 'unit_cost': 48411504.33724438}\n", - "{'anchor_cost': array(139426.2),\n", - " 'anchor_mass': 20,\n", - " 'anchor_type': 'Drag Embedment',\n", - " 'line_cost': array(1497913.2),\n", - " 'line_length': 1755.71,\n", - " 'line_mass': 579.8762530880001,\n", - " 'num_lines': 4,\n", - " 'system_cost': 327467880.0}\n", - "'Mooring System: $/kW'\n", - "545.7798\n", - "80.80888508371386\n" - ] - } - ], - "source": [ - "pprint(project.design_results[\"offshore_substation_substructure\"])\n", - "pprint(project.design_results[\"offshore_substation_topside\"])\n", - "pprint(project.design_results[\"mooring_system\"])\n", - "\n", - "pprint(\"Mooring System: $/kW\")\n", - "pprint(project.capex_breakdown_per_kw['Mooring System'])\n", - "pprint(project.capex_breakdown_per_kw['Mooring System Installation'])" - ] - } - ], - "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.8.18" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 911922e2..04d6320c 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -4,29 +4,34 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### Example Floating Project\n", + "### Example Floating Project\n", "\n", "This tutorial uses prepared ORBIT configs that are stored as .yaml files in the `~/configs/` folder. These example projects each exhibit different functionalities within ORBIT. Using these examples and combinations of them, most project configurations can be modeled. \n", "\n", - "Last updated: May 2024" + "Last updated: September 2024\n", + "\n", + "1. Run the example floating project and print outputs\n", + "2. Replace the anchor_type and mooring_type and and print outputs \n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_71795/2795185578.py:8\n", + "UserWarning: /var/folders/90/1lkt657x3n1cw5x65j3lfgd5406fb8/T/ipykernel_98169/3749054979.py:9\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 pandas as pd\n", + "\n", + "from copy import deepcopy\n", "from pprint import pprint\n", "from ORBIT import ProjectManager, load_config\n", "\n", @@ -41,13 +46,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Load the project configuration\n", + "### 1. Run the example floating project \n", + "\n", + "#### Load the project configuration\n", "`~/configs/example_floating_project.yaml`" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -78,16 +85,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Design phases: ['ArraySystemDesign', 'ElectricalDesign', 'MooringSystemDesign', 'OffshoreFloatingSubstationDesign', 'SemiSubmersibleDesign']\n", - "\n", - "Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', 'MooredSubInstallation', 'MooringSystemInstallation', 'FloatingSubstationInstallation', 'TurbineInstallation']\n" + "(\"Design phases: ['ArraySystemDesign', 'ElectricalDesign', \"\n", + " \"'MooringSystemDesign', 'OffshoreFloatingSubstationDesign', \"\n", + " \"'SemiSubmersibleDesign']\")\n", + "('\\n'\n", + " \"Install phases: ['ArrayCableInstallation', 'ExportCableInstallation', \"\n", + " \"'MooredSubInstallation', 'MooringSystemInstallation', \"\n", + " \"'FloatingSubstationInstallation', 'TurbineInstallation']\")\n" ] } ], @@ -105,24 +116,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 29, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/nriccobo/GitHub/ORBIT/library'\n", - "2\n" - ] - }, { "name": "stderr", "output_type": "stream", "text": [ - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:94\n", "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", - "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:93\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:94\n", "['towing_vessl_groups]['station_keeping_vessels'] will be deprecated and replaced with ['towing_vessl_groups]['ahts_vessels'].\n" ] } @@ -141,20 +144,20 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Installation CapEx: 519 M\n", - "System CapEx: 1333 M\n", + "Installation CapEx: 521 M\n", + "System CapEx: 1444 M\n", "Turbine CapEx: 780 M\n", "Soft CapEx: 387 M\n", - "Total CapEx: 3171 M\n", + "Total CapEx: 3283 M\n", "\n", - "Installation Time: 40914 h\n" + "Installation Time: 41147 h\n" ] } ], @@ -177,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -186,12 +189,12 @@ "{'Array System': 94.97179434403438,\n", " 'Export System': 432.13532047999996,\n", " 'Substructure': 1051.1827276666668,\n", - " 'Mooring System': 545.7798,\n", - " 'Offshore Substation': 97.56143656207396,\n", + " 'Mooring System': 552.2987080136722,\n", + " 'Offshore Substation': 276.52514805568075,\n", " 'Array System Installation': 105.04624474280226,\n", " 'Export System Installation': 246.79354615177581,\n", " 'Substructure Installation': 208.2509277379141,\n", - " 'Mooring System Installation': 80.80888508371386,\n", + " 'Mooring System Installation': 83.49086757990867,\n", " 'Offshore Substation Installation': 11.784658802638255,\n", " 'Turbine Installation': 212.89678462709279,\n", " 'Turbine': 1300.0,\n", @@ -199,7 +202,7 @@ " 'Project': 252.08333333333334}" ] }, - "execution_count": 6, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -217,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 32, "metadata": {}, "outputs": [ { @@ -382,7 +385,7 @@ " ...\n", " \n", " \n", - " 4458\n", + " 4521\n", " NaN\n", " Export Cable Installation Vessel\n", " Pull In Cable\n", @@ -402,7 +405,7 @@ " NaN\n", " \n", " \n", - " 4459\n", + " 4522\n", " NaN\n", " Export Cable Installation Vessel\n", " Terminate Cable\n", @@ -422,7 +425,7 @@ " NaN\n", " \n", " \n", - " 4460\n", + " 4523\n", " NaN\n", " Export Cable Installation Vessel\n", " Transit\n", @@ -442,7 +445,7 @@ " NaN\n", " \n", " \n", - " 4461\n", + " 4524\n", " NaN\n", " Export Cable Installation Vessel\n", " Delay\n", @@ -462,7 +465,7 @@ " NaN\n", " \n", " \n", - " 4462\n", + " 4525\n", " NaN\n", " Export Cable Installation Vessel\n", " Transit\n", @@ -483,7 +486,7 @@ " \n", " \n", "\n", - "

4463 rows \u00d7 17 columns

\n", + "

4526 rows \u00d7 17 columns

\n", "" ], "text/plain": [ @@ -494,11 +497,11 @@ "3 1.0 Mooring System Installation Vessel \n", "4 NaN Substation Assembly Line 1 \n", "... ... ... \n", - "4458 NaN Export Cable Installation Vessel \n", - "4459 NaN Export Cable Installation Vessel \n", - "4460 NaN Export Cable Installation Vessel \n", - "4461 NaN Export Cable Installation Vessel \n", - "4462 NaN Export Cable Installation Vessel \n", + "4521 NaN Export Cable Installation Vessel \n", + "4522 NaN Export Cable Installation Vessel \n", + "4523 NaN Export Cable Installation Vessel \n", + "4524 NaN Export Cable Installation Vessel \n", + "4525 NaN Export Cable Installation Vessel \n", "\n", " action duration cost level \\\n", "0 Mobilize 72.000000 3.375000e+05 ACTION \n", @@ -507,11 +510,11 @@ "3 Mobilize 168.000000 7.000000e+05 ACTION \n", "4 Substation Substructure Assembly 0.000000 0.000000e+00 ACTION \n", "... ... ... ... ... \n", - "4458 Pull In Cable 5.500000 5.156250e+04 ACTION \n", - "4459 Terminate Cable 5.500000 5.156250e+04 ACTION \n", - "4460 Transit 8.000000 7.500000e+04 ACTION \n", - "4461 Delay 26.000000 2.437500e+05 ACTION \n", - "4462 Transit 0.695652 6.521739e+03 ACTION \n", + "4521 Pull In Cable 5.500000 5.156250e+04 ACTION \n", + "4522 Terminate Cable 5.500000 5.156250e+04 ACTION \n", + "4523 Transit 8.000000 7.500000e+04 ACTION \n", + "4524 Delay 26.000000 2.437500e+05 ACTION \n", + "4525 Transit 0.695652 6.521739e+03 ACTION \n", "\n", " time phase location site_depth \\\n", "0 0.000000 ArrayCableInstallation NaN NaN \n", @@ -520,11 +523,11 @@ "3 0.000000 MooringSystemInstallation NaN NaN \n", "4 0.000000 FloatingSubstationInstallation NaN NaN \n", "... ... ... ... ... \n", - "4458 12017.280762 ExportCableInstallation NaN NaN \n", - "4459 12022.780762 ExportCableInstallation NaN NaN \n", - "4460 12030.780762 ExportCableInstallation NaN NaN \n", - "4461 12056.780762 ExportCableInstallation NaN NaN \n", - "4462 12057.476414 ExportCableInstallation NaN NaN \n", + "4521 12017.280762 ExportCableInstallation NaN NaN \n", + "4522 12022.780762 ExportCableInstallation NaN NaN \n", + "4523 12030.780762 ExportCableInstallation NaN NaN \n", + "4524 12056.780762 ExportCableInstallation NaN NaN \n", + "4525 12057.476414 ExportCableInstallation NaN NaN \n", "\n", " hub_height phase_name max_waveheight max_windspeed \\\n", "0 NaN NaN NaN NaN \n", @@ -533,11 +536,11 @@ "3 NaN NaN NaN NaN \n", "4 NaN NaN NaN NaN \n", "... ... ... ... ... \n", - "4458 NaN ExportCableInstallation NaN NaN \n", - "4459 NaN ExportCableInstallation NaN NaN \n", - "4460 NaN NaN NaN NaN \n", - "4461 NaN NaN NaN NaN \n", - "4462 NaN NaN NaN NaN \n", + "4521 NaN ExportCableInstallation NaN NaN \n", + "4522 NaN ExportCableInstallation NaN NaN \n", + "4523 NaN NaN NaN NaN \n", + "4524 NaN NaN NaN NaN \n", + "4525 NaN NaN NaN NaN \n", "\n", " transit_speed num_vessels num_ahts_vessels \n", "0 NaN NaN NaN \n", @@ -546,16 +549,16 @@ "3 NaN NaN NaN \n", "4 NaN NaN NaN \n", "... ... ... ... \n", - "4458 NaN NaN NaN \n", - "4459 NaN NaN NaN \n", - "4460 NaN NaN NaN \n", - "4461 NaN NaN NaN \n", - "4462 NaN NaN NaN \n", + "4521 NaN NaN NaN \n", + "4522 NaN NaN NaN \n", + "4523 NaN NaN NaN \n", + "4524 NaN NaN NaN \n", + "4525 NaN NaN NaN \n", "\n", - "[4463 rows x 17 columns]" + "[4526 rows x 17 columns]" ] }, - "execution_count": 7, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -566,19 +569,145 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mooring System Design:\n", + "{'anchor_cost': 190951.03604101657,\n", + " 'anchor_mass': 50,\n", + " 'anchor_type': 'Suction Pile',\n", + " 'line_cost': 1465945.088,\n", + " 'line_diam': 0.15,\n", + " 'line_length': 1347.376,\n", + " 'line_mass': 606.3192,\n", + " 'mooring_type': 'Catenary',\n", + " 'num_lines': 4,\n", + " 'system_cost': 331379224.80820334}\n", + "\n", + "Mooring System: $/kW\n", + "$ 552.3\n", + "$ 83.49\n" + ] + } + ], + "source": [ + "print(\"Mooring System Design:\")\n", + "pprint(project.design_results[\"mooring_system\"])\n", + "\n", + "print(\"\\nMooring System: $/kW\")\n", + "print(\"$\", round(project.capex_breakdown_per_kw['Mooring System'], 2))\n", + "\n", + "print(\"$\", round(project.capex_breakdown_per_kw['Mooring System Installation'], 2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2. Replace anchor and mooring types " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:94\n", + "support_vessel will be deprecated and replaced with towing_vessels and ahts_vessel in the towing groups.\n", + "DeprecationWarning: /Users/nriccobo/GitHub/ORBIT/ORBIT/phases/install/quayside_assembly_tow/moored.py:94\n", + "['towing_vessl_groups]['station_keeping_vessels'] will be deprecated and replaced with ['towing_vessl_groups]['ahts_vessels'].\n" + ] + } + ], + "source": [ + "semitaut_config = deepcopy(floating_config)\n", + "semitaut_config['mooring_system_design']['anchor_type'] = 'Drag Embedment'\n", + "semitaut_config['mooring_system_design']['mooring_type'] = 'Semitaut'\n", + "\n", + "project_semitaut = ProjectManager(semitaut_config, weather=weather)\n", + "project_semitaut.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "{'deck_space': 1,\n", - " 'length': 0,\n", - " 'mass': 1192.0,\n", - " 'type': 'Floating',\n", - " 'unit_cost': 3576000.0}\n", - "{'deck_space': 1, 'mass': 2980.0, 'unit_cost': 48411504.33724438}\n", + "Installation CapEx: 519 M\n", + "System CapEx: 1440 M\n", + "Turbine CapEx: 780 M\n", + "Soft CapEx: 387 M\n", + "Total CapEx: 3278 M\n", + "\n", + "Installation Time: 41147 h\n" + ] + } + ], + "source": [ + "print(f\"Installation CapEx: {project_semitaut.installation_capex/1e6:.0f} M\")\n", + "print(f\"System CapEx: {project_semitaut.system_capex/1e6:.0f} M\")\n", + "print(f\"Turbine CapEx: {project_semitaut.turbine_capex/1e6:.0f} M\")\n", + "print(f\"Soft CapEx: {project_semitaut.soft_capex/1e6:.0f} M\")\n", + "print(f\"Total CapEx: {project_semitaut.total_capex/1e6:.0f} M\")\n", + "\n", + "print(f\"\\nInstallation Time: {project.installation_time:.0f} h\")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Array System': 94.97179434403438,\n", + " 'Export System': 432.13532047999996,\n", + " 'Substructure': 1051.1827276666668,\n", + " 'Mooring System': 545.7798,\n", + " 'Offshore Substation': 276.3947698954073,\n", + " 'Array System Installation': 105.04624474280226,\n", + " 'Export System Installation': 246.79354615177581,\n", + " 'Substructure Installation': 208.2509277379141,\n", + " 'Mooring System Installation': 80.80888508371386,\n", + " 'Offshore Substation Installation': 11.784658802638255,\n", + " 'Turbine Installation': 212.89678462709279,\n", + " 'Turbine': 1300.0,\n", + " 'Soft': 645.0,\n", + " 'Project': 252.08333333333334}" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project_semitaut.capex_breakdown_per_kw" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mooring System Design:\n", "{'anchor_cost': 139426.2,\n", " 'anchor_mass': 20,\n", " 'anchor_type': 'Drag Embedment',\n", @@ -586,24 +715,24 @@ " 'line_diam': 0.15,\n", " 'line_length': 1755.71,\n", " 'line_mass': 579.8762530880001,\n", - " 'mooring_type': 'SemiTaut',\n", + " 'mooring_type': 'Semitaut',\n", " 'num_lines': 4,\n", " 'system_cost': 327467880.0}\n", - "'Mooring System: $/kW'\n", - "545.7798\n", - "80.80888508371386\n" + "\n", + "Mooring System: $/kW\n", + "$ 545.78\n", + "$ 80.81\n" ] } ], "source": [ - "pprint(project.design_results[\"offshore_substation_substructure\"])\n", - "pprint(project.design_results[\"offshore_substation_topside\"])\n", - "pprint(project.design_results[\"mooring_system\"])\n", + "print(\"Mooring System Design:\")\n", + "pprint(project_semitaut.design_results[\"mooring_system\"])\n", "\n", - "pprint(\"Mooring System: $/kW\")\n", - "pprint(project.capex_breakdown_per_kw['Mooring System'])\n", + "print(\"\\nMooring System: $/kW\")\n", + "print(\"$\", round(project_semitaut.capex_breakdown_per_kw['Mooring System'], 2))\n", "\n", - "pprint(project.capex_breakdown_per_kw['Mooring System Installation'])" + "print(\"$\", round(project_semitaut.capex_breakdown_per_kw['Mooring System Installation'], 2))" ] } ], @@ -623,7 +752,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.18" + "version": "3.10.14" } }, "nbformat": 4, diff --git a/examples/configs/example_floating_project.yaml b/examples/configs/example_floating_project.yaml index 28e7fd24..3bb7b468 100644 --- a/examples/configs/example_floating_project.yaml +++ b/examples/configs/example_floating_project.yaml @@ -31,8 +31,8 @@ substructure: substation_design: oss_substructure_type: Floating mooring_system_design: - anchor_type: Drag Embedment - mooring_type: SemiTaut + anchor_type: Suction Pile + mooring_type: Catenary array_system: free_cable_length: 0.5 array_system_design: diff --git a/examples/configs/example_floating_project_SemiTaut.yaml b/examples/configs/example_floating_project_SemiTaut.yaml deleted file mode 100644 index cba486b6..00000000 --- a/examples/configs/example_floating_project_SemiTaut.yaml +++ /dev/null @@ -1,58 +0,0 @@ -# Site + Plant Parameters -site: - depth: 900 - distance: 100 - distance_to_landfall: 100 -plant: - layout: ring - num_turbines: 50 - row_spacing: 7 - substation_distance: 1 - turbine_spacing: 7 -port: - monthly_rate: 2000000.0 - sub_assembly_lines: 1 - turbine_assembly_cranes: 1 -# Vessels -array_cable_install_vessel: example_cable_lay_vessel -export_cable_install_vessel: example_cable_lay_vessel -mooring_install_vessel: example_support_vessel -oss_install_vessel: floating_heavy_lift_vessel -support_vessel: example_support_vessel -#ahts_vessel: example_ahts_vessel -towing_vessel: example_towing_vessel -towing_vessel_groups: - station_keeping_vessels: 2 - ahts_vessels: 1 - towing_vessels: 3 -wtiv: floating_heavy_lift_vessel -# Module Specific -substructure: - takt_time: 168 -substation_design: - oss_substructure_type: Floating -array_system: - free_cable_length: 0.5 -array_system_design: - cables: - - XLPE_630mm_66kV -export_system_design: - cables: XLPE_500mm_132kV - percent_added_length: 0.0 -offshore_substation_substructure: - type: Floating -# Configured Phases -design_phases: -- ArraySystemDesign -- ElectricalDesign -- SemiTautMooringSystemDesign -#- OffshoreFloatingSubstationDesign -- SemiSubmersibleDesign -install_phases: - ArrayCableInstallation: 0 - ExportCableInstallation: 0 - MooredSubInstallation: 0 - MooringSystemInstallation: 0 - FloatingSubstationInstallation: 0 -# Project Inputs -turbine: 12MW_generic diff --git a/library/cables/XLPE_1000m_220kV_dynamic.yaml b/library/cables/XLPE_1000m_220kV_dynamic.yaml deleted file mode 100644 index d179ae21..00000000 --- a/library/cables/XLPE_1000m_220kV_dynamic.yaml +++ /dev/null @@ -1,10 +0,0 @@ -ac_resistance: 0.16 # ohm/km -capacitance: 190 # nF/km -conductor_size: 1000 # mm^2 -cost_per_km: 1020000 # $ (20% adder over XLPE_1000m_220kV) -current_capacity: 825 # A -inductance: 0.38 # mH/km -linear_density: 115 # t/km -cable_type: HVAC # HVDC vs HVAC -name: XLPE_1000m_220kV -rated_voltage: 220 From be5e9bb83fc8176595f0886fd9b152b303f9e707 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 13 Sep 2024 11:00:28 -0600 Subject: [PATCH 235/240] Clean up SemiTaut references. --- ORBIT/manager.py | 2 -- ORBIT/phases/design/__init__.py | 1 - 2 files changed, 3 deletions(-) diff --git a/ORBIT/manager.py b/ORBIT/manager.py index 84232f63..1ad6eaee 100644 --- a/ORBIT/manager.py +++ b/ORBIT/manager.py @@ -40,7 +40,6 @@ SemiSubmersibleDesign, CustomArraySystemDesign, OffshoreSubstationDesign, - SemiTautMooringSystemDesign, OffshoreFloatingSubstationDesign, ) from ORBIT.phases.install import ( @@ -78,7 +77,6 @@ class ProjectManager: OffshoreSubstationDesign, OffshoreFloatingSubstationDesign, MooringSystemDesign, - SemiTautMooringSystemDesign, SemiSubmersibleDesign, SparDesign, ElectricalDesign, diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 7871e0ca..5388cef4 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -17,4 +17,3 @@ from .mooring_system_design import MooringSystemDesign from .scour_protection_design import ScourProtectionDesign from .semi_submersible_design import SemiSubmersibleDesign -from .SemiTaut_mooring_system_design import SemiTautMooringSystemDesign From b591ad3ab476cb43438a71fb825b3bdfa935b742 Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 13 Sep 2024 12:21:43 -0600 Subject: [PATCH 236/240] Updated change log and version number. --- ORBIT/__init__.py | 13 ++- ORBIT/phases/design/oss_design_floating.py | 2 +- docs/index.rst | 2 +- docs/source/changelog.rst | 112 +++++++++++++-------- 4 files changed, 82 insertions(+), 47 deletions(-) diff --git a/ORBIT/__init__.py b/ORBIT/__init__.py index 422ce24f..6800f8f2 100644 --- a/ORBIT/__init__.py +++ b/ORBIT/__init__.py @@ -1,9 +1,14 @@ """Initializes ORBIT and provides the top-level import objects.""" -__author__ = ["Jake Nunemaker", "Matt Shields", "Rob Hammond"] +__author__ = [ + "Jake Nunemaker", + "Matt Shields", + "Rob Hammond", + "Nick Riccobono", +] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" -__maintainer__ = "Jake Nunemaker" -__email__ = ["jake.nunemaker@nrel.gov", "robert.hammond@nrel.gov"] +__maintainer__ = "Nick Riccobono" +__email__ = ["nicholas.riccobono@nrel.gov", "robert.hammond@nrel.gov"] __status__ = "Development" @@ -12,4 +17,4 @@ from ORBIT.parametric import ParametricManager from ORBIT.supply_chain import SupplyChainManager -__version__ = "1.0.8" +__version__ = "1.1" diff --git a/ORBIT/phases/design/oss_design_floating.py b/ORBIT/phases/design/oss_design_floating.py index 77d984b3..f1bc3610 100644 --- a/ORBIT/phases/design/oss_design_floating.py +++ b/ORBIT/phases/design/oss_design_floating.py @@ -289,7 +289,7 @@ def calc_substructure_mass_and_cost(self): substructure_mass * oss_substructure_cost_rate + substructure_pile_mass * oss_pile_cost_rate ) - # print('substructure cost:' + str(self.substructure_cost)) + self.substructure_mass = substructure_mass + substructure_pile_mass @property diff --git a/docs/index.rst b/docs/index.rst index 240c0052..1f732d55 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -41,7 +41,7 @@ the BOS process, split into :ref:`design ` and define which phases are needed to model their project or scenario using :ref:`ProjectManager `. -ORBIT is written in Python 3.7 and utilizes +ORBIT is written in Python 3.10 and utilizes `SimPy `_'s discrete event simulation framework to model individual processes during the installation phases, allowing for the effects of weather delays and vessel interactions to be diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 6349519e..236c5aa2 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -3,50 +3,80 @@ ORBIT Changelog =============== -Unreleased (TBD) ----------------- -- Relocated all the get design costs in each design class to `common_cost.yaml`. Spar, Semisub, monopile, electrical, offshore substation, and mooring designs all recieved this update. - -Merged SemiTaut Moorings -~~~~~~~~~~~~~~~~~~~~~~~~ - -- The ``MooringSystemDesign`` module now can use a Catenary or SemiTaut mooring system. User can specify "mooring_type". -- The ``FloatingOffshoreSubstation`` and ``ElectricalDesign`` modules now actually have a floating option to remove any substructure mass (and cost) from older versions. User can specify "oss_substructure_type" -- The ``MoredSubInstallation`` now utilizes an AHTS vessel which must be added to any config file as (ahts_vessel) -- "drag_embedment_install_time" increased from 5 to 12 hours -- quayside turbine tower section lift time from 12 to 4 hours per section. User specifies number of sections (default =1) -- quayside nacelle lift time changed from 7 to 12 hours -- XLPE_500mm_132kV cost_per_km changed from 200k to 500k -- example_cable_lay_vessel min_draft changed from 4.8m to 8.5m, overall_length 99m to 171m, max_mass 4000t to 13000t -- example_towing_vessel max_waveheight changed from 2.5m to 3.0m, max_windspeed 20m to 15m, transit_speed 6km/h to 14 km/h, day_rate 30k to 35k - -Merged Electrical Refactor -~~~~~~~~~~~~~~~~~~~~~~~~~~ - -- Updated ``ElectricalDesign`` module. -This class combines the elements of ``ExportSystemDesign`` and the ``OffshoreSubstationDesign`` modules. Its purpose is to represent the export system more accurately -by linking the type of cable (AC versus DC) and substation’s components (i.e. transformers versus converters).Figure 1 shows how to add ElectricalDesign() to a yaml -configuration file. Most export and substation component costs were updated to include a per-unit cost rather than a per-MW cost rate and they can be added to the -yaml file as arguments too. Otherwise, those per-unit costs use default and were determined with the help of a subcontractor. - - This module’s components’ cost scales with number of cables and substations rather than plant capacity. - - The offshore substation cost is calculated based on the cable type and number of cables, rather than scaling function based on plant capacity. - - The mass of an HVDC and HVAC substation are assumed to be the same. Without any new information the substructure mass and cost functions did not change. - - An experimental onshore cost function was also added to account for the duplicated interconnection components. Costs will vary depending on the cable type. - -.. image:: ./images/ElectricalDesignConfig.png - -Figure 1: Adding the new ElectricalDesign class to design phase in the yaml configuration file (left) versus using the original ExportDesignSystem and -OffshoreSubstationDesign classes (right). Note: ORBIT will not override output values from a design phase, so it will use the first instance and ignore -any subsequent designs that produce the same outputs. - -- Added an example notebook: `Example - Using HVDC or HVAC` -This new example showcases the capabilities of the ``ElectricalDesign`` class. It demonstrates how to create projects using HVAC or HVDC cables and -how to use ParametricManager to compare the two design decisions. - -- Expanded tests to demonstrate new features in ``ElectricalDesign``. +1.1 +--- + +New features +~~~~~~~~~~~~ +- Enhanced ``MooringSystemDesign``: + - Can specify catenary or semitaut mooring systems. (use `mooring_type`) + - Can specify drag embedment or suction pile anchors. (use `anchor_type`) + - Description: This class received some new options that the user can + specify to customize the mooring system. By default, this design uses + catenary mooring lines and suction pile anchors. The new semitaut mooring + lines use interpolation to calculate the geometry and cost based on + (Cooperman et al. 2022, https://www.nrel.gov/docs/fy22osti/82341.pdf). + - See ``5. Example Floating Project`` for more details. +- New ``ElectricalDesign``: + - Now has HVDC or HVAC transmission capabilities. + - New tests created ``test_electrical_export.py`` + - Description: This class combines the elements of ``ExportSystemDesign`` and the + ``OffshoreSubstationDesign`` modules. Its purpose is to represent the + entire export system more accurately by linking the type of cable + (AC versus DC) and substation’s components (i.e. transformers versus converters). + Most export and substation component costs were updated to include a per-unit cost + rather than a per-MW cost rate and they can be added to the project config file too. + Otherwise, those per-unit costs use default and were determined with the help of + industry experts. + - This module’s components’ cost scales with number of cables and + substations rather than plant capacity. + - The offshore substation cost is calculated based on the cable type + and number of cables, rather than scaling function based on plant capacity. + - The mass of an HVDC and HVAC substation are assumed to be the same. + Therefore the substructure mass and cost functions did not change. + - An experimental onshore cost function was also added to account for + the duplicated interconnection components. Costs will vary depending + on the cable type. + - See new example ``Example - Using HVDC or HVAC`` for more details. +- Enhanced ``FloatingOffshoreSubStation``: + - Fixed the output substructure type from Monopile to Floating. (use `oss_substructure_type`) + - Removes any pile or fixed-bottom substructure geometry. + - See ``Example 5. Example Floating Project`` for more details. +- Updated ``MoredSubInstallation``: + - Uses an AHTS vessel which must be added to project config file. + - See ``example/example_floating_project.yaml`` (use `ahts_vessel`) +- New ``22MW_generic.yaml`` turbine. + - Based on the IEA - 22 MW reference wind turbine. + - See ``library/turbines`` for more details. +- New cables: + - Varying HVDC ratings + - Varying HVDC and HVAC "dynamic" cables for floating projects. + - See ``library/cables`` for all the cables and more details. + +Updated default values +~~~~~~~~~~~~~~~~~~~~~~ +- ``defaults/process_times.yaml`` + - `drag_embedment_install_time`` increased from 5 to 12 hours. +- ``phases/install/quayside_assembly_tow/common.py``: + - lift and attach tower section time changed from 12 to 4 hours per section, + - lift and attach nacelle time changed from 7 to 12 hours. +- ``library/cables/XLPE_500mm_132kV.yaml``: + - `cost_per_km` changed from $200k to $500k. +- ``library/vessels/example_cable_lay_vessel.yaml``: + - `min_draft` changed from 4.8m to 8.5m, + - `overall_length` changed from 99m to 171m, + - `max_mass` changed 4000t to 13000t, +- ``library/vessels/example_towing_vessel.yaml``: + - `max_waveheight` changed from 2.5m to 3.0m, + - `max_windspeed` changed 20m to 15m, + - `transit_speed` changed 6km/h to 14 km/h, + - `day_rate` changed $30k to $35k Improvements ~~~~~~~~~~~~ +- All design classes have new tests to track total cost to flag any changes that may + impact final project cost. +- Relocated all the get design costs in each design class to `common_cost.yaml`. - Fully adopted `pyproject.toml` for managing all possible tool settings, and removed the tool-specific files from the top-level of the directory. - Replaced flake8 and pylint with ruff to adopt a cleaner, faster, and easier From 18c794eba07f1abc756916290d8a65268588e14d Mon Sep 17 00:00:00 2001 From: nriccobo Date: Fri, 13 Sep 2024 12:32:12 -0600 Subject: [PATCH 237/240] Cleaned up test mooring system --- .../design/test_mooring_system_design.py | 32 +------------------ 1 file changed, 1 insertion(+), 31 deletions(-) diff --git a/tests/phases/design/test_mooring_system_design.py b/tests/phases/design/test_mooring_system_design.py index 8265dbc1..7a2b87c0 100644 --- a/tests/phases/design/test_mooring_system_design.py +++ b/tests/phases/design/test_mooring_system_design.py @@ -10,10 +10,7 @@ import pytest -from ORBIT.phases.design import ( - MooringSystemDesign, - SemiTautMooringSystemDesign, -) +from ORBIT.phases.design import MooringSystemDesign base = { "site": {"depth": 200}, @@ -191,30 +188,3 @@ def test_custom_num_lines(): moor.run() assert moor.design_result["mooring_system"]["num_lines"] == 5 - - -def test_new_old_semitaut_mooring_system(): - """Temporary test until we delete the SemiTaut_mooring_system.""" - - config = deepcopy(base) - config["site"]["depth"] = 900.0 - config["mooring_system_design"]["mooring_type"] = "SemiTaut" - config["mooring_system_design"]["anchor_type"] = "Drag Embedment" - - old = SemiTautMooringSystemDesign(config) - old.run() - old_anchor_cost = old.anchor_cost.item() - old_line_cost = old.line_cost.item() - - new = MooringSystemDesign(config) - new.run() - - # same values - assert old.total_cost == new.total_cost - assert old_anchor_cost == new.anchor_cost - assert old.anchor_mass == new.anchor_mass - assert old_line_cost == new.line_cost - assert old.line_length == new.line_length - - # different values - assert len(old.detailed_output) != len(new.detailed_output) From b9ba0719088481f8a0a04f574ddb0363b72e4c61 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Fri, 13 Sep 2024 12:27:28 -0700 Subject: [PATCH 238/240] fix small typos --- docs/source/changelog.rst | 2 +- examples/5. Example Floating Project.ipynb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/source/changelog.rst b/docs/source/changelog.rst index 236c5aa2..c59f37be 100644 --- a/docs/source/changelog.rst +++ b/docs/source/changelog.rst @@ -33,7 +33,7 @@ New features - The offshore substation cost is calculated based on the cable type and number of cables, rather than scaling function based on plant capacity. - The mass of an HVDC and HVAC substation are assumed to be the same. - Therefore the substructure mass and cost functions did not change. + Therefore, the substructure mass and cost functions did not change. - An experimental onshore cost function was also added to account for the duplicated interconnection components. Costs will vary depending on the cable type. diff --git a/examples/5. Example Floating Project.ipynb b/examples/5. Example Floating Project.ipynb index 04d6320c..68a22700 100644 --- a/examples/5. Example Floating Project.ipynb +++ b/examples/5. Example Floating Project.ipynb @@ -11,7 +11,7 @@ "Last updated: September 2024\n", "\n", "1. Run the example floating project and print outputs\n", - "2. Replace the anchor_type and mooring_type and and print outputs \n" + "2. Replace the anchor_type and mooring_type and print outputs \n" ] }, { From f4e41d9af3b1535aab0ac3876cf6a7c5bf90489c Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Fri, 13 Sep 2024 12:28:30 -0700 Subject: [PATCH 239/240] updating email address --- ORBIT/__init__.py | 2 +- ORBIT/core/library.py | 2 +- ORBIT/phases/__init__.py | 2 +- ORBIT/phases/design/__init__.py | 2 +- ORBIT/phases/design/_cables.py | 2 +- ORBIT/phases/design/array_system_design.py | 2 +- ORBIT/phases/design/export_system_design.py | 2 +- ORBIT/phases/design/scour_protection_design.py | 2 +- ORBIT/phases/install/__init__.py | 2 +- ORBIT/phases/install/cable_install/__init__.py | 2 +- ORBIT/phases/install/install_phase.py | 2 +- ORBIT/phases/install/scour_protection_install/__init__.py | 2 +- library/__init__.py | 2 +- library/ports/__init__.py | 2 +- tests/core/test_library.py | 2 +- tests/phases/design/test_array_system_design.py | 2 +- tests/phases/design/test_cable.py | 2 +- tests/phases/design/test_export_system_design.py | 2 +- tests/phases/design/test_scour_protection_design.py | 2 +- 19 files changed, 19 insertions(+), 19 deletions(-) diff --git a/ORBIT/__init__.py b/ORBIT/__init__.py index 6800f8f2..32d2fff6 100644 --- a/ORBIT/__init__.py +++ b/ORBIT/__init__.py @@ -8,7 +8,7 @@ ] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Nick Riccobono" -__email__ = ["nicholas.riccobono@nrel.gov", "robert.hammond@nrel.gov"] +__email__ = ["nicholas.riccobono@nrel.gov", "rob.hammond@nrel.gov"] __status__ = "Development" diff --git a/ORBIT/core/library.py b/ORBIT/core/library.py index bf678dcf..3fcb588e 100644 --- a/ORBIT/core/library.py +++ b/ORBIT/core/library.py @@ -27,7 +27,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import os diff --git a/ORBIT/phases/__init__.py b/ORBIT/phases/__init__.py index e03cbe6b..324fe7ad 100644 --- a/ORBIT/phases/__init__.py +++ b/ORBIT/phases/__init__.py @@ -6,7 +6,7 @@ __author__ = ["Jake Nunemaker", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = ["Jake Nunemaker", "Rob Hammond"] -__email__ = ["jake.nunemaker@nrel.gov" "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov" "rob.hammond@nrel.gov"] from .base import BasePhase diff --git a/ORBIT/phases/design/__init__.py b/ORBIT/phases/design/__init__.py index 5388cef4..70eabc07 100644 --- a/ORBIT/phases/design/__init__.py +++ b/ORBIT/phases/design/__init__.py @@ -3,7 +3,7 @@ __author__ = ["Jake Nunemaker", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = ["Jake Nunemaker", "Rob Hammond"] -__email__ = ["jake.nunemaker@nrel.gov" "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov" "rob.hammond@nrel.gov"] from .design_phase import DesignPhase # isort:skip diff --git a/ORBIT/phases/design/_cables.py b/ORBIT/phases/design/_cables.py index 56410eea..73f34fe0 100644 --- a/ORBIT/phases/design/_cables.py +++ b/ORBIT/phases/design/_cables.py @@ -3,7 +3,7 @@ __author__ = ["Matt Shields", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import math diff --git a/ORBIT/phases/design/array_system_design.py b/ORBIT/phases/design/array_system_design.py index 43210d59..c6123b55 100644 --- a/ORBIT/phases/design/array_system_design.py +++ b/ORBIT/phases/design/array_system_design.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import warnings diff --git a/ORBIT/phases/design/export_system_design.py b/ORBIT/phases/design/export_system_design.py index 4ad674b1..f6ab00d2 100644 --- a/ORBIT/phases/design/export_system_design.py +++ b/ORBIT/phases/design/export_system_design.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" from warnings import warn diff --git a/ORBIT/phases/design/scour_protection_design.py b/ORBIT/phases/design/scour_protection_design.py index cb07fa45..8dbac190 100644 --- a/ORBIT/phases/design/scour_protection_design.py +++ b/ORBIT/phases/design/scour_protection_design.py @@ -3,7 +3,7 @@ __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" from math import ceil diff --git a/ORBIT/phases/install/__init__.py b/ORBIT/phases/install/__init__.py index 46ca4cbf..5a6d0035 100644 --- a/ORBIT/phases/install/__init__.py +++ b/ORBIT/phases/install/__init__.py @@ -3,7 +3,7 @@ __author__ = ["Jake Nunemaker", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = ["Jake Nunemaker", "Rob Hammond"] -__email__ = ["jake.nunemaker@nrel.gov" "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov" "rob.hammond@nrel.gov"] from .install_phase import InstallPhase # isort:skip from .oss_install import ( diff --git a/ORBIT/phases/install/cable_install/__init__.py b/ORBIT/phases/install/cable_install/__init__.py index dc52a6a0..7997fda6 100644 --- a/ORBIT/phases/install/cable_install/__init__.py +++ b/ORBIT/phases/install/cable_install/__init__.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" from .array import ArrayCableInstallation from .common import SimpleCable diff --git a/ORBIT/phases/install/install_phase.py b/ORBIT/phases/install/install_phase.py index 0689a2d9..930686e1 100644 --- a/ORBIT/phases/install/install_phase.py +++ b/ORBIT/phases/install/install_phase.py @@ -3,7 +3,7 @@ __author__ = ["Jake Nunemaker", "Rob Hammond"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = ["Jake Nunemaker", "Rob Hammond"] -__email__ = ["jake.nunemaker@nrel.gov", "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov", "rob.hammond@nrel.gov"] from abc import abstractmethod diff --git a/ORBIT/phases/install/scour_protection_install/__init__.py b/ORBIT/phases/install/scour_protection_install/__init__.py index 9dde34c0..b2f99b17 100644 --- a/ORBIT/phases/install/scour_protection_install/__init__.py +++ b/ORBIT/phases/install/scour_protection_install/__init__.py @@ -1,6 +1,6 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" from .standard import ScourProtectionInstallation diff --git a/library/__init__.py b/library/__init__.py index 62fe1c84..5d3ded35 100644 --- a/library/__init__.py +++ b/library/__init__.py @@ -1,5 +1,5 @@ __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" -__email__ = ["jake.nunemaker@nrel.gov", "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov", "rob.hammond@nrel.gov"] __status__ = "Development" diff --git a/library/ports/__init__.py b/library/ports/__init__.py index 62fe1c84..5d3ded35 100644 --- a/library/ports/__init__.py +++ b/library/ports/__init__.py @@ -1,5 +1,5 @@ __author__ = ["Rob Hammond", "Jake Nunemaker"] __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Jake Nunemaker" -__email__ = ["jake.nunemaker@nrel.gov", "robert.hammond@nrel.gov"] +__email__ = ["jake.nunemaker@nrel.gov", "rob.hammond@nrel.gov"] __status__ = "Development" diff --git a/tests/core/test_library.py b/tests/core/test_library.py index 24c253eb..002adb84 100644 --- a/tests/core/test_library.py +++ b/tests/core/test_library.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import os from copy import deepcopy diff --git a/tests/phases/design/test_array_system_design.py b/tests/phases/design/test_array_system_design.py index e7e1e4b4..a7f7bb09 100644 --- a/tests/phases/design/test_array_system_design.py +++ b/tests/phases/design/test_array_system_design.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" from copy import deepcopy diff --git a/tests/phases/design/test_cable.py b/tests/phases/design/test_cable.py index eabab579..3973aadf 100644 --- a/tests/phases/design/test_cable.py +++ b/tests/phases/design/test_cable.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import copy diff --git a/tests/phases/design/test_export_system_design.py b/tests/phases/design/test_export_system_design.py index fa5c76a5..9ef801e1 100644 --- a/tests/phases/design/test_export_system_design.py +++ b/tests/phases/design/test_export_system_design.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import warnings from copy import deepcopy diff --git a/tests/phases/design/test_scour_protection_design.py b/tests/phases/design/test_scour_protection_design.py index 98c50731..88753a3c 100644 --- a/tests/phases/design/test_scour_protection_design.py +++ b/tests/phases/design/test_scour_protection_design.py @@ -3,7 +3,7 @@ __author__ = "Rob Hammond" __copyright__ = "Copyright 2020, National Renewable Energy Laboratory" __maintainer__ = "Rob Hammond" -__email__ = "robert.hammond@nrel.gov" +__email__ = "rob.hammond@nrel.gov" import pytest From 6338de60b9817847cceec21929e2b86926bb6fa3 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Fri, 13 Sep 2024 12:59:51 -0700 Subject: [PATCH 240/240] configure pypi to tags->test-pypi and release->pypi --- .github/workflows/publish-to-pypi.yml | 50 +++++++++++++--------- .github/workflows/publish-to-test-pypi.yml | 37 ++++++++++++++++ 2 files changed, 67 insertions(+), 20 deletions(-) create mode 100644 .github/workflows/publish-to-test-pypi.yml diff --git a/.github/workflows/publish-to-pypi.yml b/.github/workflows/publish-to-pypi.yml index c61c9415..ff0d2f36 100644 --- a/.github/workflows/publish-to-pypi.yml +++ b/.github/workflows/publish-to-pypi.yml @@ -1,25 +1,35 @@ -name: Upload to PyPi +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries -on: push +name: Deploy to PyPI + +on: + release: + types: [published] jobs: - deploy: + release-pypi: + environment: release + # Upload to PyPI on every published release + if: github.event.action == 'published' runs-on: ubuntu-latest + steps: - - uses: actions/checkout@v4 - - name: Set up Python 3.10 - uses: actions/setup-python@v4 - with: - python-version: '3.10' - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine - - name: Build and publish - if: startsWith(github.ref, 'refs/tags/v') - env: - TWINE_USERNAME: __token__ - TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }} - run: | - python setup.py sdist bdist_wheel - twine upload dist/* + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.10' + + - name: Build package + run: | + python -m pip install --upgrade pip + pip install setuptools build wheel twine + python -m build + twine check --strict dist/* + + - name: Publish package to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + verbose: True diff --git a/.github/workflows/publish-to-test-pypi.yml b/.github/workflows/publish-to-test-pypi.yml new file mode 100644 index 00000000..d7407ab8 --- /dev/null +++ b/.github/workflows/publish-to-test-pypi.yml @@ -0,0 +1,37 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries + +name: Deploy to Test PyPI + +on: + push: + tags: + - 'v*' + +jobs: + release-test-pypi: + # Upload to Test PyPI on every pushed tag. + environment: release + if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: '3.10' + + - name: Build package + run: | + python -m pip install --upgrade pip + pip install setuptools build wheel twine + python -m build + twine check --strict dist/* + + - name: Publish package to Test PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + verbose: True + repository-url: https://test.pypi.org/legacy/