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

foxes/models/wake_models/wind/turbopark.py

@@ -1,7 +1,6 @@
 import numpy as np
 
 from foxes.models.wake_models.gaussian import GaussianWakeModel
-from foxes.utils import sqrt_reg
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -48,10 +47,8 @@ class TurbOParkWake(GaussianWakeModel):
 
         Parameters
         ----------
-        superpositions: dict
-            The superpositions. Key: variable name str,
-            value: The wake superposition model name,
-            will be looked up in model book
+        superposition: str
+            The wind deficit superposition
         A: float
             The wake growth parameter A.
         sbeta_factor: float
@@ -73,8 +70,11 @@ class TurbOParkWake(GaussianWakeModel):
         self.induction = induction
 
     def __repr__(self):
-        s = super().__repr__()
-        s += f"(A={self.A}, sp={self.superpositions[FV.WS]})"
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        s = f"{type(self).__name__}"
+        s += f"({self.superpositions[FV.WS]}, A={self.A}, induction={iname})"
         return s
 
     def sub_models(self):
@@ -107,39 +107,13 @@ class TurbOParkWake(GaussianWakeModel):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
 
-    def init_wake_deltas(self, algo, mdata, fdata, pdata, wake_deltas):
-        """
-        Initialize wake delta storage.
-
-        They are added on the fly to the wake_deltas dict.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        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, ...)
-
-        """
-        n_states = mdata.n_states
-        wake_deltas[FV.WS] = np.zeros((n_states, pdata.n_points), dtype=FC.DTYPE)
-
-    def calc_amplitude_sigma_spsel(
+    def calc_amplitude_sigma(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
     ):
         """
@@ -150,73 +124,69 @@ class TurbOParkWake(GaussianWakeModel):
         ----------
         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)
 
         """
-
         # get ct:
         ct = self.get_data(
             FV.CT,
-            FC.STATE_POINT,
+            FC.STATE_TARGET,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
             upcast=True,
-            states_source_turbine=states_source_turbine,
         )
 
         # select targets:
-        sp_sel = (x > 1e-5) & (ct > 0.0)
-        if np.any(sp_sel):
+        st_sel = (x > 1e-5) & (ct > 0.0)
+        if np.any(st_sel):
             # apply selection:
-            x = x[sp_sel]
-            ct = ct[sp_sel]
+            x = x[st_sel]
+            ct = ct[st_sel]
 
             # get D:
             D = self.get_data(
                 FV.D,
-                FC.STATE_POINT,
+                FC.STATE_TARGET,
                 lookup="w",
                 algo=algo,
                 fdata=fdata,
-                pdata=pdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
                 upcast=True,
-                states_source_turbine=states_source_turbine,
-            )
-            D = D[sp_sel]
+            )[st_sel]
 
             # get TI:
             ati = self.get_data(
                 FV.AMB_TI,
-                FC.STATE_POINT,
+                FC.STATE_TARGET,
                 lookup="w",
                 algo=algo,
                 fdata=fdata,
-                pdata=pdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
                 upcast=True,
-                states_source_turbine=states_source_turbine,
-            )
-            ati = ati[sp_sel]
+            )[st_sel]
 
             # calculate sigma:
             # beta = np.sqrt(0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct))
@@ -258,12 +228,12 @@ class TurbOParkWake(GaussianWakeModel):
 
         # case no targets:
         else:
-            sp_sel = np.zeros_like(x, dtype=bool)
-            n_sp = np.sum(sp_sel)
+            st_sel = np.zeros_like(x, dtype=bool)
+            n_sp = np.sum(st_sel)
             ampld = np.zeros(n_sp, dtype=FC.DTYPE)
             sigma = np.zeros(n_sp, dtype=FC.DTYPE)
 
-        return {FV.WS: (ampld, sigma)}, sp_sel
+        return {FV.WS: (ampld, sigma)}, st_sel
 
 
 class TurbOParkWakeIX(GaussianWakeModel):
@@ -309,10 +279,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
 
         Parameters
         ----------
-        superpositions: dict
-            The superpositions. Key: variable name str,
-            value: The wake superposition model name,
-            will be looked up in model book
+        superposition: str
+            The wind deficit superposition
         dx: float
             The step size of the integral
         A: float, optional
@@ -341,8 +309,11 @@ class TurbOParkWakeIX(GaussianWakeModel):
         self.induction = induction
 
     def __repr__(self):
-        s = super().__repr__()
-        s += f"(ti={self.ti_var}, dx={self.dx}, A={self.A}, sp={self.superpositions[FV.WS]})"
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        s = f"{type(self).__name__}({self.superpositions[FV.WS]}"
+        s += f", ti={self.ti_var}, dx={self.dx}, A={self.A}, induction={iname})"
         return s
 
     def sub_models(self):
@@ -375,38 +346,33 @@ class TurbOParkWakeIX(GaussianWakeModel):
             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
-        wake_deltas[FV.WS] = np.zeros((n_states, pdata.n_points), dtype=FC.DTYPE)
-
-        # find TI wake models:
+        # find TI wake model:
         self._tiwakes = []
-        for w in algo.wake_models:
+        for w in algo.wake_models.values():
             if w is not self:
