foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/models/wake_models/induction/rathmann.py

@@ -1,11 +1,11 @@
 import numpy as np
 
-from foxes.core import WakeModel
+from foxes.core import TurbineInductionModel
 import foxes.variables as FV
 import foxes.constants as FC
 
 
-class Rathmann(WakeModel):
+class Rathmann(TurbineInductionModel):
     """
     The Rathmann induction wake model
 
@@ -47,6 +47,12 @@ class Rathmann(WakeModel):
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
 
+    def __repr__(self):
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        return f"{type(self).__name__}(induction={iname})"
+
     def sub_models(self):
         """
         List of all sub-models
@@ -77,116 +83,105 @@ class Rathmann(WakeModel):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
 
-    def init_wake_deltas(self, algo, mdata, fdata, pdata, wake_deltas):
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
-        Initialize wake delta storage.
-
-        They are added on the fly to the wake_deltas dict.
+        Creates new empty wake delta arrays.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
+        tdata: foxes.core.TData
+            The target point data
+
+        Returns
+        -------
         wake_deltas: dict
-            The wake deltas storage, add wake deltas
-            on the fly. Keys: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
 
         """
-        n_states = mdata.n_states
-        n_points = pdata.n_points
-        wake_deltas[FV.WS] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
+        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
 
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         wake_coos,
         wake_deltas,
     ):
         """
-        Calculate the contribution to the wake deltas
-        by this wake model.
-
-        Modifies wake_deltas on the fly.
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
-            points, shape: (n_states, n_points, 3)
+            points, shape: (n_states, n_targets, n_tpoints, 3)
         wake_deltas: dict
-            The wake deltas, are being modified ob the fly.
-            Key: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
 
         """
-
-        # get x, y and z
-        x = wake_coos[:, :, 0]
-        y = wake_coos[:, :, 1]
-        z = wake_coos[:, :, 2]
-
         # get ct:
         ct = self.get_data(
             FV.CT,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
         )
 
         # get ws:
         ws = self.get_data(
             FV.REWS,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
         )
 
         # get D
-        D = self.get_data(
+        R = 0.5 * self.get_data(
             FV.D,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
-            upcast=True,
-            states_source_turbine=states_source_turbine,
+            tdata=tdata,
+            upcast=False,
+            downwind_index=downwind_index,
         )
 
-        x_R = x / (D / 2)
-        r_R = np.sqrt(y**2 + z**2) / (D / 2)
+        # get x, r and R etc. Rounding for safe x < 0 condition below
+        x_R = np.round(wake_coos[..., 0] / R, 12)
+        r_R = np.linalg.norm(wake_coos[..., 1:3], axis=-1) / R
 
         def mu(x_R):
             """axial shape function at r=0 from vortex cylinder model (eqn 11)"""
@@ -204,23 +199,21 @@ class Rathmann(WakeModel):
             return sin_alpha * sin_beta * (1 + x_R**2)
 
         # ws delta in front of rotor
-        sp_sel = (ct > 0) & (x < 0)
+        sp_sel = (ct > 0) & (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(x_R[sp_sel]) * G(x_R[sp_sel], r_R[sp_sel])
-            )  # eqn 10
+            blockage = ws[sp_sel] * a * mu(xr) * G(xr, r_R[sp_sel])  # eqn 10
             wake_deltas[FV.WS][sp_sel] += -blockage
 
         # ws delta behind rotor
         if not self.pre_rotor_only:
             # mirror -blockage in rotor plane
-            sp_sel = (ct > 0) & (x > 0) & (r_R > 1)
+            sp_sel = (ct > 0) & (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(-x_R[sp_sel]) * G(-x_R[sp_sel], r_R[sp_sel])
-                )  # eqn 10
+                blockage = ws[sp_sel] * a * mu(-xr) * G(-xr, r_R[sp_sel])  # eqn 10
                 wake_deltas[FV.WS][sp_sel] += blockage
 
         return wake_deltas

foxes/models/wake_models/induction/self_similar.py

@@ -1,11 +1,11 @@
 import numpy as np
 
-from foxes.core import WakeModel
+from foxes.core import TurbineInductionModel
 import foxes.variables as FV
 import foxes.constants as FC
 
 
-class SelfSimilar(WakeModel):
+class SelfSimilar(TurbineInductionModel):
     """
     The self-similar induction wake model
     from Troldborg and Meyer Forsting
@@ -38,7 +38,7 @@ class SelfSimilar(WakeModel):
 
     """
 
-    def __init__(self, pre_rotor_only=False, induction="Madsen"):
+    def __init__(self, pre_rotor_only=False, induction="Madsen", gamma=1.1):
         """
         Constructor.
 
@@ -48,11 +48,20 @@ class SelfSimilar(WakeModel):
             Calculate only the pre-rotor region
         induction: foxes.core.AxialInductionModel or str
             The induction model
+        gamma: float, default=1.1
+            The parameter that multiplies Ct in the ct2a calculation
 
         """
         super().__init__()
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
+        self.gamma = gamma
+
+    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})"
 
     def sub_models(self):
         """
@@ -84,40 +93,37 @@ class SelfSimilar(WakeModel):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
 
-    def init_wake_deltas(self, algo, mdata, fdata, pdata, wake_deltas):
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
-        Initialize wake delta storage.
-
-        They are added on the fly to the wake_deltas dict.
+        Creates new empty wake delta arrays.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
+        tdata: foxes.core.TData
+            The target point data
+
+        Returns
+        -------
         wake_deltas: dict
-            The wake deltas storage, add wake deltas
-            on the fly. Keys: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
 
         """
-        n_states = mdata.n_states
-        n_points = pdata.n_points
-        wake_deltas[FV.WS] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
+        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
 
     def _mu(self, x_R):
         """Helper function: define mu (eqn 11 from [1])"""
         return 1 + (x_R / np.sqrt(1 + x_R**2))
 
-    def _a0(self, ct, x_R, gamma=1.1):
+    def _a0(self, ct, x_R):
         """Helper function: define a0 with gamma factor, eqn 8 from [2]"""
-        return self.induction.ct2a(gamma * ct)
+        return self.induction.ct2a(self.gamma * ct)
 
     def _a(self, ct, x_R):
         """Helper function: define axial shape function (eqn 11 from [1])"""
@@ -131,93 +137,84 @@ class SelfSimilar(WakeModel):
         """Helper function: define radial shape function (eqn 12 from [1])"""
         return (1 / np.cosh(beta * (r_R) / self._r_half(x_R))) ** alpha  # * (x_R < 0)
 
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         wake_coos,
         wake_deltas,
     ):
         """
-        Calculate the contribution to the wake deltas
-        by this wake model.
-
-        Modifies wake_deltas on the fly.
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
-            points, shape: (n_states, n_points, 3)
+            points, shape: (n_states, n_targets, n_tpoints, 3)
         wake_deltas: dict
-            The wake deltas, are being modified ob the fly.
-            Key: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
 
         """
-
         # get ct
         ct = self.get_data(
             FV.CT,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
         )
 
         # get ws
         ws = self.get_data(
             FV.REWS,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
         )
 
-        # get D
-        D = self.get_data(
+        # get R
+        R = 0.5 * self.get_data(
             FV.D,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
-            upcast=True,
-            states_source_turbine=states_source_turbine,
+            tdata=tdata,
+            upcast=False,
+            downwind_index=downwind_index,
         )
 
-        # get x, r and R etc
-        x = wake_coos[:, :, 0]
-        y = wake_coos[:, :, 1]
-        z = wake_coos[:, :, 2]
-        R = D / 2
-        x_R = x / R
-        r = np.sqrt(y**2 + z**2)
-        r_R = r / R
+        # get x, r and R etc. Rounding for safe x < 0 condition below
+        x_R = np.round(wake_coos[..., 0] / R, 12)
+        r_R = np.linalg.norm(wake_coos[..., 1:3], axis=-1) / R
 
         # select values
-        sp_sel = (ct > 0) & (x < 0)  # upstream
+        sp_sel = (ct > 0) & (x_R <= 0)  # upstream
         if np.any(sp_sel):
             # velocity eqn 10 from [1]
             xr = x_R[sp_sel]
@@ -228,7 +225,7 @@ class SelfSimilar(WakeModel):
 
         # set area behind to mirrored value EXCEPT for area behind turbine
         if not self.pre_rotor_only:
-            sp_sel = (ct > 0) & (x > 0) & (r_R > 1)
+            sp_sel = (ct > 0) & (x_R > 0) & (r_R > 1)
             if np.any(sp_sel):
                 # velocity eqn 10 from [1]
                 xr = x_R[sp_sel]