foxes 0.5.0.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/models/wake_superpositions/ti_linear.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+
+class TILinear(WakeSuperposition):
+    """
+    Linear wake superposition for TI.
+
+    Attributes
+    ----------
+    superp_to_amb: str
+        The method for combining ambient with wake deltas:
+        linear or quadratic
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, superp_to_amb="quadratic"):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        superp_to_amb: str
+            The method for combining ambient with wake deltas:
+            linear or quadratic
+
+        """
+        super().__init__()
+        self.superp_to_amb = superp_to_amb
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+        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)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable != FV.TI:
+            raise ValueError(f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}")
+        
+        wake_delta[sel_sp] += wake_model_result
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        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)
+
+        """
+        # linear superposition to ambient:
+        if self.superp_to_amb == "linear":
+            return wake_delta
+
+        # quadratic superposition to ambient:
+        elif self.superp_to_amb == "quadratic":
+            return np.sqrt(wake_delta**2 + amb_results**2) - amb_results
+
+        # unknown ti delta:
+        else:
+            raise ValueError(
+                f"Unknown superp_to_amb = '{self.superp_to_amb}', valid choices: linear, quadratic"
+            )

foxes/models/wake_superpositions/ti_max.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+
+class TIMax(WakeSuperposition):
+    """
+    Max wake superposition for TI.
+
+    Attributes
+    ----------
+    superp_to_amb: str
+        The method for combining ambient with wake deltas:
+        linear or quadratic
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, superp_to_amb="quadratic"):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        superp_to_amb: str
+            The method for combining ambient with wake deltas:
+            linear or quadratic
+
+        """
+        super().__init__()
+        self.superp_to_amb = superp_to_amb
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+        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)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable != FV.TI:
+            raise ValueError(f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}")
+        
+        wake_delta[sel_sp] = np.maximum(wake_model_result, wake_delta[sel_sp])
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        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)
+
+        """
+        # linear superposition to ambient:
+        if self.superp_to_amb == "linear":
+            return wake_delta
+
+        # quadratic superposition to ambient:
+        elif self.superp_to_amb == "quadratic":
+            return np.sqrt(wake_delta**2 + amb_results**2) - amb_results
+
+        # unknown ti delta:
+        else:
+            raise ValueError(
+                f"Unknown superp_to_amb = '{self.superp_to_amb}', valid choices: linear, quadratic"
+            )

foxes/models/wake_superpositions/{ti_superp.py → ti_pow.py}

@@ -1,16 +1,16 @@
 import numpy as np
 
 from foxes.core import WakeSuperposition
+import foxes.variables as FV
 
-
-class TISuperposition(WakeSuperposition):
+class TIPow(WakeSuperposition):
     """
-    A collection of superpositions for TI.
+    Power wake superposition for TI.
 
     Attributes
     ----------
-    ti_superp: str
-        The method choice: linear, quadratic, power_N, max
+    pow: float
+        The power to which to take the wake results
     superp_to_amb: str
         The method for combining ambient with wake deltas:
         linear or quadratic
@@ -19,22 +19,21 @@ class TISuperposition(WakeSuperposition):
 
     """
 
-    def __init__(self, ti_superp, superp_to_amb="quadratic"):
+    def __init__(self, pow, superp_to_amb="quadratic"):
         """
         Constructor.
 
         Parameters
         ----------
-        ti_superp: str
-            The method choice: linear, quadratic, power_N, max
+        pow: float
+            The power to which to take the wake results
         superp_to_amb: str
             The method for combining ambient with wake deltas:
             linear or quadratic
 
         """
         super().__init__()
