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

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,

foxes/models/partial_wakes/centre.py

@@ -39,3 +39,50 @@ class PartialCentre(RotorPoints):
 
         """
         return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=config.dtype_double)
+
+    def map_rotor_results(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        variable,
+        rotor_res,
+        rotor_weights,
+    ):
+        """
+        Map ambient rotor point results onto target points.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        variable: str
+            The variable name to map
+        rotor_res: numpy.ndarray
+            The results at rotor points, shape:
+            (n_states, n_turbines, n_rotor_points)
+        rotor_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+
+        Returns
+        -------
+        res: numpy.ndarray
+            The mapped results at target points, shape:
+            (n_states, n_targets, n_tpoints)
+
+        """
+        if rotor_res.shape[2] > 1:
+            return np.einsum(
+                "str,r->st",
+                rotor_res,
+                rotor_weights,
+            )[:, :, None]
+        else:
+            return rotor_res

foxes/models/partial_wakes/rotor_points.py

@@ -39,13 +39,52 @@ class RotorPoints(PartialWakesModel):
             algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata),
         )
 
+    def map_rotor_results(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        variable,
+        rotor_res,
+        rotor_weights,
+    ):
+        """
+        Map ambient rotor point results onto target points.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        variable: str
+            The variable name to map
+        rotor_res: numpy.ndarray
+            The results at rotor points, shape:
+            (n_states, n_turbines, n_rotor_points)
+        rotor_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+
+        Returns
+        -------
+        res: numpy.ndarray
+            The mapped results at target points, shape:
+            (n_states, n_targets, n_tpoints)
+
+        """
+        return rotor_res
+
     def finalize_wakes(
         self,
         algo,
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -67,11 +106,6 @@ class RotorPoints(PartialWakesModel):
             The farm data
         tdata: foxes.core.Data
             The target point data
-        amb_res: dict
-            The ambient results at the target points
-            of all rotors. Key: variable name, value
-            np.ndarray of shape:
-            (n_states, n_turbines, n_rotor_points)
         rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rotor_points,)
         wake_deltas: dict
@@ -91,8 +125,10 @@ class RotorPoints(PartialWakesModel):
             of shape (n_states, n_rotor_points)
 
         """
-        ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
-        wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
+        wdel = {
+            v: d[:, downwind_index, None].copy() if d.shape[1] > 1 else d[:, 0, None]
+            for v, d in wake_deltas.items()
+        }
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, tdata, wdel)
 
         return {v: d[:, 0] for v, d in wdel.items()}

foxes/models/partial_wakes/segregated.py

@@ -87,7 +87,6 @@ class PartialSegregated(PartialWakesModel):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -109,11 +108,6 @@ class PartialSegregated(PartialWakesModel):
             The farm data
         tdata: foxes.core.Data
             The target point data
-        amb_res: dict
-            The ambient results at the target points
-            of all rotors. Key: variable name, value
-            np.ndarray of shape:
-            (n_states, n_turbines, n_rotor_points)
         rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rotor_points,)
         wake_deltas: dict
@@ -138,20 +132,8 @@ class PartialSegregated(PartialWakesModel):
         gweights = tdata[FC.TWEIGHTS]
 
         wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
-
-        if n_rotor_points == tdata.n_tpoints:
-            ares = {v: d[:, downwind_index, None] for v, d in amb_res.items()}
-        else:
-            ares = {}
-            for v, d in amb_res.items():
-                ares[v] = np.zeros(
-                    (n_states, 1, tdata.n_tpoints), dtype=config.dtype_double
-                )
-                ares[v][:] = np.einsum("sp,p->s", d[:, downwind_index], rpoint_weights)[
-                    :, None, None
-                ]
-
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
+        htdata = tdata.get_slice([FC.TURBINE], np.s_[downwind_index])
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, htdata, wdel)
 
         for v in wdel.keys():
             hdel = np.zeros((n_states, n_rotor_points), dtype=config.dtype_double)

foxes/models/partial_wakes/top_hat.py

@@ -126,8 +126,6 @@ class PartialTopHat(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
 
         """
         self.check_wmodel(wmodel, error=True)
@@ -182,6 +180,33 @@ class PartialTopHat(PartialCentre):
 
                 weights = calc_area(D / 2, wr, R) / (np.pi * (D / 2) ** 2)
 
+                # 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.UV in clw:
+                        duv = clw.pop(FV.UV)
+                    else:
+                        clwe = {v: d[:, None] for v, d in clw.items()}
+                        wmodel.vec_superp.wdeltas_ws2uv(
+                            algo, fdata, tdata, downwind_index, clwe, st_sel
+                        )
+                        duv = np.einsum("sd,s->sd", clwe.pop(FV.UV)[:, 0], weights)
+                        del clwe, clw[FV.WS]
+                        if FV.WD in clw:
+                            del clw[FV.WD]
+                    wake_deltas[FV.UV] = wmodel.vec_superp.add_wake_vector(
+                        algo,
+                        mdata,
+                        fdata,
+                        tdata,
+                        downwind_index,
+                        st_sel,
+                        wake_deltas[FV.UV],
+                        duv[:, None],
+                    )
+
                 for v, d in clw.items():
                     try:
                         superp = wmodel.superp[v]

foxes/models/point_models/__init__.py

@@ -2,7 +2,7 @@
 Point models.
 """
 
-from .wake_deltas import WakeDeltas
-from .set_uniform_data import SetUniformData
-from .tke2ti import TKE2TI
-from .ustar2ti import Ustar2TI
+from .wake_deltas import WakeDeltas as WakeDeltas
+from .set_uniform_data import SetUniformData as SetUniformData
+from .tke2ti import TKE2TI as TKE2TI
+from .ustar2ti import Ustar2TI as Ustar2TI

foxes/models/rotor_models/__init__.py

@@ -2,6 +2,6 @@
 Rotor models.
 """
 
-from .centre import CentreRotor
-from .grid import GridRotor
-from .levels import LevelRotor
+from .centre import CentreRotor as CentreRotor
+from .grid import GridRotor as GridRotor
+from .levels import LevelRotor as LevelRotor