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

foxes/models/wake_superpositions/ti_pow.py

@@ -37,48 +37,56 @@ class TIPow(WakeSuperposition):
         self.pow = pow
         self.superp_to_amb = superp_to_amb
 
-    def calc_wakes_plus_wake(
+    def __repr__(self):
+        return (
+            f"{type(self).__name__}(pow={self.pow}, 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:
@@ -86,7 +94,7 @@ class TIPow(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}"
             )
 
-        wake_delta[sel_sp] += wake_model_result**self.pow
+        wake_delta[st_sel] += wake_model_result**self.pow
         return wake_delta
 
     def calc_final_wake_delta(
@@ -94,7 +102,6 @@ class TIPow(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -107,24 +114,25 @@ class TIPow(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_quadratic.py

@@ -32,48 +32,54 @@ class TIQuadratic(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 TIQuadratic(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}"
             )
 
-        wake_delta[sel_sp] += wake_model_result**2
+        wake_delta[st_sel] += wake_model_result**2
         return wake_delta
 
     def calc_final_wake_delta(
@@ -89,7 +95,6 @@ class TIQuadratic(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -102,24 +107,25 @@ class TIQuadratic(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/ws_linear.py

@@ -44,6 +44,10 @@ class WSLinear(WakeSuperposition):
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def __repr__(self):
+        a = f"scale_amb={self.scale_amb}, lim_low={self.lim_low}, lim_high={self.lim_high}"
+        return f"{type(self).__name__}({a})"
+
     def input_farm_vars(self, algo):
         """
         The variables which are needed for running
@@ -62,48 +66,51 @@ class WSLinear(WakeSuperposition):
         """
         return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
 
-    def calc_wakes_plus_wake(
+    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 not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
@@ -111,19 +118,19 @@ class WSLinear(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wind speed variable, got {variable}"
             )
 
-        if np.any(sel_sp):
+        if np.any(st_sel):
             scale = self.get_data(
                 FV.AMB_REWS if self.scale_amb else FV.REWS,
-                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,
-            )[sel_sp]
+            )[st_sel, None]
 
-            wake_delta[sel_sp] += scale * wake_model_result
+            wake_delta[st_sel] += scale * wake_model_result
 
         return wake_delta
 
@@ -132,7 +139,6 @@ class WSLinear(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -145,24 +151,25 @@ class WSLinear(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)
 
         """
         w = wake_delta

foxes/models/wake_superpositions/ws_max.py

@@ -44,6 +44,10 @@ class WSMax(WakeSuperposition):
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def __repr__(self):
+        a = f"scale_amb={self.scale_amb}, lim_low={self.lim_low}, lim_high={self.lim_high}"
+        return f"{type(self).__name__}({a})"
+
     def input_farm_vars(self, algo):
         """
         The variables which are needed for running
@@ -62,48 +66,51 @@ class WSMax(WakeSuperposition):
         """
         return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
 
-    def calc_wakes_plus_wake(
+    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 not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
@@ -111,22 +118,22 @@ class WSMax(WakeSuperposition):
                 f"Superposition '{self.name}': Expecting wind speed variable, got {variable}"
             )
 
-        if np.any(sel_sp):
+        if np.any(st_sel):
             scale = self.get_data(
                 FV.AMB_REWS if self.scale_amb else FV.REWS,
-                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,
-            )[sel_sp]
+            )[st_sel, None]
 
             wake_model_result = np.abs(scale * wake_model_result)
-            odelta = wake_delta[sel_sp]
+            odelta = wake_delta[st_sel]
 
-            wake_delta[sel_sp] = np.maximum(odelta, wake_model_result)
+            wake_delta[st_sel] = np.maximum(odelta, wake_model_result)
 
         return wake_delta
 
@@ -135,7 +142,6 @@ class WSMax(WakeSuperposition):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -148,24 +154,25 @@ class WSMax(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)
 
         """
         w = -wake_delta