Offshore development

.github/workflows/deploy-pages.yaml

@@ -18,11 +18,11 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
-        python-version: "3.11"
+        python-version: "3.12"
 
     - name: Install dependencies
       run: |
-        pip install -e ".[docs]"
+        pip install -e ".[dev,docs,floating]"
 
     # Build the book
     - name: Build the book

.github/workflows/python-tests-consolidated.yaml

@@ -44,7 +44,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install Ard
       run: |
-        pip install .[dev]
+        pip install .[dev,doc,floating]
 
   test-unit:
     name: Run unit tests
@@ -81,7 +81,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install Ard
       run: |
-        pip install .[dev]
+        pip install .[dev,doc,floating]
     - name: Run unit tests with coverage
       run: |
         pytest --cov=ard --cov-fail-under=80 test/unit
@@ -121,7 +121,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install Ard
       run: |
-        pip install .[dev]
+        pip install .[dev,doc,floating]
     - name: Run system tests with coverage
       run: |
         pytest --cov=ard --cov-fail-under=50 test/system
@@ -184,7 +184,7 @@ jobs:
         python -m pip install --upgrade pip
     - name: Install Ard
       run: |
-        pip install .[dev]
+        pip install .[dev,doc,floating]
     - name: Run examples
       shell: python
       run: |

ard/api/default_systems/ard_system_offshore_floating_detailed_mooring.yaml

@@ -0,0 +1,110 @@
+type: group
+systems:
+  layout2aep:
+    type: group
+    promotes: ["*"]
+    approx_totals:
+      method: "fd"
+      step: 1.0E-3
+      form: "central"
+      step_calc: "rel_avg"
+    systems:
+      layout:
+        type: component
+        module: ard.layout.gridfarm
+        object: GridFarmLayout
+        promotes: ["*"]
+        kwargs:
+          modeling_options:
+      aepFLORIS:
+        type: component
+        module: ard.farm_aero.floris
+        object: FLORISAEP
+        promotes: ["x_turbines", "y_turbines", "AEP_farm"]
+        kwargs:
+          modeling_options:
+          case_title: "offshore-floating"
+          data_path:
+  landuse:
+    type: component
+    module: ard.layout.gridfarm
+    object: GridFarmLanduse
+    promotes: ["*"]
+    kwargs:
+      modeling_options:
+  collection:
+    type: component
+    module: ard.collection
+    object: OptiwindnetCollection
+    promotes: ["x_turbines", "y_turbines"]
+    kwargs:
+      modeling_options:
+  mooring_design:
+    type: component
+    module: ard.offshore.mooring_design_detailed
+    object: DetailedMooringDesign
+    promotes: ["x_turbines", "y_turbines", "x_anchors", "y_anchors", "phi_platform"]
+    kwargs:
+      modeling_options:
+      wind_query:
+      data_path:
+  mooring_constraint:
+    type: component
+    module: ard.offshore.mooring_constraint
+    object: MooringConstraint
+    promotes: ["x_turbines", "y_turbines", "x_anchors", "y_anchors"]
+    kwargs:
+      modeling_options:
+  spacing_constraint:
+    type: component
+    module: ard.layout.spacing
+    object: TurbineSpacing
+    promotes: ["x_turbines", "y_turbines"]
+    kwargs:
+      modeling_options:
+  tcc:
+    type: component
+    module: ard.cost.wisdem_wrap
+    object: TurbineCapitalCosts
+    promotes: [
+      "turbine_number",
+      "machine_rating",
+      "tcc_per_kW",
+      "offset_tcc_per_kW",
+    ]
+  orbit:
+    type: component
+    module: ard.cost.wisdem_wrap
+    object: ORBITGroup
+    promotes: [
+      ["plant_turbine_spacing", "spacing_effective_primary"],
+      ["plant_row_spacing", "spacing_effective_secondary"],
+      # "installation_capex",
+    ]
+    kwargs:
+      modeling_options:
+  opex:
+    type: component
+    module: ard.cost.wisdem_wrap
+    object: OperatingExpenses
+    promotes: [
+      "turbine_number",
+      "machine_rating",
+      "opex_per_kW"
+    ]
+  financese:
+    type: component
+    module: ard.cost.wisdem_wrap
+    object: FinanceSEGroup
+    promotes: [
+      "turbine_number",
+      "machine_rating",
+      "tcc_per_kW",
+      "offset_tcc_per_kW",
+      "opex_per_kW",
+    ]
+    kwargs:
+      modeling_options:
+connections:
+  - ["AEP_farm", "financese.plant_aep_in"]
+  - ["orbit.total_capex_kW", "financese.bos_per_kW"]  # For offshore systems

