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

foxes/models/wake_models/wind/bastankhah16.py

@@ -447,7 +447,7 @@ class Bastankhah2016(DistSlicedWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition})
+        super().__init__(wind_superposition=superposition)
 
         self.model = None
         self.alpha = alpha
@@ -460,10 +460,23 @@ class Bastankhah2016(DistSlicedWakeModel):
     def __repr__(self):
         iname = self.induction
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
+
     def sub_models(self):
         """
         List of all sub-models
@@ -474,7 +487,7 @@ class Bastankhah2016(DistSlicedWakeModel):
             Names of all sub models
 
         """
-        return [self.wake_k, self.model]
+        return super().sub_models() + [self.wake_k, self.model]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -621,4 +634,23 @@ class Bastankhah2016(DistSlicedWakeModel):
                     * np.exp(-0.5 * (z / sigma_z) ** 2)
                 )
 
+        # wake deflection causes wind vector rotation:
+        if FC.WDEFL_ROT_ANGLE in tdata:
+            dwd_defl = tdata.pop(FC.WDEFL_ROT_ANGLE)
+            if FV.WD not in wdeltas:
+                wdeltas[FV.WD] = np.zeros_like(wdeltas[FV.WS])
+                wdeltas[FV.WD][:] = dwd_defl[st_sel]
+            else:
+                wdeltas[FV.WD] += dwd_defl[st_sel]
+
+        # wake deflection causes wind speed reduction:
+        if FC.WDEFL_DWS_FACTOR in tdata:
+            dws_defl = tdata.pop(FC.WDEFL_DWS_FACTOR)
+            if FV.WS not in wdeltas:
+                raise AssertionError(
+                    f"Wake model '{self.name}': Expecting '{FV.WS}' in wdeltas, found {list(wdeltas.keys())}"
+                )
+            else:
+                wdeltas[FV.WS] *= dws_defl[st_sel]
+
         return wdeltas, st_sel

foxes/models/wake_models/wind/jensen.py

@@ -31,7 +31,7 @@ class JensenWake(TopHatWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition}, induction=induction)
+        super().__init__(wind_superposition=superposition, induction=induction)
         self.wake_k = WakeK(**wake_k)
 
     def __repr__(self):
@@ -39,10 +39,23 @@ class JensenWake(TopHatWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
+
     def calc_wake_radius(
         self,
         algo,

foxes/models/wake_models/wind/turbopark.py

@@ -63,7 +63,7 @@ class TurbOParkWake(GaussianWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition})
+        super().__init__(wind_superposition=superposition)
 
         self.sbeta_factor = sbeta_factor
         self.c1 = c1
@@ -76,10 +76,23 @@ class TurbOParkWake(GaussianWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
+
     def sub_models(self):
         """
         List of all sub-models
@@ -329,6 +342,19 @@ class TurbOParkWakeIX(GaussianWakeModel):
         s += self.wake_k.repr() + ")"
         return s
 
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
+
     def sub_models(self):
         """
         List of all sub-models

foxes/models/wake_superpositions/__init__.py

@@ -2,12 +2,21 @@
 Wake superposition models.
 """
 
-from .ws_linear import WSLinear, WSLinearLocal
-from .ws_quadratic import WSQuadratic, WSQuadraticLocal
-from .ws_pow import WSPow, WSPowLocal
-from .ws_max import WSMax, WSMaxLocal
-from .ws_product import WSProduct
-from .ti_linear import TILinear
-from .ti_quadratic import TIQuadratic
-from .ti_pow import TIPow
-from .ti_max import TIMax
+from .ws_linear import WSLinear as WSLinear
+from .ws_linear import WSLinearLocal as WSLinearLocal
+
+from .ws_pow import WSPow as WSPow
+from .ws_pow import WSPowLocal as WSPowLocal
+
+from .ws_max import WSMax as WSMax
+from .ws_max import WSMaxLocal as WSMaxLocal
+
+from .ws_quadratic import WSQuadratic as WSQuadratic
+from .ws_quadratic import WSQuadraticLocal as WSQuadraticLocal
+
+from .wind_vector import WindVectorLinear as WindVectorLinear
+from .ws_product import WSProduct as WSProduct
+from .ti_linear import TILinear as TILinear
+from .ti_quadratic import TIQuadratic as TIQuadratic
+from .ti_pow import TIPow as TIPow
+from .ti_max import TIMax as TIMax

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)