-                wdel = {}
-                w.init_wake_deltas(algo, mdata, fdata, pdata, wdel)
+                wdel = w.new_wake_deltas(algo, mdata, fdata, tdata)
                 if self.ti_var in wdel:
                     self._tiwakes.append(w)
         if self.ti_var not in FV.amb2var and len(self._tiwakes) == 0:
@@ -414,13 +380,15 @@ class TurbOParkWakeIX(GaussianWakeModel):
                 f"Model '{self.name}': Missing wake model that computes wake delta for variable {self.ti_var}"
             )
 
-    def calc_amplitude_sigma_spsel(
+        return super().new_wake_deltas(algo, mdata, fdata, tdata)
+
+    def calc_amplitude_sigma(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
     ):
         """
@@ -431,60 +399,57 @@ class TurbOParkWakeIX(GaussianWakeModel):
         ----------
         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)
 
         """
-
         # get ct:
         ct = self.get_data(
             FV.CT,
-            FC.STATE_POINT,
+            FC.STATE_TARGET,
             lookup="w",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
             upcast=True,
-            states_source_turbine=states_source_turbine,
         )
 
         # select targets:
-        sp_sel = (x > 1e-5) & (ct > 0.0)
-        if np.any(sp_sel):
+        st_sel = (x > 1e-5) & (ct > 0.0)
+        if np.any(st_sel):
             # apply selection:
-            # x = x[sp_sel]
-            ct = ct[sp_sel]
+            # x = x[st_sel]
+            ct = ct[st_sel]
 
             # get D:
             D = self.get_data(
                 FV.D,
-                FC.STATE_POINT,
+                FC.STATE_TARGET,
                 lookup="w",
                 algo=algo,
                 fdata=fdata,
-                pdata=pdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
                 upcast=True,
-                states_source_turbine=states_source_turbine,
-            )
-            D = D[sp_sel]
+            )[st_sel]
 
             # calculate sigma:
             # beta = np.sqrt(0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct))
@@ -498,7 +463,7 @@ class TurbOParkWakeIX(GaussianWakeModel):
                 algo,
                 mdata,
                 fdata,
-                states_source_turbine,
+                downwind_index,
                 [self.ti_var],
                 x,
                 dx=self.dx,
@@ -508,13 +473,8 @@ class TurbOParkWakeIX(GaussianWakeModel):
             )[:, :, 0]
 
             # calculate sigma (eqn 1, plus epsilon from eqn 4 for x = 0)
-            sigma = D * epsilon + self.A * ti_ix[sp_sel]
-
-            del (
-                x,
-                sbeta,
-                epsilon,
-            )
+            sigma = D * epsilon + self.A * ti_ix[st_sel]
+            del x, epsilon
 
             # calculate amplitude, same as in Bastankhah model (eqn 7)
             ct_eff = ct / (8 * (sigma / D) ** 2)
@@ -522,12 +482,12 @@ class TurbOParkWakeIX(GaussianWakeModel):
 
         # case no targets:
         else:
-            sp_sel = np.zeros_like(x, dtype=bool)
-            n_sp = np.sum(sp_sel)
+            st_sel = np.zeros_like(x, dtype=bool)
+            n_sp = np.sum(st_sel)
             ampld = np.zeros(n_sp, dtype=FC.DTYPE)
             sigma = np.zeros(n_sp, dtype=FC.DTYPE)
 
-        return {FV.WS: (ampld, sigma)}, sp_sel
+        return {FV.WS: (ampld, sigma)}, st_sel
 
     def finalize(self, algo, verbosity=0):
         """

foxes/models/wake_superpositions/ti_linear.py

@@ -32,48 +32,54 @@ class TILinear(WakeSuperposition):
         super().__init__()
         self.superp_to_amb = superp_to_amb
 
-    def calc_wakes_plus_wake(
+    def __repr__(self):
+        return f"{type(self).__name__}(superp_to_amb={self.superp_to_amb})"
+
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         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,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         if variable != FV.TI:
@@ -81,7 +87,7 @@ class TILinear(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}"
             )
 
-        wake_delta[sel_sp] += wake_model_result
+        wake_delta[st_sel] += wake_model_result
         return wake_delta
 
     def calc_final_wake_delta(
@@ -89,7 +95,6 @@ class TILinear(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -102,24 +107,25 @@ class TILinear(WakeSuperposition):
         ----------
         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
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         # linear superposition to ambient:

foxes/models/wake_superpositions/ti_max.py

@@ -32,48 +32,54 @@ class TIMax(WakeSuperposition):
         super().__init__()
         self.superp_to_amb = superp_to_amb
 
-    def calc_wakes_plus_wake(
+    def __repr__(self):
+        return f"{type(self).__name__}(superp_to_amb={self.superp_to_amb})"
+
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         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,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         if variable != FV.TI:
@@ -81,7 +87,7 @@ class TIMax(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}"
             )
 
-        wake_delta[sel_sp] = np.maximum(wake_model_result, wake_delta[sel_sp])
+        wake_delta[st_sel] = np.maximum(wake_model_result, wake_delta[st_sel])
         return wake_delta
 
     def calc_final_wake_delta(
@@ -89,7 +95,6 @@ class TIMax(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -102,24 +107,25 @@ class TIMax(WakeSuperposition):
         ----------
         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
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         # linear superposition to ambient: