Release candidate for beta.6

ard/__init__.py

@@ -1,13 +1,4 @@
 from pathlib import Path
 
-from . import collection
-from . import layout
-from . import offshore
-from . import wind_query
-from . import utils
-from . import viz
-
-from .viz import house_style
-
 BASE_DIR = Path(__file__).parent.absolute()
 ASSET_DIR = BASE_DIR / "api" / "default_systems"

ard/api/interface.py

@@ -5,11 +5,6 @@
 from openmdao.utils.file_utils import clean_outputs
 from ard.utils.io import load_yaml, replace_key_value
 from ard.utils.logging import prepend_tabs_to_stdio
-from ard.cost.wisdem_wrap import (
-    LandBOSSE_setup_latents,
-    ORBIT_setup_latents,
-    FinanceSE_setup_latents,
-)
 import windIO
 from ard import ASSET_DIR
 from typing import Union
@@ -163,12 +158,11 @@ def set_up_system_recursive(
         prob = None
 
     # Add subsystems directly from the input dictionary
+    indent = "\t" * _depth
     if hasattr(parent_group, "name") and (parent_group.name != ""):
-        print(
-            f"{''.join(' ' * 4 * _depth)}Adding {system_name} to {parent_group.name}."
-        )
+        print(f"{indent}Adding {system_name} to {parent_group.name}.")
     else:
-        print(f"{''.join(' ' * 4 * _depth)}Adding {system_name}.")
+        print(f"{indent}Adding {system_name}.")
     if "systems" in input_dict:  # Recursively add nested subsystems]
         if _depth > 0:
             group = parent_group.add_subsystem(

ard/collection/optiwindnet_wrap.py

@@ -4,9 +4,12 @@
 import numpy as np
 
 from optiwindnet.mesh import make_planar_embedding
-from optiwindnet.interarraylib import L_from_site
+from optiwindnet.converting import L_from_site
 from optiwindnet.heuristics import constructor
-from optiwindnet.MILP import OWNWarmupFailed, solver_factory, ModelOptions
+from optiwindnet.types import OWNWarmupFailed
+from optiwindnet.constraints import NetworkConstraints
+from optiwindnet.MILP import solver_factory
+from optiwindnet.MILP._core import _constraints_from_options
 
 from . import templates
 
@@ -153,15 +156,41 @@ def initialize(self):
     def setup(self):
         """Setup of OM component."""
         super().setup()
+        # network constraints are given either as optiwindnet `NetworkConstraints`
+        # arguments (`network_constraints`) or as the legacy `model_options`
+        collection_options = self.modeling_options["collection"]
+        if "network_constraints" in collection_options:
+            if "model_options" in collection_options:
+                raise ValueError(
+                    "give either network_constraints or model_options, not both"
+                )
+            constraints = NetworkConstraints(
+                **collection_options["network_constraints"]
+            )
+        else:
+            # stopgap until optiwindnet v0.4, which drops the legacy options
+            constraints = _constraints_from_options(
+                **collection_options.get("model_options", {})
+            )
+        self.constraints = constraints
+
+        # the heuristic warm-start only applies if the feeder count is free
         self.constructor_args = {}
-        model_options = self.modeling_options["collection"]["model_options"]
-        if model_options.get("feeder_limit") == "unlimited":
+        if all(
+            value is None
+            for value in (
+                constraints.feeders,
+                constraints.max_feeders,
+                constraints.substation_feeders,
+                constraints.max_substation_feeders,
+            )
+        ):
             self.constructor_args["straight_feeder_route"] = (
-                model_options.get("feeder_route") == "straight"
+                constraints.feeder_route == "straight"
             )
-            if model_options.get("topology") == "branched":
+            if constraints.topology == "branched":
                 self.constructor_args["method"] = "rootlust"
-            elif model_options.get("topology") == "radial":
+            elif constraints.topology == "radial":
                 self.constructor_args["method"] = "radial_EW"
             else:
                 self.constructor_args.clear()
@@ -200,7 +229,6 @@ def compute(
 
         solver = solver_factory(solver_name)
 
-        model_options = self.modeling_options["collection"]["model_options"]
         # start from previous solution if available, else from heuristic if it fits
         if self.S_previous is not None:
             S_warm = self.S_previous
@@ -217,17 +245,17 @@ def compute(
             solver.set_problem(
                 P,
                 A,
-                max_turbines_per_string,
-                ModelOptions(**model_options),
+                capacity=max_turbines_per_string,
+                constraints=self.constraints,
                 warmstart=S_warm,
             )
         except OWNWarmupFailed:
             # the previous solution is no longer feasible
             solver.set_problem(
                 P,
                 A,
-                max_turbines_per_string,
-                ModelOptions(**model_options),
+                capacity=max_turbines_per_string,
+                constraints=self.constraints,
             )
 
         # do the branch-and-bound MILP search