foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/models/wake_models/induction/rathmann.py

@@ -31,27 +31,35 @@ class Rathmann(TurbineInductionModel):
 
     """
 
-    def __init__(self, pre_rotor_only=False, induction="Madsen"):
+    def __init__(
+        self,
+        superposition="ws_linear",
+        induction="Madsen",
+        pre_rotor_only=False,
+    ):
         """
         Constructor.
 
         Parameters
         ----------
-        pre_rotor_only: bool
-            Calculate only the pre-rotor region
+        superposition: str
+            The wind speed superposition
         induction: foxes.core.AxialInductionModel or str
             The induction model
+        pre_rotor_only: bool
+            Calculate only the pre-rotor region
 
         """
         super().__init__()
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
+        self._superp_name = superposition
 
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
-        return f"{type(self).__name__}(induction={iname})"
+        return f"{type(self).__name__}({self._superp_name}, induction={iname})"
 
     def sub_models(self):
         """
@@ -63,7 +71,7 @@ class Rathmann(TurbineInductionModel):
             All sub models
 
         """
-        return [self.induction]
+        return [self._superp, self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -79,6 +87,7 @@ class Rathmann(TurbineInductionModel):
             Overwrite existing data
 
         """
+        self._superp = algo.mbook.wake_superpositions[self._superp_name]
         if isinstance(self.induction, str):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
@@ -133,7 +142,7 @@ class Rathmann(TurbineInductionModel):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
@@ -155,18 +164,6 @@ class Rathmann(TurbineInductionModel):
             downwind_index=downwind_index,
         )
 
-        # get ws:
-        ws = self.get_data(
-            FV.REWS,
-            FC.STATE_TARGET_TPOINT,
-            lookup="w",
-            algo=algo,
-            fdata=fdata,
-            tdata=tdata,
-            upcast=True,
-            downwind_index=downwind_index,
-        )
-
         # get D
         R = 0.5 * self.get_data(
             FV.D,
@@ -199,21 +196,78 @@ class Rathmann(TurbineInductionModel):
             return sin_alpha * sin_beta * (1 + x_R**2)
 
         # ws delta in front of rotor
-        sp_sel = (ct > 0) & (x_R <= 0)
+        sp_sel = (ct > 1e-8) & (x_R <= 0)
         if np.any(sp_sel):
             xr = x_R[sp_sel]
             a = self.induction.ct2a(ct[sp_sel])
-            blockage = ws[sp_sel] * a * mu(xr) * G(xr, r_R[sp_sel])  # eqn 10
-            wake_deltas[FV.WS][sp_sel] += -blockage
+            blockage = a * mu(xr) * G(xr, r_R[sp_sel])  # eqn 10
+
+            self._superp.add_wake(
+                algo,
+                mdata,
+                fdata,
+                tdata,
+                downwind_index,
+                sp_sel,
+                FV.WS,
+                wake_deltas[FV.WS],
+                -blockage,
+            )
 
         # ws delta behind rotor
         if not self.pre_rotor_only:
             # mirror -blockage in rotor plane
-            sp_sel = (ct > 0) & (x_R > 0) & (r_R > 1)
+            sp_sel = (ct > 1e-8) & (x_R > 0) & (r_R > 1)
             if np.any(sp_sel):
                 xr = x_R[sp_sel]
                 a = self.induction.ct2a(ct[sp_sel])
-                blockage = ws[sp_sel] * a * mu(-xr) * G(-xr, r_R[sp_sel])  # eqn 10
-                wake_deltas[FV.WS][sp_sel] += blockage
+                blockage = a * mu(-xr) * G(-xr, r_R[sp_sel])  # eqn 10
+
+                self._superp.add_wake(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    sp_sel,
+                    FV.WS,
+                    wake_deltas[FV.WS],
+                    blockage,
+                )
 
         return wake_deltas
+
+    def finalize_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        amb_results,
+        wake_deltas,
+    ):
+        """
+        Finalize the wake calculation.
+
+        Modifies wake_deltas on the fly.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        amb_results: dict
+            The ambient results, key: variable name str,
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
+        wake_deltas: dict
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
+
+        """
+        wake_deltas[FV.WS] = self._superp.calc_final_wake_delta(
+            algo, mdata, fdata, FV.WS, amb_results[FV.WS], wake_deltas[FV.WS]
+        )

foxes/models/wake_models/induction/self_similar.py

@@ -38,30 +38,39 @@ class SelfSimilar(TurbineInductionModel):
 
     """
 
-    def __init__(self, pre_rotor_only=False, induction="Madsen", gamma=1.1):
+    def __init__(
+        self,
+        superposition="ws_linear",
+        induction="Madsen",
+        gamma=1.1,
+        pre_rotor_only=False,
+    ):
         """
         Constructor.
 
         Parameters
         ----------
