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

foxes/models/wake_models/dist_sliced.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+import numpy as np
 
 from foxes.core import WakeModel
 
@@ -73,13 +74,13 @@ class DistSlicedWakeModel(WakeModel):
         super().initialize(algo, verbosity, force)
 
     @abstractmethod
-    def calc_wakes_spsel_x_yz(
+    def calc_wakes_x_yz(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
         yz,
     ):
@@ -90,77 +91,74 @@ class DistSlicedWakeModel(WakeModel):
         ----------
         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 in the downwind order
         x: numpy.ndarray
-            The x values, shape: (n_states, n_points)
+            The x values, shape: (n_states, n_targets)
         yz: numpy.ndarray
             The yz values for each x value, shape:
-            (n_states, n_points, n_yz_per_x, 2)
+            (n_states, n_targets, n_yz_per_target, 2)
 
         Returns
         -------
         wdeltas: dict
             The wake deltas. Key: variable name str,
-            value: numpy.ndarray, shape: (n_sp_sel, n_yz_per_x)
-        sp_sel: numpy.ndarray of bool
-            The state-point selection, for which the wake
-            is non-zero, shape: (n_states, n_points)
+            value: numpy.ndarray, shape: (n_st_sel, n_yz_per_target)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
 
         """
         pass
 
-    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, ...)
 
         """
-        x = wake_coos[:, :, 0]
-        yz = wake_coos[:, :, None, 1:3]
+        # rounding for safe x > 0 conditions
+        x = np.round(wake_coos[:, :, 0, 0], 12)
+        yz = wake_coos[..., 1:3]
 
-        wdeltas, sp_sel = self.calc_wakes_spsel_x_yz(
-            algo, mdata, fdata, pdata, states_source_turbine, x, yz
+        wdeltas, st_sel = self.calc_wakes_x_yz(
+            algo, mdata, fdata, tdata, downwind_index, x, yz
         )
 
         for v, hdel in wdeltas.items():
@@ -171,16 +169,16 @@ class DistSlicedWakeModel(WakeModel):
                     f"Model '{self.name}': Missing wake superposition entry for variable '{v}', found {sorted(list(self.superp.keys()))}"
                 )
 
-            wake_deltas[v] = superp.calc_wakes_plus_wake(
+            wake_deltas[v] = superp.add_wake(
                 algo,
                 mdata,
                 fdata,
-                pdata,
-                states_source_turbine,
-                sp_sel,
+                tdata,
+                downwind_index,
+                st_sel,
                 v,
                 wake_deltas[v],
-                hdel[:, 0],
+                hdel,
             )
 
     def finalize_wake_deltas(
@@ -188,7 +186,6 @@ class DistSlicedWakeModel(WakeModel):
         algo,
         mdata,
         fdata,
-        pdata,
         amb_results,
         wake_deltas,
     ):
@@ -201,24 +198,21 @@ class DistSlicedWakeModel(WakeModel):
         ----------
         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
         amb_results: dict
             The ambient results, key: variable name str,
-            values: numpy.ndarray with shape (n_states, n_points)
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
         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, ...) before evaluation,
-            numpy.ndarray with shape (n_states, n_points) afterwards
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
 
         """
         for v, s in self.superp.items():
             wake_deltas[v] = s.calc_final_wake_delta(
-                algo, mdata, fdata, pdata, v, amb_results[v], wake_deltas[v]
+                algo, mdata, fdata, v, amb_results[v], wake_deltas[v]
             )

foxes/models/wake_models/gaussian.py

@@ -13,13 +13,13 @@ class GaussianWakeModel(AxisymmetricWakeModel):
     """
 
     @abstractmethod
-    def calc_amplitude_sigma_spsel(
+    def calc_amplitude_sigma(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
     ):
         """
@@ -30,37 +30,36 @@ class GaussianWakeModel(AxisymmetricWakeModel):
         ----------
         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 in the downwind order
         x: numpy.ndarray
-            The x values, shape: (n_states, n_points)
+            The x values, shape: (n_states, n_targets)
 
         Returns
         -------
         amsi: tuple
             The amplitude and sigma, both numpy.ndarray
-            with shape (n_sp_sel,)
-        sp_sel: numpy.ndarray of bool
-            The state-point selection, for which the wake
-            is non-zero, shape: (n_states, n_points)
+            with shape (n_st_sel,)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
 
         """
         pass
 
-    def calc_wakes_spsel_x_r(
+    def calc_wakes_x_r(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
         r,
     ):
@@ -71,38 +70,37 @@ class GaussianWakeModel(AxisymmetricWakeModel):
         ----------
         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 in the downwind order
         x: numpy.ndarray
-            The x values, shape: (n_states, n_points)
+            The x values, shape: (n_states, n_targets)
         r: numpy.ndarray
             The radial values for each x value, shape:
-            (n_states, n_points, n_r_per_x, 2)
+            (n_states, n_targets, n_yz_per_target)
 
         Returns
         -------
         wdeltas: dict
             The wake deltas. Key: variable name str,
-            value: numpy.ndarray, shape: (n_sp_sel, n_r_per_x)
-        sp_sel: numpy.ndarray of bool
-            The state-point selection, for which the wake
-            is non-zero, shape: (n_states, n_points)
+            value: numpy.ndarray, shape: (n_st_sel, n_r_per_x)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
 
         """
-        amsi, sp_sel = self.calc_amplitude_sigma_spsel(
-            algo, mdata, fdata, pdata, states_source_turbine, x
+        amsi, st_sel = self.calc_amplitude_sigma(
+            algo, mdata, fdata, tdata, downwind_index, x
         )
         wdeltas = {}
-        rsel = r[sp_sel]
+        rsel = r[st_sel]
         for v in amsi.keys():
             ampld, sigma = amsi[v]
             wdeltas[v] = ampld[:, None] * np.exp(-0.5 * (rsel / sigma[:, None]) ** 2)
 
-        return wdeltas, sp_sel
+        return wdeltas, st_sel

foxes/models/wake_models/induction/rankine_half_body.py

@@ -1,12 +1,12 @@
 import numpy as np
 
-from foxes.core import WakeModel
+from foxes.core import TurbineInductionModel
 from foxes.utils import uv2wd, wd2uv
 import foxes.variables as FV
 import foxes.constants as FC
 
 
-class RankineHalfBody(WakeModel):
+class RankineHalfBody(TurbineInductionModel):
     """
     The Rankine half body induction wake model
 
@@ -43,6 +43,12 @@ class RankineHalfBody(WakeModel):
         super().__init__()
         self.induction = induction
 
+    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
@@ -73,122 +79,113 @@ class RankineHalfBody(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["U"] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        wake_deltas["V"] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        wake_deltas[FV.WS] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        wake_deltas[FV.WD] = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-
-    def contribute_to_wake_deltas(
+        return {
+            FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0]),
+            FV.WD: np.zeros_like(tdata[FC.TARGETS][..., 0]),
+            "U": np.zeros_like(tdata[FC.TARGETS][..., 0]),
+            "V": np.zeros_like(tdata[FC.TARGETS][..., 0]),
+        }
+
+    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,
-            upcast=True,
-            states_source_turbine=states_source_turbine,
+            tdata=tdata,
+            downwind_index=downwind_index,
+            upcast=False,
         )
 
         # get ws:
         ws = self.get_data(
             FV.REWS,
-            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,
+            downwind_index=downwind_index,
+            upcast=False,
         )
 
         # get D
         D = self.get_data(
             FV.D,
-            FC.STATE_POINT,
+            FC.STATE_TARGET_TPOINT,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
             upcast=True,
-            states_source_turbine=states_source_turbine,
         )
 
         # calc m (page 7, skipping pi everywhere)
         m = 2 * ws * self.induction.ct2a(ct) * (D / 2) ** 2
 
         # get r and theta
-        r = np.sqrt(y**2 + z**2)
+        x = np.round(wake_coos[..., 0], 12)
+        r = np.linalg.norm(wake_coos[..., 1:], axis=-1)
         r_sph = np.sqrt(r**2 + x**2)
         theta = np.arctan2(r, x)
 
@@ -201,35 +198,32 @@ class RankineHalfBody(WakeModel):
         xs = -np.sqrt(m / (4 * ws))
 
         # set values out of body shape
-        sp_sel = (ct > 0) & ((RHB_shape < -1) | (x < xs))
-        if np.any(sp_sel):
+        st_sel = (ct > 0) & ((RHB_shape < -1) | (x < xs))
+        if np.any(st_sel):
             # apply selection
-            xyz = wake_coos[sp_sel]
+            xyz = wake_coos[st_sel]
 
             # calc velocity components
-            vel_factor = m[sp_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
-            wake_deltas["U"][sp_sel] += vel_factor * xyz[:, 0]
-            wake_deltas["V"][sp_sel] += vel_factor * xyz[:, 1]
+            vel_factor = m[st_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
+            wake_deltas["U"][st_sel] += vel_factor * xyz[:, 0]
+            wake_deltas["V"][st_sel] += vel_factor * xyz[:, 1]
 
         # set values inside body shape
-        sp_sel = (ct > 0) & (RHB_shape >= -1) & (x >= xs) & (x < 0)
-        if np.any(sp_sel):
+        st_sel = (ct > 0) & (RHB_shape >= -1) & (x >= xs) & (x <= 0)
+        if np.any(st_sel):
             # apply selection
-            xyz = np.zeros_like(wake_coos[sp_sel])
-            xyz[:, 0] = xs[sp_sel]
+            xyz = np.zeros_like(wake_coos[st_sel])
+            xyz[:, 0] = xs[st_sel]
 
             # calc velocity components
-            vel_factor = m[sp_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
-            wake_deltas["U"][sp_sel] += vel_factor * xyz[:, 0]
-
-        return wake_deltas
+            vel_factor = m[st_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
+            wake_deltas["U"][st_sel] += vel_factor * xyz[:, 0]
 
     def finalize_wake_deltas(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
         amb_results,
         wake_deltas,
     ):
@@ -242,32 +236,30 @@ class RankineHalfBody(WakeModel):
         ----------
         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
         amb_results: dict
             The ambient results, key: variable name str,
-            values: numpy.ndarray with shape (n_states, n_points)
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
         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, ...) before evaluation,
-            numpy.ndarray with shape (n_states, n_points) afterwards
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
 
         """
-
         # calc ambient wind vector:
         ws0 = amb_results[FV.WS]
         nx = wd2uv(amb_results[FV.WD])
-        wind_vec = nx * ws0[:, :, None]
+        wind_vec = nx * ws0[:, :, :, None]
 
         # wake deltas are in wake frame, rotate back to global frame:
-        ny = np.stack((-nx[:, :, 1], nx[:, :, 0]), axis=2)
-        delta_uv = wake_deltas["U"][:, :, None] * nx + wake_deltas["V"][:, :, None] * ny
+        ny = np.stack((-nx[..., 1], nx[..., 0]), axis=-1)
+        delta_uv = (
+            wake_deltas["U"][:, :, :, None] * nx + wake_deltas["V"][:, :, :, None] * ny
+        )
         del ws0, nx, ny
 
         # add ambient result to wake deltas: