foxes 1.3__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/input/yaml/windio/read_farm.py

@@ -77,7 +77,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
                 return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: PCtFomTwo", level=3)
+            _print("              Turbine type class: PCtFomTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="PCtFromTwo",
                 data_source_P=data_P,
@@ -111,7 +111,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
 
             _print(f"            Creating model '{tname}'", level=3)
-            _print(f"              Turbine type class: CpCtFromTwo", level=3)
+            _print("              Turbine type class: CpCtFromTwo", level=3)
             mbook.turbine_types[tname] = TurbineType.new(
                 ttype_type="CpCtFromTwo",
                 data_source_cp=data_cp,
@@ -126,7 +126,7 @@ def read_turbine_types(wio_farm, mbook, ws_exp_P, ws_exp_ct, verbosity):
             _print("               ", mbook.turbine_types[tname], level=3)
 
         else:
-            raise KeyError(f"Expecting either 'power_curve' or 'Cp_curve'")
+            raise KeyError("Expecting either 'power_curve' or 'Cp_curve'")
 
     return ttypes
 
@@ -157,7 +157,7 @@ def read_layout(lname, ldict, farm, ttypes, verbosity=1):
     cdict = Dict(ldict["coordinates"], name="coordinates")
     tmap = ldict.get_item("turbine_types", None)
     if verbosity > 2:
-        print(f"          Turbine type map:", tmap)
+        print("          Turbine type map:", tmap)
     for i, xy in enumerate(zip(cdict["x"], cdict["y"])):
         tt = ttypes[tmap[i] if tmap is not None else 0]
         farm.add_turbine(
@@ -211,7 +211,7 @@ def read_farm(wio_dict, mbook, verbosity):
     if isinstance(wfarm, dict):
         layouts = Dict(wfarm, name=wio_farm.name + ".layouts")
     else:
-        layouts = {str(i): l for i, l in enumerate(wfarm)}
+        layouts = {str(i): lf for i, lf in enumerate(wfarm)}
         layouts = Dict(layouts, name=wio_farm.name + ".layouts")
     if verbosity > 2:
         print("    Reading layouts")

foxes/input/yaml/windio/read_fields.py

@@ -22,6 +22,8 @@ wio2foxes = {
     "LMO": FV.MOL,
     "z0": FV.Z0,
     "reference_height": FV.H,
+    "weibull_a": FV.WEIBULL_A,
+    "weibull_k": FV.WEIBULL_k,
 }
 
 """ Mapping from foxes to windio variables
@@ -134,8 +136,6 @@ def read_wind_resource_field(
 
     """
     if name in [
-        "weibull_a",
-        "weibull_k",
         "potential_temperature",
         "friction_velocity",
         "k",
@@ -178,6 +178,8 @@ def read_wind_resource_field(
         "LMO",
         "z0",
         "reference_height",
+        "weibull_a",
+        "weibull_k",
     ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True
 

foxes/input/yaml/windio/read_site.py

@@ -159,6 +159,55 @@ def _get_MultiHeightNCTimeseries(
     return False
 
 
+def _get_WeibullSectors(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
+    """Try to generate Weibull sector parameters
+    :group: input.yaml.windio
+    """
+    if (
+        FV.WEIBULL_A in fields
+        and FV.WEIBULL_k in fields
+        and "sector_probability" in fields
+        and len(dims[FV.WEIBULL_A]) == 1
+        and len(dims[FV.WEIBULL_k]) == 1
+        and len(dims["sector_probability"]) == 1
+    ):
+        if verbosity > 2:
+            print("        selecting class 'WeibullSectors'")
+
+        data = {}
+        fix = {}
+        c = dims[FV.WEIBULL_A][0]
+        for v, d in fields.items():
+            if dims[v] == (c,):
+                data[v] = d
+            elif len(dims[v]) == 0:
+                fix[v] = d
+            elif verbosity > 2:
+                print(f"        ignoring field '{v}' with dims {dims[v]}")
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        if FV.WD in coords:
+            data[FV.WD] = coords[FV.WD]
+
+        sdata = pd.DataFrame(index=range(len(fields[FV.WEIBULL_A])), data=data)
+        sdata.index.name = "sector"
+        states_dict.update(
+            dict(
+                states_type="WeibullSectors",
+                data_source=sdata,
+                ws_bins=coords.get(FV.WS, np.arange(30)),
+                output_vars=ovars,
+                var2ncvar={FV.WEIGHT: "sector_probability"},
+                fixed_vars=fix,
+                profiles=profiles,
+            )
+        )
+        return True
+    return False
+
+
 def get_states(coords, fields, dims, verbosity=1):
     """
     Reads states parameters from windio input
@@ -200,6 +249,9 @@ def get_states(coords, fields, dims, verbosity=1):
         or _get_MultiHeightNCTimeseries(
             coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
         )
+        or _get_WeibullSectors(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
     ):
         return States.new(**states_dict)
     else:

foxes/input/yaml/windio/windio.py

@@ -43,7 +43,7 @@ def read_windio(wio_dict, verbosity=1):
     if not isinstance(wio_dict, Dict):
         wio_dict = Dict(wio_dict, name="windio")
 
-    _print(f"Reading windio data")
+    _print("Reading windio data")
     _print("  Name:", wio_dict.pop_item("name", None))
     _print("  Contents:", [k for k in wio_dict.keys()])
 

foxes/models/__init__.py

@@ -2,18 +2,19 @@
 Model collection.
 """
 
-from . import turbine_types
-from . import rotor_models
-from . import turbine_models
-from . import farm_models
-from . import partial_wakes
-from . import wake_frames
-from . import wake_models
-from . import wake_superpositions
-from . import farm_controllers
-from . import vertical_profiles
-from . import point_models
-from . import axial_induction
-from . import ground_models
+from . import turbine_types as turbine_types
+from . import rotor_models as rotor_models
+from . import turbine_models as turbine_models
+from . import farm_models as farm_models
+from . import partial_wakes as partial_wakes
+from . import wake_frames as wake_frames
+from . import wake_models as wake_models
+from . import wake_deflections as wake_deflections
+from . import wake_superpositions as wake_superpositions
+from . import farm_controllers as farm_controllers
+from . import vertical_profiles as vertical_profiles
+from . import point_models as point_models
+from . import axial_induction as axial_induction
+from . import ground_models as ground_models
 
-from .model_book import ModelBook
+from .model_book import ModelBook as ModelBook

foxes/models/axial_induction/__init__.py

@@ -1,2 +1,2 @@
-from .betz import BetzAxialInduction
-from .madsen import MadsenAxialInduction
+from .betz import BetzAxialInduction as BetzAxialInduction
+from .madsen import MadsenAxialInduction as MadsenAxialInduction

foxes/models/farm_controllers/__init__.py

@@ -2,4 +2,4 @@
 Farm controller models.
 """
 
-from .basic import BasicFarmController
+from .basic import BasicFarmController as BasicFarmController

foxes/models/farm_models/__init__.py

@@ -2,4 +2,4 @@
 Farm models.
 """
 
-from .turbine2farm import Turbine2FarmModel
+from .turbine2farm import Turbine2FarmModel as Turbine2FarmModel

foxes/models/ground_models/__init__.py

@@ -1,2 +1,3 @@
-from .no_ground import NoGround
-from .wake_mirror import WakeMirror, GroundMirror
+from .no_ground import NoGround as NoGround
+from .wake_mirror import WakeMirror as WakeMirror
+from .wake_mirror import GroundMirror as GroundMirror

foxes/models/ground_models/wake_mirror.py

@@ -75,13 +75,14 @@ class WakeMirror(GroundModel):
         # assert(np.all(fdata[FV.H]==fdata[FV.TXYH[..., 2]]))
 
         # contribution from main wake:
-        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wcoos = algo.wake_frame.get_wake_coos(
+            algo, mdata, fdata, tdata, downwind_index, wmodel
+        )
         wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
 
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             pwake.contribute(
@@ -136,7 +137,6 @@ class WakeMirror(GroundModel):
         # contribution from mirrors:
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
-
             fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             wcoos = algo.wake_frame.get_wake_coos(

foxes/models/model_book.py

@@ -17,6 +17,7 @@ from foxes.core import (
     AxialInductionModel,
     TurbineInductionModel,
     GroundModel,
+    WakeDeflection,
 )
 
 
@@ -62,6 +63,9 @@ class ModelBook:
     ground_models: foxes.utils.FDict
         The ground models. Keys: model name str,
         values: foxes.core.GroundModel
+    wake_deflections: foxes.utils.FDict
+        The wake deflection models. Keys: model name str,
+        values: foxes.core.WakeDeflection
     sources: foxes.utils.FDict
         All sources dict
     base_classes: foxes.utils.FDict
@@ -231,15 +235,78 @@ class ModelBook:
             hints={"n2": "(Number of points in square grid)"},
         )
 
+        self.wake_deflections = FDict(
+            name="wake_deflections",
+            no_deflection=fm.wake_deflections.NoDeflection(),
+            Bastankhah2016=fm.wake_deflections.Bastankhah2016Deflection(),
+            Jimenez=fm.wake_deflections.JimenezDeflection(rotate=True),
+            JimenezProj=fm.wake_deflections.JimenezDeflection(rotate=False),
+            JimenezPath=fm.wake_deflections.JimenezDeflection(rotate=None),
+        )
+
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "Jimenez_b<beta>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            hints={"beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)"},
+            kwargs=dict(rotate=True),
+        )
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "Jimenez_b<beta>_dx<dx>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            dx=lambda dx: float(dx),
+            var2arg={"dx": "step_x"},
+            hints={
+                "beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)",
+                "dx": "(The step size in m for integration along wake path, e.g. 10)",
+            },
+            kwargs=dict(rotate=True),
+        )
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "JimenezProj_b<beta>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            hints={"beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)"},
+            kwargs=dict(rotate=False),
+        )
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "JimenezProj_b<beta>_dx<dx>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            dx=lambda dx: float(dx),
+            var2arg={"dx": "step_x"},
+            hints={
+                "beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)",
+                "dx": "(The step size in m for integration along wake path, e.g. 10)",
+            },
+            kwargs=dict(rotate=False),
+        )
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "JimenezPath_b<beta>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            hints={"beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)"},
+            kwargs=dict(rotate=None),
+        )
+        self.wake_deflections.add_factory(
+            fm.wake_deflections.JimenezDeflection,
+            "JimenezPath_b<beta>_dx<dx>",
+            beta=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
+            dx=lambda dx: float(dx),
+            var2arg={"dx": "step_x"},
+            hints={
+                "beta": "(The Jimenez beta coefficient, e.g. 01 for 0.1)",
+                "dx": "(The step size in m for integration along wake path, e.g. 10)",
+            },
+            kwargs=dict(rotate=None),
+        )
+
         self.wake_frames = FDict(
             name="wake_frames",
-            rotor_wd=fm.wake_frames.RotorWD(var_wd=FV.WD),
+            rotor_wd=fm.wake_frames.RotorWD(),
             rotor_wd_farmo=fm.wake_frames.FarmOrder(),
         )
-        self.wake_frames.add_k_factory(
-            fm.wake_frames.YawedWakes,
-            "yawed_[wake_k]",
-        )
         self.wake_frames.add_factory(
             fm.wake_frames.Streamlines2D,
             "streamlines_<step>",
@@ -336,6 +403,8 @@ class ModelBook:
             ti_cubic=fm.wake_superpositions.TIPow(pow=3, superp_to_amb="quadratic"),
             ti_quartic=fm.wake_superpositions.TIPow(pow=4, superp_to_amb="quadratic"),
             ti_max=fm.wake_superpositions.TIMax(superp_to_amb="quadratic"),
+            vector=fm.wake_superpositions.WindVectorLinear(scale_amb=False),
+            vector_amb=fm.wake_superpositions.WindVectorLinear(scale_amb=True),
         )
 
         self.axial_induction = FDict(name="induction_models")
@@ -348,76 +417,114 @@ class ModelBook:
             fm.wake_models.wind.JensenWake,
             "Jensen_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
             "Bastankhah2014_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.2, induction="Madsen"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
             "Bastankhah2014B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.2, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
             "Bastankhah025_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.25, induction="Madsen"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
             "Bastankhah025B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.25, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
             "Bastankhah2016_<superposition>_[wake_k]",
             kwargs=dict(induction="Madsen"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
             "Bastankhah2016B_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
         self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
             "TurbOPark_<superposition>_[wake_k]",
             kwargs=dict(induction="Madsen"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
             "TurbOParkB_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
         self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWakeIX,
             "TurbOParkIX_<superposition>_[wake_k]_dx<dx>",
-            superposition=lambda s: f"ws_{s}",
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
             dx=lambda x: float(x),
             hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)",
                 "dx": "(Integration step in m)",
             },
         )
@@ -460,39 +567,53 @@ class ModelBook:
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
-        self.wake_models[f"RHB"] = fm.wake_models.induction.RankineHalfBody()
+        self.wake_models["RHB"] = fm.wake_models.induction.RankineHalfBody()
 
-        self.wake_models[f"VortexSheet"] = fm.wake_models.induction.VortexSheet()
+        self.wake_models["VortexSheet"] = fm.wake_models.induction.VortexSheet()
         self.wake_models.add_factory(
             fm.wake_models.induction.VortexSheet,
             "VortexSheet_<superposition>",
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
-        self.wake_models[f"Rathmann"] = fm.wake_models.induction.Rathmann()
+        self.wake_models["Rathmann"] = fm.wake_models.induction.Rathmann()
         self.wake_models.add_factory(
             fm.wake_models.induction.Rathmann,
             "Rathmann_<superposition>",
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
-        self.wake_models[f"SelfSimilar"] = fm.wake_models.induction.SelfSimilar()
-        self.wake_models[f"SelfSimilar2020"] = (
-            fm.wake_models.induction.SelfSimilar2020()
-        )
+        self.wake_models["SelfSimilar"] = fm.wake_models.induction.SelfSimilar()
+        self.wake_models["SelfSimilar2020"] = fm.wake_models.induction.SelfSimilar2020()
         self.wake_models.add_factory(
             fm.wake_models.induction.SelfSimilar,
             "SelfSimilar_<superposition>",
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
         self.wake_models.add_factory(
             fm.wake_models.induction.SelfSimilar2020,
             "SelfSimilar2020_<superposition>",
-            superposition=lambda s: f"ws_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+            superposition=lambda s: f"ws_{s}"
+            if f"ws_{s}" in self.wake_superpositions
+            else s,
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear, or vector)"
+            },
         )
 
         self.ground_models = FDict(name="ground_models")
@@ -517,6 +638,7 @@ class ModelBook:
             farm_controllers=self.farm_controllers,
             partial_wakes=self.partial_wakes,
             wake_frames=self.wake_frames,
+            wake_deflections=self.wake_deflections,
             wake_superpositions=self.wake_superpositions,
             wake_models=self.wake_models,
             axial_induction=self.axial_induction,
@@ -532,6 +654,7 @@ class ModelBook:
             farm_controllers=FarmController,
             partial_wakes=PartialWakesModel,
             wake_frames=WakeFrame,
+            wake_deflections=WakeDeflection,
             wake_superpositions=WakeSuperposition,
             wake_models=WakeModel,
             axial_induction=AxialInductionModel,
@@ -563,16 +686,19 @@ class ModelBook:
             if subset is None or k in subset:
                 print(k)
                 print("-" * len(k))
-                if len(ms):
-                    for mname in sorted(list(ms.keys())):
-                        if search is None or search in mname:
-                            print(f"{mname}: {ms[mname]}")
-                    if isinstance(ms, FDict):
-                        for f in ms.factories:
-                            if search is None or search in f.name_template:
+                any = False
+                for mname in sorted(list(ms.keys())):
+                    if search is None or search in mname:
+                        print(f"{mname}: {ms[mname]}")
+                        any = True
+                if isinstance(ms, FDict):
+                    for f in ms.factories:
+                        if search is None or search in f.name_template:
+                            if any:
                                 print()
-                                print(f)
-                else:
+                            print(f)
+                            any = True
+                if not any:
                     print("(none)")
                 print()
 

foxes/models/partial_wakes/__init__.py

@@ -2,9 +2,9 @@
 Partial wake models.
 """
 
-from .centre import PartialCentre
-from .rotor_points import RotorPoints
-from .top_hat import PartialTopHat
-from .axiwake import PartialAxiwake
-from .segregated import PartialSegregated
-from .grid import PartialGrid
+from .centre import PartialCentre as PartialCentre
+from .rotor_points import RotorPoints as RotorPoints
+from .top_hat import PartialTopHat as PartialTopHat
+from .axiwake import PartialAxiwake as PartialAxiwake
+from .segregated import PartialSegregated as PartialSegregated
+from .grid import PartialGrid as PartialGrid

foxes/models/partial_wakes/axiwake.py

@@ -101,8 +101,6 @@ class PartialAxiwake(PartialCentre):
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
             (n_states, n_targets, n_tpoints, ...)
-        wmodel: foxes.core.WakeModel
-            The wake model
 
         """
         # check:
@@ -199,16 +197,43 @@ class PartialAxiwake(PartialCentre):
             algo, mdata, fdata, tdata, downwind_index, x, r
         )
 
