foxes 0.7.0.6__py3-none-any.whl → 0.7.2__py3-none-any.whl

foxes/models/wake_models/wind/bastankhah14.py

@@ -18,7 +18,7 @@ class Bastankhah2014(GaussianWakeModel):
 
     Attributes
     ----------
-    k: float, optional
+    k: float
         The wake growth parameter k. If not given here
         it will be searched in the farm data.
     sbeta_factor: float

foxes/models/wake_models/wind/turbopark.py

@@ -18,8 +18,8 @@ class TurbOParkWake(GaussianWakeModel):
 
     Attributes
     ----------
-    A: float
-        The wake growth parameter A.
+    k: float
+        The wake growth parameter k.
     sbeta_factor: float
         Factor multiplying sbeta
     c1: float
@@ -36,10 +36,11 @@ class TurbOParkWake(GaussianWakeModel):
     def __init__(
         self,
         superposition,
-        A,
+        k=None,
         sbeta_factor=0.25,
         c1=1.5,
         c2=0.8,
+        k_var=FV.K,
         induction="Madsen",
     ):
         """
@@ -49,32 +50,43 @@ class TurbOParkWake(GaussianWakeModel):
         ----------
         superposition: str
             The wind deficit superposition
-        A: float
-            The wake growth parameter A.
+        k: float, optional
+            The wake growth parameter k. If not given here
+            it will be searched in the farm data.
         sbeta_factor: float
             Factor multiplying sbeta
         c1: float
             Factor from Frandsen turbulence model
         c2: float
             Factor from Frandsen turbulence model
+        k_var: str
+            The variable name for k
         induction: foxes.core.AxialInductionModel or str
             The induction model
 
         """
         super().__init__(superpositions={FV.WS: superposition})
 
-        self.A = A
         self.sbeta_factor = sbeta_factor
         self.c1 = c1
         self.c2 = c2
+        self.k_var = k_var
         self.induction = induction
 
+        setattr(self, k_var, k)
+
     def __repr__(self):
+        k = getattr(self, self.k_var)
         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})"
+        s += f"({self.superpositions[FV.WS]}, induction={iname}"
+        if k is None:
+            s += f", k_var={self.k_var}"
+        else:
+            s += f", {self.k_var}={k}"
+        s += ")"
         return s
 
     def sub_models(self):
@@ -188,6 +200,18 @@ class TurbOParkWake(GaussianWakeModel):
                 upcast=True,
             )[st_sel]
 
+            # get k:
+            k = self.get_data(
+                self.k_var,
+                FC.STATE_TARGET,
+                lookup="sw",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=True,
+            )[st_sel]
+
             # calculate sigma:
             # beta = np.sqrt(0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct))
             a = self.induction.ct2a(ct)
@@ -201,7 +225,7 @@ class TurbOParkWake(GaussianWakeModel):
             # calculate sigma (eqn 4)
             sigma = D * (
                 epsilon
-                + self.A
+                + k
                 * ati
                 / beta
                 * (
@@ -246,10 +270,12 @@ class TurbOParkWakeIX(GaussianWakeModel):
     ----------
     dx: float
         The step size of the integral
-    A: float
-        The wake growth parameter A.
+    k: float
+        The wake growth parameter k.
     sbeta_factor: float
         Factor multiplying sbeta
+    k_var: str
+        The variable name for k
     ti_var:  str
         The TI variable
     self_wake: bool
@@ -267,8 +293,9 @@ class TurbOParkWakeIX(GaussianWakeModel):
         self,
         superposition,
         dx,
-        A,
+        k=None,
         sbeta_factor=0.25,
+        k_var=FV.K,
         ti_var=FV.TI,
         self_wake=True,
         induction="Madsen",
@@ -283,10 +310,13 @@ class TurbOParkWakeIX(GaussianWakeModel):
             The wind deficit superposition
         dx: float
             The step size of the integral
-        A: float, optional
-            The wake growth parameter A.
+        k: float, optional
+            The wake growth parameter k. If not given here
+            it will be searched in the farm data.
         sbeta_factor: float
             Factor multiplying sbeta
+        k_var: str
+            The variable name for k
         ti_var:  str
             The TI variable
         self_wake: bool
@@ -300,20 +330,28 @@ class TurbOParkWakeIX(GaussianWakeModel):
         super().__init__(superpositions={FV.WS: superposition})
 
         self.dx = dx
-        self.A = A
         self.sbeta_factor = sbeta_factor
+        self.k_var = k_var
         self.ti_var = ti_var
         self.ipars = ipars
         self._tiwakes = None
         self.self_wake = self_wake
         self.induction = induction
 
+        setattr(self, k_var, k)
+
     def __repr__(self):
+        k = getattr(self, self.k_var)
         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})"