-
-        self.ti_superp = ti_superp
+        self.pow = pow
         self.superp_to_amb = superp_to_amb
 
     def calc_wakes_plus_wake(
@@ -81,31 +80,10 @@ class TISuperposition(WakeSuperposition):
             The updated wake deltas, shape: (n_states, n_points)
 
         """
-
-        # superposition of every turbines efect at each target point
-        # linear ti delta:
-        if self.ti_superp == "linear":
-            wake_delta[sel_sp] += wake_model_result
-
-        # quadratic ti delta:
-        elif self.ti_superp == "quadratic":
-            wake_delta[sel_sp] += wake_model_result**2
-
-        # power_N delta:
-        elif len(self.ti_superp) > 6 and self.ti_superp[:6] == "power_":
-            N = int(self.ti_superp[6:])
-            wake_delta[sel_sp] += wake_model_result**N
-
-        # max ti delta:
-        elif self.ti_superp == "max":
-            wake_delta[sel_sp] = np.maximum(wake_model_result, wake_delta[sel_sp])
-
-        # unknown ti delta:
-        else:
-            raise ValueError(
-                f"Unknown ti_superp = '{self.ti_superp}', valid choices: linear, quadratic, power_N, max"
-            )
-
+        if variable != FV.TI:
+            raise ValueError(f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}")
+        
+        wake_delta[sel_sp] += wake_model_result**self.pow
         return wake_delta
 
     def calc_final_wake_delta(
@@ -148,31 +126,11 @@ class TISuperposition(WakeSuperposition):
         """
         # linear superposition to ambient:
         if self.superp_to_amb == "linear":
-            if self.ti_superp == "linear" or self.ti_superp == "max":
-                return wake_delta
-            elif self.ti_superp == "quadratic":
-                return np.sqrt(wake_delta)
-            elif len(self.ti_superp) > 6 and self.ti_superp[:6] == "power_":
-                N = int(self.ti_superp[6:])
-                return wake_delta ** (1 / N)
-            else:
-                raise ValueError(
-                    f"Unknown ti_superp = '{self.ti_superp}', valid choices: linear, quadratic, power_N, max"
-                )
+            return wake_delta ** (1/self.pow)
 
         # quadratic superposition to ambient:
         elif self.superp_to_amb == "quadratic":
-            if self.ti_superp == "linear" or self.ti_superp == "max":
-                return np.sqrt(wake_delta**2 + amb_results**2) - amb_results
-            elif self.ti_superp == "quadratic":
-                return np.sqrt(wake_delta + amb_results**2) - amb_results
-            elif len(self.ti_superp) > 6 and self.ti_superp[:6] == "power_":
-                N = int(self.ti_superp[6:])
-                return np.sqrt(wake_delta ** (2 / N) + amb_results**2) - amb_results
-            else:
-                raise ValueError(
-                    f"Unknown ti_superp = '{self.ti_superp}', valid choices: linear, quadratic, power_N, max"
-                )
+            return np.sqrt(wake_delta **(2/self.pow) + amb_results**2) - amb_results
 
         # unknown ti delta:
         else:

foxes/models/wake_superpositions/ti_quadratic.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+
+class TIQuadratic(WakeSuperposition):
+    """
+    Quadratic wake superposition for TI.
+
+    Attributes
+    ----------
+    superp_to_amb: str
+        The method for combining ambient with wake deltas:
+        linear or quadratic
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, superp_to_amb="quadratic"):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        superp_to_amb: str
+            The method for combining ambient with wake deltas:
+            linear or quadratic
+
+        """
+        super().__init__()
+        self.superp_to_amb = superp_to_amb
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+        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)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable != FV.TI:
+            raise ValueError(f"Superposition '{self.name}': Expecting wake variable {FV.TI}, got {variable}")
+        
+        wake_delta[sel_sp] += wake_model_result**2
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        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)
+
+        """
+        # linear superposition to ambient:
+        if self.superp_to_amb == "linear":
+            return np.sqrt(wake_delta)
+
+        # quadratic superposition to ambient:
+        elif self.superp_to_amb == "quadratic":
+            return np.sqrt(wake_delta + amb_results**2) - amb_results
+
+        # unknown ti delta:
+        else:
+            raise ValueError(
+                f"Unknown superp_to_amb = '{self.superp_to_amb}', valid choices: linear, quadratic"
+            )

foxes/models/wake_superpositions/ws_linear.py

@@ -0,0 +1,170 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+import foxes.constants as FC
+
+class WSLinear(WakeSuperposition):
+    """
+    Linear supersposition of wind deficit results
+
+    Attributes
+    ----------
+    scale_amb: bool
+        Flag for scaling wind deficit with ambient wind speed
+        instead of waked wind speed
+    lim_low: float
+        Lower limit of the final waked wind speed
+    lim_high: float
+        Upper limit of the final waked wind speed
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, scale_amb=False, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        scale_amb: bool
+            Flag for scaling wind deficit with ambient wind speed
+            instead of waked wind speed
+        lim_low: float
+            Lower limit of the final waked wind speed
+        lim_high: float
+            Upper limit of the final waked wind speed
+
+        """
+        super().__init__()
+
+        self.scale_amb = scale_amb
+        self.lim_low = lim_low
+        self.lim_high = lim_high
+
+    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 calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+        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)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
+            raise ValueError(f"Superposition '{self.name}': Expecting wind speed variable, got {variable}")
+        
+        if np.any(sel_sp):
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_POINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                pdata=pdata,
+                upcast=True,
+                states_source_turbine=states_source_turbine,
+            )[sel_sp]
+
+            wake_delta[sel_sp] += scale * wake_model_result
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        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)
+
+        """
+        w = wake_delta
+        if self.lim_low is not None:
+            w = np.maximum(w, self.lim_low - amb_results)
+        if self.lim_high is not None:
+            w = np.minimum(w, self.lim_high - amb_results)
+        return w