-        pre_rotor_only: bool
-            Calculate only the pre-rotor region
+        superposition: str
+            The wind speed superposition.
         induction: foxes.core.AxialInductionModel or str
             The induction model
         gamma: float, default=1.1
             The parameter that multiplies Ct in the ct2a calculation
+        pre_rotor_only: bool
+            Calculate only the pre-rotor region
 
         """
         super().__init__()
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
         self.gamma = gamma
+        self._superp_name = superposition
 
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
-        return f"{type(self).__name__}(gamma={self.gamma}, induction={iname})"
+        return f"{type(self).__name__}({self._superp_name}, induction={iname}, gamma={self.gamma})"
 
     def sub_models(self):
         """
@@ -73,7 +82,7 @@ class SelfSimilar(TurbineInductionModel):
             All sub models
 
         """
-        return [self.induction]
+        return [self._superp, self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -89,6 +98,7 @@ class SelfSimilar(TurbineInductionModel):
             Overwrite existing data
 
         """
+        self._superp = algo.mbook.wake_superpositions[self._superp_name]
         if isinstance(self.induction, str):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
@@ -163,7 +173,7 @@ class SelfSimilar(TurbineInductionModel):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
@@ -185,18 +195,6 @@ class SelfSimilar(TurbineInductionModel):
             downwind_index=downwind_index,
         )
 
