foxes 1.2.5__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/models/wake_superpositions/ti_linear.py

@@ -95,8 +95,8 @@ class TILinear(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -111,11 +111,10 @@ class TILinear(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -134,6 +133,7 @@ class TILinear(WakeSuperposition):
 
         # quadratic superposition to ambient:
         elif self.superp_to_amb == "quadratic":
+            amb_results = tdata[FV.var2amb[variable]]
             return np.sqrt(wake_delta**2 + amb_results**2) - amb_results
 
         # unknown ti delta:

foxes/models/wake_superpositions/ti_max.py

@@ -95,8 +95,8 @@ class TIMax(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -111,11 +111,10 @@ class TIMax(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -134,6 +133,7 @@ class TIMax(WakeSuperposition):
 
         # quadratic superposition to ambient:
         elif self.superp_to_amb == "quadratic":
+            amb_results = tdata[FV.var2amb[variable]]
             return np.sqrt(wake_delta**2 + amb_results**2) - amb_results
 
         # unknown ti delta:

foxes/models/wake_superpositions/ti_pow.py

@@ -102,8 +102,8 @@ class TIPow(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -118,11 +118,10 @@ class TIPow(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -141,6 +140,7 @@ class TIPow(WakeSuperposition):
 
         # quadratic superposition to ambient:
         elif self.superp_to_amb == "quadratic":
+            amb_results = tdata[FV.var2amb[variable]]
             return np.sqrt(wake_delta ** (2 / self.pow) + amb_results**2) - amb_results
 
         # unknown ti delta:

foxes/models/wake_superpositions/ti_quadratic.py

@@ -95,8 +95,8 @@ class TIQuadratic(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -111,11 +111,10 @@ class TIQuadratic(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -134,6 +133,7 @@ class TIQuadratic(WakeSuperposition):
 
         # quadratic superposition to ambient:
         elif self.superp_to_amb == "quadratic":
+            amb_results = tdata[FV.var2amb[variable]]
             return np.sqrt(wake_delta + amb_results**2) - amb_results
 
         # unknown ti delta:

foxes/models/wake_superpositions/wind_vector.py

@@ -0,0 +1,257 @@
+import numpy as np
+
+from foxes.core import WindVectorWakeSuperposition
+from foxes.utils import wd2uv, uv2wd, delta_wd
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class WindVectorLinear(WindVectorWakeSuperposition):
+    """
+    Linear superposition of wind deficit vector results
+
+    Attributes
+    ----------
+    scale_amb: bool
+        Flag for scaling wind deficit with ambient wind speed
+        instead of waked wind speed
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, scale_amb=False):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        scale_amb: bool
+            Flag for scaling wind deficit with ambient wind speed
+            instead of waked wind speed
+
+        """
+        super().__init__()
+        self.scale_amb = scale_amb
+
+    def __repr__(self):
+        a = f"scale_amb={self.scale_amb}"
+        return f"{type(self).__name__}({a})"
+
+    def input_farm_vars(self, algo):
+        """
+        The variables which are needed for running
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
+
+    def wdeltas_ws2uv(self, algo, fdata, tdata, downwind_index, wdeltas, st_sel):
+        """
+        Transform results from wind speed to wind vector data
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        wdeltas: dict
+            The wake deltas. Key: variable name str,
+            value: numpy.ndarray, shape: (n_st_sel, n_tpoints)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
+
+        Returns
+        -------
+        wdeltas: dict
+            The wake deltas. Key: variable name str,
+            value: numpy.ndarray, now respecting has_uv flag
+
+        """
+        if FV.AMB_UV not in tdata:
+            tdata[FV.AMB_UV] = wd2uv(tdata[FV.AMB_WD], tdata[FV.AMB_WS])
+        if FV.UV not in wdeltas:
+            assert FV.WS in wdeltas, (
+                f"{self.name}: Expecting '{FV.WS}' in wdeltas, got {list(wdeltas.keys())}"
+            )
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_TARGET_TPOINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=False,
+                selection=st_sel,
+            )
+            ws0 = tdata[FV.AMB_WS][st_sel]
+            wd0 = tdata[FV.AMB_WD][st_sel]
+            dws = scale * wdeltas.pop(FV.WS)
+            dwd = wdeltas.pop(FV.WD, 0)
+            wdeltas[FV.UV] = wd2uv(wd0 + dwd, ws0 + dws) - tdata[FV.AMB_UV][st_sel]
+
+        return wdeltas
+
+    def wdeltas_uv2ws(self, algo, fdata, tdata, downwind_index, wdeltas, st_sel):
+        """
+        Transform results from wind vector to wind speed data
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        wdeltas: dict
+            The wake deltas. Key: variable name str,
+            value: numpy.ndarray, shape: (n_st_sel, n_tpoints)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
+
+        Returns
+        -------
+        wdeltas: dict
+            The wake deltas. Key: variable name str,
+            value: numpy.ndarray, now respecting has_uv flag
+
+        """
+        if FV.UV in wdeltas:
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_TARGET_TPOINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=False,
+                selection=st_sel,
+            )
+            ws0 = tdata[FV.AMB_WS][st_sel]
+            wd0 = tdata[FV.AMB_WD][st_sel]
+            uv = tdata[FV.AMB_UV][st_sel] + wdeltas.pop(FV.UV)
+            wdeltas[FV.WD] = delta_wd(wd0, uv2wd(uv))
+            wdeltas[FV.WS] = (np.linalg.norm(uv, axis=-1) - ws0) / scale
+
+        return wdeltas
+
+    def add_wake_vector(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        st_sel,
+        wake_delta_uv,
+        wake_model_result_uv,
+    ):
+        """
+        Add a wake delta vector to previous wake deltas,
+        at rotor points.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
+        wake_delta_uv: numpy.ndarray
+            The original wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, 2)
+        wake_model_result_uv: numpy.ndarray
+            The new wind vector wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, 2, ...)
+
+        Returns
+        -------
+        wdelta_uv: numpy.ndarray
+            The updated wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
+
+        """
+
+        if np.any(st_sel):
+            wake_delta_uv[st_sel] += wake_model_result_uv
+
+        return wake_delta_uv
+
+    def calc_final_wake_delta_uv(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        wake_delta_uv,
+    ):
+        """
+        Calculate the final wind vector wake delta after adding all
+        contributions.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        wake_delta_uv: numpy.ndarray
+            The original wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, 2)
+
+        Returns
+        -------
+        final_wake_delta_ws: numpy.ndarray
+            The final wind speed wake delta, which will be added to
+            the ambient results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
+        final_wake_delta_wd: numpy.ndarray
+            The final wind direction wake delta, which will be added to
+            the ambient results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
+
+        """
+        if FV.AMB_UV not in tdata:
+            tdata[FV.AMB_UV] = wd2uv(tdata[FV.AMB_WD], tdata[FV.AMB_WS])
+
+        uv = tdata[FV.AMB_UV] + wake_delta_uv
+        dwd = delta_wd(tdata[FV.AMB_WD], uv2wd(uv))
+        dws = np.linalg.norm(uv, axis=-1) - tdata[FV.AMB_WS]
+
+        return dws, dwd

foxes/models/wake_superpositions/ws_linear.py

@@ -140,8 +140,8 @@ class WSLinear(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -156,11 +156,10 @@ class WSLinear(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -175,9 +174,9 @@ class WSLinear(WakeSuperposition):
         """
         w = wake_delta
         if self.lim_low is not None:
-            w = np.maximum(w, self.lim_low - amb_results)
+            w = np.maximum(w, self.lim_low - tdata[FV.var2amb[variable]])
         if self.lim_high is not None:
-            w = np.minimum(w, self.lim_high - amb_results)
+            w = np.minimum(w, self.lim_high - tdata[FV.var2amb[variable]])
         return w
 
 
@@ -296,8 +295,8 @@ class WSLinearLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -312,11 +311,10 @@ class WSLinearLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -329,6 +327,7 @@ class WSLinearLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = wake_delta * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_max.py

@@ -143,8 +143,8 @@ class WSMax(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -159,11 +159,10 @@ class WSMax(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -176,6 +175,7 @@ class WSMax(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -wake_delta
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)
@@ -302,8 +302,8 @@ class WSMaxLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -318,11 +318,10 @@ class WSMaxLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -335,6 +334,7 @@ class WSMaxLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -wake_delta * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_pow.py

@@ -145,8 +145,8 @@ class WSPow(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -161,11 +161,10 @@ class WSPow(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -178,6 +177,7 @@ class WSPow(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -(wake_delta ** (1 / self.pow))
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)
@@ -307,8 +307,8 @@ class WSPowLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -323,11 +323,10 @@ class WSPowLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -340,6 +339,7 @@ class WSPowLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -(wake_delta ** (1 / self.pow)) * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_product.py

@@ -131,8 +131,8 @@ class WSProduct(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -147,11 +147,10 @@ class WSProduct(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -164,6 +163,7 @@ class WSProduct(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = amb_results * (wake_delta - 1)
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)

foxes/models/wake_superpositions/ws_quadratic.py

@@ -140,8 +140,8 @@ class WSQuadratic(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -156,11 +156,10 @@ class WSQuadratic(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -173,6 +172,7 @@ class WSQuadratic(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -np.sqrt(wake_delta)
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)
@@ -296,8 +296,8 @@ class WSQuadraticLocal(WakeSuperposition):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -312,11 +312,10 @@ class WSQuadraticLocal(WakeSuperposition):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -329,6 +328,7 @@ class WSQuadraticLocal(WakeSuperposition):
             (n_states, n_targets, n_tpoints)
 
         """
+        amb_results = tdata[FV.var2amb[variable]]
         w = -np.sqrt(wake_delta) * amb_results
         if self.lim_low is not None:
             w = np.maximum(w, self.lim_low - amb_results)