ard/api/interface.py

@@ -68,6 +68,7 @@ def set_up_ard_model(input_dict: Union[str, dict], root_data_path: str = None):
         "offshore_monopile",
         "offshore_monopile_no_cable_design",
         "offshore_floating",
+        "offshore_floating_detailed_mooring",
         "offshore_floating_no_cable_design",
     ]
 
@@ -106,6 +107,8 @@ def set_up_ard_model(input_dict: Union[str, dict], root_data_path: str = None):
         analysis_options=input_dict["analysis_options"],
     )
 
+    prob.setup()
+
     return prob
 
 
@@ -278,6 +281,4 @@ def set_up_system_recursive(
             units="m",
         )
 
-        prob.setup()
-
     return prob

ard/collection/optiwindnet_wrap.py

@@ -69,6 +69,9 @@ class OptiwindnetCollection(templates.CollectionTemplate):
     -------
     total_length_cables : float
         the total length of cables used in the collection system network
+    terse_links : np.ndarray
+        a 1D numpy int array encoding the electrical connections of the collection
+        system (tree topology), with length `N_turbines`
 
     Discrete Outputs
     -------
@@ -81,9 +84,6 @@ class OptiwindnetCollection(templates.CollectionTemplate):
         length `N_turbines`
     max_load_cables : int
         the maximum cable capacity required by the collection system
-    terse_links : np.ndarray
-        a 1D numpy int array encoding the electrical connections of the collection
-        system (tree topology), with length `N_turbines`
     """
 
     def initialize(self):
@@ -103,6 +103,13 @@ def setup_partials(self):
             ["x_turbines", "y_turbines", "x_substations", "y_substations"],
             method="exact",
         )
+        self.declare_partials(
+            ["terse_links"],
+            ["x_turbines", "y_turbines", "x_substations", "y_substations"],
+            method="exact",
+            val=0.0,
+            dependent=False,
+        )
 
     def compute(
         self,
@@ -201,14 +208,14 @@ def compute(
         # pack and ship
         self.graph = G
         discrete_outputs["graph"] = G  # TODO: remove for terse links, below!
-        discrete_outputs["terse_links"] = terse_links
         discrete_outputs["length_cables"] = length_cables
         discrete_outputs["load_cables"] = load_cables
         discrete_outputs["max_load_cables"] = S.graph["max_load"]
         # TODO: remove this assert after enough testing
         assert (
             abs(length_cables.sum() - G.size(weight="length")) < 1e-7
         ), f"difference: {length_cables.sum() - G.size(weight='length')}"
+        outputs["terse_links"] = terse_links
         outputs["total_length_cables"] = length_cables.sum()
 
     def compute_partials(self, inputs, J, discrete_inputs=None):

ard/collection/templates.py

@@ -108,8 +108,8 @@ def setup(self):
 
         # set up outputs for the collection system
         self.add_output("total_length_cables", 0.0, units="m")
+        self.add_output("terse_links", np.full((self.N_turbines,), -1))
         self.add_discrete_output("length_cables", np.zeros((self.N_turbines,)))
-        self.add_discrete_output("terse_links", np.full((self.N_turbines,), -1))
         self.add_discrete_output("load_cables", np.zeros((self.N_turbines,)))
         self.add_discrete_output("max_load_cables", 0.0)
         self.add_discrete_output("graph", None)

ard/cost/orbit_wrap.py

@@ -12,11 +12,25 @@
 from ORBIT.core.library import default_library
 from ORBIT.core.library import initialize_library
 
+import networkx as nx
+from optiwindnet.interarraylib import calcload
 from ard.cost.wisdem_wrap import ORBIT_setup_latents
 
+from ard.collection.optiwindnet_wrap import _own_L_from_inputs
+
+
+def S_from_terse_links(terse_links, **kwargs):
+    T = terse_links.shape[0]
+    S = nx.Graph(T=T, R=abs(terse_links.min()), **kwargs)
+    S.add_edges_from(tuple(zip(range(T), terse_links)))
+    calcload(S)
+    if "capacity" not in kwargs:
+        S.graph["capacity"] = S.graph["max_load"]
+    return S
+
 
 def generate_orbit_location_from_graph(
-    graph,  # TODO: replace with a terse_links representation
+    terse_links,  # TODO: replace with a terse_links representation
     X_turbines,
     Y_turbines,
     X_substations,
@@ -57,6 +71,22 @@ def generate_orbit_location_from_graph(
         if the recursive setup seems to be stuck in a loop
     """
 