-        # get ws
-        ws = self.get_data(
-            FV.REWS,
-            FC.STATE_TARGET_TPOINT,
-            lookup="w",
-            algo=algo,
-            fdata=fdata,
-            tdata=tdata,
-            upcast=True,
-            downwind_index=downwind_index,
-        )
-
         # get R
         R = 0.5 * self.get_data(
             FV.D,
@@ -214,26 +212,78 @@ class SelfSimilar(TurbineInductionModel):
         r_R = np.linalg.norm(wake_coos[..., 1:3], axis=-1) / R
 
         # select values
-        sp_sel = (ct > 0) & (x_R <= 0)  # upstream
+        sp_sel = (ct > 1e-8) & (x_R <= 0)  # upstream
         if np.any(sp_sel):
             # velocity eqn 10 from [1]
             xr = x_R[sp_sel]
-            blockage = (
-                ws[sp_sel] * self._a(ct[sp_sel], xr) * self._rad_fn(xr, r_R[sp_sel])
+            blockage = self._a(ct[sp_sel], xr) * self._rad_fn(xr, r_R[sp_sel])
+
+            self._superp.add_wake(
+                algo,
+                mdata,
+                fdata,
+                tdata,
+                downwind_index,
+                sp_sel,
+                FV.WS,
+                wake_deltas[FV.WS],
+                -blockage,
             )
-            wake_deltas[FV.WS][sp_sel] -= blockage
 
         # set area behind to mirrored value EXCEPT for area behind turbine
         if not self.pre_rotor_only:
-            sp_sel = (ct > 0) & (x_R > 0) & (r_R > 1)
+            sp_sel = (ct > 1e-8) & (x_R > 0) & (r_R > 1)
             if np.any(sp_sel):
                 # velocity eqn 10 from [1]
                 xr = x_R[sp_sel]
-                blockage = (
-                    ws[sp_sel]
-                    * self._a(ct[sp_sel], -xr)
-                    * self._rad_fn(-xr, r_R[sp_sel])
+                blockage = self._a(ct[sp_sel], -xr) * self._rad_fn(-xr, r_R[sp_sel])
+
+                # wdelta[sp_sel] += blockage
+                self._superp.add_wake(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    sp_sel,
+                    FV.WS,
+                    wake_deltas[FV.WS],
+                    blockage,
                 )
-                wake_deltas[FV.WS][sp_sel] += blockage
 
         return wake_deltas
+
+    def finalize_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        amb_results,
+        wake_deltas,
+    ):
+        """
+        Finalize the wake calculation.
+
+        Modifies wake_deltas on the fly.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        amb_results: dict
+            The ambient results, key: variable name str,
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
+        wake_deltas: dict
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
+
+        """
+        wake_deltas[FV.WS] = self._superp.calc_final_wake_delta(
+            algo, mdata, fdata, FV.WS, amb_results[FV.WS], wake_deltas[FV.WS]
+        )

foxes/models/wake_models/induction/vortex_sheet.py

@@ -10,7 +10,10 @@ class VortexSheet(TurbineInductionModel):
     """
     The Vortex Sheet model implemented with a radial dependency
 
-    Ref: Medici, D., et al. "The upstream flow of a wind turbine: blockage effect." Wind Energy 14.5 (2011): 691-697.
+    Notes
+    -----
+    Reference:
+    Medici, D., et al. "The upstream flow of a wind turbine: blockage effect." Wind Energy 14.5 (2011): 691-697.
     https://doi.org/10.1002/we.451
 
     Attributes
@@ -24,29 +27,35 @@ class VortexSheet(TurbineInductionModel):
 
     """
 
-    def __init__(self, pre_rotor_only=False, induction="Madsen"):
+    def __init__(
+        self,
+        superposition="ws_linear",
+        induction="Madsen",
+        pre_rotor_only=False,
+    ):
         """
         Constructor.
 
         Parameters
         ----------
-        pre_rotor_only: bool
-            Calculate only the pre-rotor region
+        superposition: str
+            The wind speed superposition
         induction: foxes.core.AxialInductionModel or str
             The induction model
-
-        :group: models.wake_models.induction
+        pre_rotor_only: bool
+            Calculate only the pre-rotor region
 
         """
         super().__init__()
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
+        self._superp_name = superposition
 
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
-        return f"{type(self).__name__}, induction={iname})"
+        return f"{type(self).__name__}({self._superp_name}, induction={iname})"
 
     def sub_models(self):
         """
@@ -58,7 +67,7 @@ class VortexSheet(TurbineInductionModel):
             All sub models
 
         """
-        return [self.induction]
+        return [self._superp, self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -74,6 +83,7 @@ class VortexSheet(TurbineInductionModel):
             Overwrite existing data
 
         """
+        self._superp = algo.mbook.wake_superpositions[self._superp_name]
         if isinstance(self.induction, str):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
@@ -129,7 +139,7 @@ class VortexSheet(TurbineInductionModel):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
@@ -159,18 +169,6 @@ class VortexSheet(TurbineInductionModel):
             downwind_index=downwind_index,
         )
 
-        # get ws
-        ws = self.get_data(
-            FV.REWS,
-            FC.STATE_TARGET_TPOINT,
-            lookup="w",
-            algo=algo,
-            fdata=fdata,
-            tdata=tdata,
-            upcast=True,
-            downwind_index=downwind_index,
-        )
-
         # get D
         D = self.get_data(
             FV.D,
@@ -183,45 +181,85 @@ class VortexSheet(TurbineInductionModel):
             downwind_index=downwind_index,
         )
 
-        sp_sel = (ct > 0) & (x <= 0)
-        ws_sel = ws[sp_sel]
+        sp_sel = (ct > 1e-8) & (x <= 0)
         ct_sel = ct[sp_sel]
         r_sph_sel = r_sph[sp_sel]
         D_sel = D[sp_sel]
 
         if np.any(sp_sel):
-            blockage = (
-                ws_sel
-                * (
-                    1
-                    - self.induction.ct2a(ct_sel)
-                    * ((1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2))
-                    ** (-0.5)
-                )
-            ) - ws_sel
-            wake_deltas[FV.WS][sp_sel] += blockage
+            blockage = self.induction.ct2a(ct_sel) * (
+                (1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2)
+            ) ** (-0.5)
+
+            self._superp.add_wake(
+                algo,
+                mdata,
+                fdata,
+                tdata,
+                downwind_index,
+                sp_sel,
+                FV.WS,
+                wake_deltas[FV.WS],
+                -blockage,
+            )
 
         if not self.pre_rotor_only:
             sp_sel = (
-                (ct > 0) & (x > 0) & (r > D / 2)
+                (ct > 1e-8) & (x > 0) & (r > D / 2)
             )  # mirror in rotor plane and inverse blockage, but not directly behind rotor
-            ws_sel = ws[sp_sel]
             ct_sel = ct[sp_sel]
             r_sph_sel = r_sph[sp_sel]
             D_sel = D[sp_sel]
             if np.any(sp_sel):
-                blockage = (
-                    ws_sel
-                    * (
-                        1
-                        - self.induction.ct2a(ct_sel)
-                        * (
-                            (1 + 2 * r_sph_sel / D_sel)
-                            * (1 + (2 * r_sph_sel / D_sel) ** 2)
-                        )
-                        ** (-0.5)
-                    )
-                ) - ws_sel
-                wake_deltas[FV.WS][sp_sel] += -blockage
+                blockage = self.induction.ct2a(ct_sel) * (
+                    (1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2)
+                ) ** (-0.5)
+
+                self._superp.add_wake(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    sp_sel,
+                    FV.WS,
+                    wake_deltas[FV.WS],
+                    blockage,
+                )
 
         return wake_deltas
+
+    def finalize_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        amb_results,
+        wake_deltas,
+    ):
+        """
+        Finalize the wake calculation.
+
+        Modifies wake_deltas on the fly.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        amb_results: dict
+            The ambient results, key: variable name str,
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
+        wake_deltas: dict
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
+
+        """
+        wake_deltas[FV.WS] = self._superp.calc_final_wake_delta(
+            algo, mdata, fdata, FV.WS, amb_results[FV.WS], wake_deltas[FV.WS]
+        )

foxes/models/wake_models/ti/crespo_hernandez.py

@@ -278,8 +278,9 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             fdata=fdata,
             tdata=tdata,
             downwind_index=downwind_index,
-            upcast=True,
-        )[st_sel]
+            upcast=False,
+            selection=st_sel,
+        )
 
         # get TI:
         ti = self.get_data(
@@ -290,8 +291,9 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             fdata=fdata,
             tdata=tdata,
             downwind_index=downwind_index,
-            upcast=True,
-        )[st_sel]
+            upcast=False,
+            selection=st_sel,
+        )
 
         # calculate induction factor:
         twoa = 2 * self.induction.ct2a(ct)

foxes/models/wake_models/ti/iec_ti.py

@@ -54,24 +54,27 @@ class IECTIWake(TopHatWakeModel):
 
         """
         super().__init__(superpositions={FV.TI: superposition}, induction=induction)
+        self.iec_type = iec_type
+        self.wake_k = None
 
-        if opening_angle is not None:
+        if opening_angle is None:
+            self.wake_k = WakeK(**wake_k)
+        else:
             if "k" in wake_k or "ka" in wake_k or "kb" in wake_k:
                 raise KeyError(
                     f"Can handle 'opening_angle' or ('k', 'ka', 'kb') parameters, not both"
                 )
-            wake_k["k"] = float(np.tan(np.deg2rad(opening_angle / 2.0)))
-
-        self.iec_type = iec_type
-        self.wake_k = WakeK(**wake_k)
+            self._k = float(np.tan(np.deg2rad(opening_angle / 2.0)))
 
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.TI]}, induction={iname}, "
-        s += self.wake_k.repr() + ")"
+        s += f"({self.superpositions[FV.TI]}, induction={iname}"
+        if self.wake_k is not None:
+            s += ", " + self.wake_k.repr()
+        s += ")"
         return s
 
     def sub_models(self):
@@ -84,7 +87,7 @@ class IECTIWake(TopHatWakeModel):
             All sub models
 
         """
-        return [self.wake_k]
+        return [self.wake_k] if self.wake_k is not None else []
 
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
@@ -147,15 +150,29 @@ class IECTIWake(TopHatWakeModel):
             The wake radii, shape: (n_states, n_targets)
 
         """
-        k = self.wake_k(
-            FC.STATE_TARGET,
-            algo=algo,
-            fdata=fdata,
-            tdata=tdata,
-            upcast=False,
-            downwind_index=downwind_index,
-        )
-        return k * x
+        if self.wake_k is None:
+            return self._k * x
+        else:
+            D = self.get_data(
+                FV.D,
+                FC.STATE_TARGET,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=True,
+            )
+
+            k = self.wake_k(
+                FC.STATE_TARGET,
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                upcast=False,
+                downwind_index=downwind_index,
+            )
+            return D / 2 + k * x
 
     def calc_centreline(
         self,
@@ -211,8 +228,9 @@ class IECTIWake(TopHatWakeModel):
             fdata=fdata,
             tdata=tdata,
             downwind_index=downwind_index,
-            upcast=True,
-        )[st_sel]
+            upcast=False,
+            selection=st_sel,
+        )
 
         # get ws:
         ws = self.get_data(
@@ -223,8 +241,9 @@ class IECTIWake(TopHatWakeModel):
             fdata=fdata,
             tdata=tdata,
             downwind_index=downwind_index,
-            upcast=True,
-        )[st_sel]
+            upcast=False,
+            selection=st_sel,
+        )
 
         # calculate wind deficit:
         if self.iec_type == "2005":

foxes/models/wake_models/top_hat.py

@@ -209,7 +209,7 @@ class TopHatWakeModel(AxisymmetricWakeModel):
         wake_r = self.calc_wake_radius(algo, mdata, fdata, tdata, downwind_index, x, ct)
 
         wdeltas = {}
-        st_sel = (ct > 0) & (x > 0) & np.any(r < wake_r[:, :, None], axis=2)
+        st_sel = (x > 1e-8) & (ct > 1e-8) & np.any(r < wake_r[:, :, None], axis=2)
         if np.any(st_sel):
             x = x[st_sel]
             r = r[st_sel]