-        for v, wdel in wdeltas.items():
-            d = np.einsum("sn,sn->s", wdel, weights[st_sel])
+        # run superposition models:
+        if wmodel.affects_ws and wmodel.has_uv:
+            assert wmodel.has_vector_wind_superp, (
+                f"{self.name}: Expecting vector wind superposition in wake model '{wmodel.name}', got '{wmodel.wind_superposition}'"
+            )
+            if FV.WS in wdeltas or FV.UV in wdeltas:
+                if FV.UV not in wdeltas:
+                    wmodel.vec_superp.wdeltas_ws2uv(
+                        algo, fdata, tdata, downwind_index, wdeltas, st_sel
+                    )
+                duv = np.einsum("snd,sn->sd", wdeltas.pop(FV.UV), weights[st_sel])
+                wake_deltas[FV.UV] = wmodel.vec_superp.add_wake_vector(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    st_sel,
+                    wake_deltas[FV.UV],
+                    duv[:, None],
+                )
+                del duv
+            for v in [FV.WS, FV.WD, FV.UV]:
+                if v in wdeltas:
+                    del wdeltas[v]
 
+        for v, wdel in wdeltas.items():
             try:
                 superp = wmodel.superp[v]
             except KeyError:
+                s = {v: m.name for v, m in wmodel.superp.items()}
                 raise KeyError(
-                    f"Model '{self.name}': Missing wake superposition entry for variable '{v}' in wake model '{wmodel.name}', found {sorted(list(wmodel.superp.keys()))}"
+                    f"Model '{self.name}': Missing wake superposition entry for variable '{v}' in wake model '{wmodel.name}', found {s}"
                 )
 
+            d = np.einsum("sn,sn->s", wdel, weights[st_sel])
+
             wake_deltas[v] = superp.add_wake(
                 algo,
                 mdata,