foxes 1.3__py3-none-any.whl → 1.5__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
@@ -81,12 +85,13 @@ class ModelBook:
             Path to power/ct curve file, for creation
             of default turbine type model
         """
-        self.point_models = FDict(name="point_models")
+        self.point_models = FDict(_name="point_models")
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
         self.point_models["ustar2ti"] = fm.point_models.Ustar2TI()
 
-        self.rotor_models = FDict(name="rotor_models")
+        self.rotor_models = FDict(_name="rotor_models")
         self.rotor_models["centre"] = fm.rotor_models.CentreRotor()
+        self.rotor_models["direct_mdata"] = fm.rotor_models.DirectMDataInfusion()
 
         def _n2n(n2):
             n2 = float(n2)
@@ -128,7 +133,7 @@ class ModelBook:
             hints={"n": "(Number of vertical levels)"},
         )
 
-        self.turbine_types = FDict(name="turbine_types")
+        self.turbine_types = FDict(_name="turbine_types")
         self.turbine_types["null_type"] = fm.turbine_types.NullType()
         self.turbine_types["NREL5MW"] = fm.turbine_types.PCtFile(
             "NREL-5MW-D126-H90.csv", rho=1.225
@@ -146,7 +151,7 @@ class ModelBook:
             self.turbine_types["Pct"] = fm.turbine_types.PCtFile(Pct_file)
 
         self.turbine_models = FDict(
-            name="turbine_models",
+            _name="turbine_models",
             kTI=fm.turbine_models.kTI(),
             kTI_amb=fm.turbine_models.kTI(ti_var=FV.AMB_TI),
             thrust2ct=fm.turbine_models.Thrust2Ct(),
@@ -199,7 +204,7 @@ class ModelBook:
         )
 
         self.farm_models = FDict(
-            name="farm_models",
+            _name="farm_models",
             **{
                 f"farm_{mname}": fm.farm_models.Turbine2FarmModel(m)
                 for mname, m in self.turbine_models.items()
@@ -207,12 +212,12 @@ class ModelBook:
         )
 
         self.farm_controllers = FDict(
-            name="farm_controllers",
+            _name="farm_controllers",
             basic_ctrl=fm.farm_controllers.BasicFarmController(),
         )
 
         self.partial_wakes = FDict(
-            name="partial_wakes",
+            _name="partial_wakes",
             rotor_points=fm.partial_wakes.RotorPoints(),
             top_hat=fm.partial_wakes.PartialTopHat(),
             centre=fm.partial_wakes.PartialCentre(),
@@ -231,15 +236,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),
+            _name="wake_frames",
+            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>",
@@ -296,7 +364,7 @@ class ModelBook:
         )
 
         self.wake_superpositions = FDict(
-            name="wake_superpositions",
+            _name="wake_superpositions",
             ws_linear=fm.wake_superpositions.WSLinear(scale_amb=False),
             ws_linear_lim=fm.wake_superpositions.WSLinear(
                 scale_amb=False, lim_low=1e-4
@@ -336,88 +404,128 @@ 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")
+        self.axial_induction = FDict(_name="induction_models")
         self.axial_induction["Betz"] = fm.axial_induction.BetzAxialInduction()
         self.axial_induction["Madsen"] = fm.axial_induction.MadsenAxialInduction()
 
-        self.wake_models = FDict(name="wake_models")
+        self.wake_models = FDict(_name="wake_models")
 
         self.wake_models.add_k_factory(
             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,42 +568,56 @@ 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")
+        self.ground_models = FDict(_name="ground_models")
         self.ground_models["no_ground"] = fm.ground_models.NoGround()
         self.ground_models["ground_mirror"] = fm.ground_models.GroundMirror()
         self.ground_models.add_factory(
@@ -508,7 +630,7 @@ class ModelBook:
         )
 
         self.sources = FDict(
-            name="sources",
+            _name="sources",
             point_models=self.point_models,
             rotor_models=self.rotor_models,
             turbine_types=self.turbine_types,
@@ -517,13 +639,14 @@ 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,
             ground_models=self.ground_models,
         )
         self.base_classes = FDict(
-            name="base_classes",
+            _name="base_classes",
             point_models=PointDataModel,
             rotor_models=RotorModel,
             turbine_types=TurbineType,
@@ -532,6 +655,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 +687,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,14 +125,10 @@ class RotorPoints(PartialWakesModel):
             of shape (n_states, n_rotor_points)
 
         """
-        ares = {
-            v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
-            for v, d in amb_res.items()
-        }
         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, ares, wdel)
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, tdata, wdel)
 
         return {v: d[:, 0] for v, d in wdel.items()}