+    # create graph from terse links
+    tlm = np.astype(terse_links, np.int_)
+    L = _own_L_from_inputs(
+        {
+            "x_turbines": X_turbines,
+            "y_turbines": Y_turbines,
+            "x_substations": X_substations,
+            "y_substations": Y_substations,
+        },
+        {
+            "x_border": None,
+            "y_border": None,
+        },
+    )
+    graph = S_from_terse_links(tlm)
+
     # get all edges, sorted by the first node then the second node
     edges_to_process = [edge for edge in graph.edges]
     edges_to_process.sort(key=lambda x: (x[0], x[1]))
@@ -209,8 +239,11 @@ def initialize(self):
         super().initialize()
 
         self.options.declare("case_title", default="working")
-        self.options.declare("modeling_options")
+        self.options.declare(
+            "modeling_options", types=dict, desc="Ard modeling options"
+        )
         self.options.declare("approximate_branches", default=False)
+        self.options.declare("override_mooring_lines", default=False)
 
     def setup(self):
         """Define all input variables from all models."""
@@ -255,6 +288,14 @@ def setup(self):
                 modeling_options=self.modeling_options,
                 case_title=self.options["case_title"],
                 approximate_branches=self.options["approximate_branches"],
+                override_mooring_lines=self.modeling_options["costs"].get(
+                    "override_mooring_lines",
+                    False,
+                ),
+                override_mooring_anchors=self.modeling_options["costs"].get(
+                    "override_mooring_anchors",
+                    False,
+                ),
                 floating=self.modeling_options["floating"],
                 jacket=self.modeling_options.get("jacket"),
                 jacket_legs=self.modeling_options.get("jacket_legs"),
@@ -274,6 +315,8 @@ def initialize(self):
         self.options.declare("case_title", default="working")
         self.options.declare("modeling_options")
         self.options.declare("approximate_branches", default=False)
+        self.options.declare("override_mooring_lines", default=False)
+        self.options.declare("override_mooring_anchors", default=False)
 
     def setup(self):
         """Define all the inputs."""
@@ -287,7 +330,7 @@ def setup(self):
         self.N_substations = self.modeling_options["layout"]["N_substations"]
 
         # bring in collection system design
-        self.add_discrete_input("graph", None)
+        self.add_input("terse_links", np.full((self.N_turbines,), -1))
 
         # add the detailed turbine and substation locations
         self.add_input("x_turbines", np.zeros((self.N_turbines,)), units="km")
@@ -332,6 +375,14 @@ def compile_orbit_config_file(
             "row_spacing": inputs["plant_row_spacing"],
         }
 
+        # override the mooring line values
+        if self.options["override_mooring_lines"]:
+            # if mooring lines will be calculated in detail
+            # zero their ORBIT cost contributions
+            config["mooring_system"]["line_cost"] = 0.0
+            # the standard diameter and mass can still be used to approximate
+            # construction times and costs, etc.
+
         # switch to the custom array system design
         if not ("ArraySystemDesign" in config["design_phases"]):
             raise KeyError(
@@ -359,7 +410,7 @@ def compile_orbit_config_file(
 
         # generate the csv data needed to locate the farm elements
         generate_orbit_location_from_graph(
-            discrete_inputs["graph"],
+            inputs["terse_links"],
             inputs["x_turbines"],
             inputs["y_turbines"],
             inputs["x_substations"],
@@ -396,6 +447,7 @@ def initialize(self):
             "modeling_options", types=dict, desc="Ard modeling options"
         )
         self.options.declare("approximate_branches", default=False)
+        self.options.declare("override_mooring_lines", default=False)
 
     def setup(self):
 
@@ -430,7 +482,7 @@ def setup(self):
                 "total_capex_kW",
                 "bos_capex",
                 "installation_capex",
-                "graph",
+                "terse_links",
                 "x_turbines",
                 "y_turbines",
                 "x_substations",
@@ -443,3 +495,17 @@ def setup(self):
         # connect
         for key in variable_mapping.keys():
             self.connect(key, f"orbit.{key}")
+
+    def setup_partials(self):
+
+        self.declare_partials(
+            "*",
+            "*",
+            method="fd",
+            step=1.0e-5,
+            form="central",
+            step_calc="rel_avg",
+        )
+        self.declare_partials(
+            "terse_links", "*", method="exact", val=0.0, dependent=False
+        )