+        s = f"{type(self).__name__}"
+        s += f"({self.superpositions[FV.WS]}, induction={iname}, dx={self.dx}"
+        if k is None:
+            s += f", k_var={self.k_var}"
+        else:
+            s += f", {self.k_var}={k}"
+        s += f", ti_var={self.ti_var})"
         return s
 
     def sub_models(self):
@@ -451,6 +489,18 @@ class TurbOParkWakeIX(GaussianWakeModel):
                 upcast=True,
             )[st_sel]
 
+            # get k:
+            k = self.get_data(
+                self.k_var,
+                FC.STATE_TARGET,
+                lookup="sw",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=True,
+            )[st_sel]
+
             # calculate sigma:
             # beta = np.sqrt(0.5 * (1 + np.sqrt(1.0 - ct)) / np.sqrt(1.0 - ct))
             a = self.induction.ct2a(ct)
@@ -473,7 +523,7 @@ class TurbOParkWakeIX(GaussianWakeModel):
             )[:, :, 0]
 
             # calculate sigma (eqn 1, plus epsilon from eqn 4 for x = 0)
-            sigma = D * epsilon + self.A * ti_ix[st_sel]
+            sigma = D * epsilon + k * ti_ix[st_sel]
             del x, epsilon
 
             # calculate amplitude, same as in Bastankhah model (eqn 7)

foxes/models/wake_superpositions/__init__.py

@@ -2,10 +2,10 @@
 Wake superposition models.
 """
 
-from .ws_linear import WSLinear
-from .ws_quadratic import WSQuadratic
-from .ws_pow import WSPow
-from .ws_max import WSMax
+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

foxes/models/wake_superpositions/ws_linear.py

@@ -178,3 +178,159 @@ class WSLinear(WakeSuperposition):
         if self.lim_high is not None:
             w = np.minimum(w, self.lim_high - amb_results)
         return w
+
+
+class WSLinearLocal(WakeSuperposition):
+    """
+    Local linear supersposition of wind deficit results
+
+    Attributes
+    ----------
+    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, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        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.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def __repr__(self):
+        a = f"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
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return []
+
+    def add_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        st_sel,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta 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 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_targets, n_tpoints, ...)
+        wake_model_result: numpy.ndarray
+            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_targets, n_tpoints, ...)
+
+        """
+        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(st_sel):
+            wake_delta[st_sel] += wake_model_result
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        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.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm 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)
+
+        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_targets, n_tpoints)
+
+        """
+        w = wake_delta * amb_results
+        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

foxes/models/wake_superpositions/ws_max.py

@@ -181,3 +181,162 @@ class WSMax(WakeSuperposition):
         if self.lim_high is not None:
             w = np.minimum(w, self.lim_high - amb_results)
         return w
+
+
+class WSMaxLocal(WakeSuperposition):
+    """
+    Local max supersposition of wind deficit results
+
+    Attributes
+    ----------
+    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, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        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.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def __repr__(self):
+        a = f"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
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return []
+
+    def add_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        st_sel,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta 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 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_targets, n_tpoints, ...)
+        wake_model_result: numpy.ndarray
+            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_targets, n_tpoints, ...)
+
+        """
+        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(st_sel):
+            wake_model_result = np.abs(wake_model_result)
+            odelta = wake_delta[st_sel]
+
+            wake_delta[st_sel] = np.maximum(odelta, wake_model_result)
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        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.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm 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)
+
+        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_targets, n_tpoints)
+
+        """
+        w = -wake_delta * amb_results
+        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

foxes/models/wake_superpositions/ws_pow.py

@@ -183,3 +183,165 @@ class WSPow(WakeSuperposition):
         if self.lim_high is not None:
             w = np.minimum(w, self.lim_high - amb_results)
         return w
+
+
+class WSPowLocal(WakeSuperposition):
+    """
+    Local power supersposition of wind deficit results
+
+    Attributes
+    ----------
+    pow: float
+        The power to which to take the wake results
+    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, pow, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        pow: float
+            The power to which to take the wake results
+        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.pow = pow
+        self.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def __repr__(self):
+        a = f"pow={self.pow}, 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
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return []
+
+    def add_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        st_sel,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta 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 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_targets, n_tpoints, ...)
+        wake_model_result: numpy.ndarray
+            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_targets, n_tpoints, ...)
+
+        """
+        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(st_sel):
+            wake_delta[st_sel] += np.abs(wake_model_result) ** self.pow
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        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.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm 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)
+
+        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_targets, n_tpoints)
+
+        """
+        w = -(wake_delta ** (1 / self.pow)) * amb_results
+        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