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

foxes/models/turbine_types/PCt_from_two.py

@@ -123,6 +123,7 @@ class PCtFromTwo(TurbineType):
 
     def __repr__(self):
         a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}, rho={self.rho}"
+        a += f", var_ws_ct={self.WSCT}, var_ws_P={self.WSP}"
         return f"{type(self).__name__}({a})"
 
     def output_farm_vars(self, algo):
@@ -196,6 +197,97 @@ class PCtFromTwo(TurbineType):
 
         return super().load_data(algo, verbosity)
 
+    def modify_cutin(
+        self,
+        modify_ct,
+        modify_P,
+        steps=20,
+        iterations=100,
+        a=0.55,
+        b=0.55,
+    ):
+        """
+        Modify the data such that a discontinuity
+        at cutin wind speed is avoided
+
+        Parameters
+        ----------
+        variable: str
+            The target variable
+        modify_ct: bool
+            Flag for modification of the ct curve
+        modify_P: bool
+            Flag for modification of the power curve
+        steps: int
+            The number of wind speed steps between 0 and
+            the cutin wind speed
+        iterations: int
+            The number of iterations
+        a: float
+            Coefficient for iterative mixing
+        b: float
+            Coefficient for iterative mixing
+
+        """
+        if modify_ct:
+
+            ws = self._data_ws_ct
+            ct = self._data_ct
+
+            i = 0
+            try:
+                while i < len(ws) and (not modify_ct or ct[i] < 1e-5):
+                    i += 1
+            except IndexError:
+                raise IndexError(
+                    f"Turbine type '{self.name}': Failed not determine cutin wind speed. ws = {ws}, ct = {ct}"
+                )
+
+            if ws[i] > 0:
+                ws = ws[i:]
+                ct = ct[i:]
+
+                new_ws = np.linspace(0.0, ws[0], steps + 1, dtype=ws.dtype)
+                new_ct = np.zeros_like(new_ws)
+
+                new_ct[-1] = ct[0]
+                for it in range(iterations):
+                    new_ct[1:-1] = a * new_ct[:-2] + (1 - a) * new_ct[2:]
+
+                self._data_ws_ct = np.concatenate([new_ws[:-1], ws], axis=0)
+                self._data_ct = np.concatenate([new_ct[:-1], ct], axis=0)
+
+        if modify_P:
+
+            ws = self._data_ws_P
+            P = self._data_P
+
+            i = 0
+            try:
+                while i < len(ws) and (not modify_P or P[i] < 0.1):
+                    i += 1
+            except IndexError:
+                raise IndexError(
+                    f"Turbine type '{self.name}': Failed not determine cutin wind speed. ws = {ws}, P = {P}"
+                )
+
+            if ws[i] > 0:
+                ws = ws[i:]
+                P = P[i:]
+
+                new_ws = np.linspace(0.0, ws[0], steps + 1, dtype=ws.dtype)
+                new_P = np.zeros_like(new_ws)
+
+                new_P[-1] = P[0]
+                for it in range(iterations):
+                    new_P[1:-1] = b * new_P[:-2] + (1 - b) * new_P[2:]
+
+                self._data_ws_P = np.concatenate([new_ws[:-1], ws], axis=0)
+                self._data_P = np.concatenate([new_P[:-1], P], axis=0)
+
+        if not modify_ct and not modify_P:
+            super().modify_cutin(modify_ct, modify_P)
+
     def calculate(self, algo, mdata, fdata, st_sel):
         """ "
         The main model calculation.

foxes/models/wake_frames/yawed_wakes.py

@@ -1,6 +1,6 @@
 import numpy as np
 
-from foxes.core import WakeFrame
+from foxes.core import WakeFrame, WakeK, TData
 from foxes.models.wake_models.wind.bastankhah16 import (
     Bastankhah2016Model,
     Bastankhah2016,
@@ -28,16 +28,11 @@ class YawedWakes(WakeFrame):
         The model for computing common data
     model_pars: dict
         Model parameters
-    K: float
-        The wake growth parameter k. If not given here
-        it will be searched in the farm data.
     YAWM: float
         The yaw misalignment YAWM. If not given here
         it will be searched in the farm data.
     base_frame: foxes.core.WakeFrame
         The wake frame from which to start
-    k_var: str
-        The variable name for k
 
     :group: models.wake_frames
 
@@ -45,45 +40,46 @@ class YawedWakes(WakeFrame):
 
     def __init__(
         self,
-        k=None,
         base_frame=RotorWD(),
-        k_var=FV.K,
-        **kwargs,
+        alpha=0.58,
+        beta=0.07,
+        induction="Madsen",
+        **wake_k,
     ):
         """
         Constructor.
 
         Parameters
         ----------
-        k: float, optional
-            The wake growth parameter k. If not given here
-            it will be searched in the farm data, by default None
         base_frame: foxes.core.WakeFrame
             The wake frame from which to start
-        k_var: str
-            The variable name for k
-        kwargs: dict, optional
-            Additional parameters for the Bastankhah2016Model,
+        alpha: float
+            model parameter used to determine onset of far wake region,
+            if not found in wake model
+        beta: float
+            model parameter used to determine onset of far wake region,
             if not found in wake model
+        induction: foxes.core.AxialInductionModel or str
+            The induction model, if not found in wake model
+        wake_k: dict, optional
+            Parameters for the WakeK class, if not found in wake model
 
         """
         super().__init__()
 
         self.base_frame = base_frame
         self.model = None
-        self.model_pars = kwargs
-        self.k_var = k_var
+        self.alpha = alpha
+        self.beta = beta
+        self.induction = induction
+        self.wake_k = None
+        self._wake_k_pars = wake_k
 
-        setattr(self, k_var, k)
         setattr(self, FV.YAWM, 0.0)
 
     def __repr__(self):
-        k = getattr(self, self.k_var)
         s = f"{type(self).__name__}("
-        if k is None:
-            s += f"k_var={self.k_var}"
-        else:
-            s += f"{self.k_var}={k}"
+        s += self.wake_k.repr() if self.wake_k is not None else ""
         s += ")"
         return s
 
@@ -97,7 +93,7 @@ class YawedWakes(WakeFrame):
             Names of all sub models
 
         """
-        return [self.base_frame, self.model]
+        return [self.wake_k, self.base_frame, self.model]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -114,20 +110,26 @@ class YawedWakes(WakeFrame):
 
         """
         if not self.initialized:
-            for w in algo.wake_models:
+            for w in algo.wake_models.values():
                 if isinstance(w, Bastankhah2016):
                     if not w.initialized:
                         w.initialize(algo, verbosity, force)
                     self.model = w.model
-                    if w.k_var == self.k_var:
-                        setattr(self, self.k_var, getattr(w, self.k_var))
+                    self.wake_k = w.wake_k
+                    break
             if self.model is None:
-                self.model = Bastankhah2016Model(**self.model_pars)
-            if self.k is None:
-                for w in algo.wake_models:
-                    if hasattr(w, "k_var") and w.k_var == self.k_var:
-                        setattr(self, self.k_var, getattr(w, self.k_var))
-                        break
+                self.model = Bastankhah2016Model(
+                    alpha=self.alpha, beta=self.beta, induction=self.induction
+                )
+            if self.wake_k is None:
+                wake_k = WakeK(**self._wake_k_pars)
+                if not wake_k.all_none:
+                    self.wake_k = wake_k
+                else:
+                    for w in algo.wake_models.values():
+                        if hasattr(w, "wake_k"):
+                            self.wake_k = w.wake_k
+                            break
 
         super().initialize(algo, verbosity, force)
 
@@ -175,10 +177,10 @@ class YawedWakes(WakeFrame):
         gamma *= np.pi / 180
 
         # get k:
-        k = self.get_data(
-            self.k_var,
+        k = self.wake_k(
             FC.STATE_TARGET,
-            lookup="sf",
+            lookup_ti="f",
+            lookup_k="sf",
             algo=algo,
             fdata=fdata,
             tdata=tdata,
@@ -299,6 +301,7 @@ class YawedWakes(WakeFrame):
         points = self.base_frame.get_centreline_points(
             algo, mdata, fdata, downwind_index, x
         )
+        tdata = TData.from_points(points)
 
         nx = np.zeros_like(points)
         nx[:, 0] = points[:, 1] - points[:, 0]
@@ -314,7 +317,7 @@ class YawedWakes(WakeFrame):
         del nx, nz
 
         y = np.zeros_like(x)
-        self._update_y(algo, mdata, fdata, None, downwind_index, x, y)
+        self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
 
         points += y[:, :, None] * ny
 

foxes/models/wake_models/__init__.py

@@ -6,7 +6,6 @@ from .dist_sliced import DistSlicedWakeModel
 from .axisymmetric import AxisymmetricWakeModel
 from .top_hat import TopHatWakeModel
 from .gaussian import GaussianWakeModel
-from .wake_mirror import WakeMirror, GroundMirror
 
 from . import wind
 from . import ti

foxes/models/wake_models/induction/__init__.py

@@ -6,3 +6,4 @@ from .rankine_half_body import RankineHalfBody
 from .rathmann import Rathmann
 from .self_similar import SelfSimilar
 from .self_similar2020 import SelfSimilar2020
+from .vortex_sheet import VortexSheet

foxes/models/wake_models/induction/rankine_half_body.py

@@ -195,7 +195,7 @@ class RankineHalfBody(TurbineInductionModel):
         )
 
         # stagnation point condition
-        xs = -np.sqrt(m / (4 * ws))
+        xs = -np.sqrt(m / (4 * ws + 1e-15))
 
         # set values out of body shape
         st_sel = (ct > 0) & ((RHB_shape < -1) | (x < xs))

foxes/models/wake_models/induction/vortex_sheet.py

@@ -0,0 +1,227 @@
+import numpy as np
+
+from foxes.core import TurbineInductionModel
+from foxes.utils import uv2wd, wd2uv
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class VortexSheet(TurbineInductionModel):
+    """
+    The Vortex Sheet model implemented with a radial dependency
+
+    Ref: Medici, D., et al. "The upstream flow of a wind turbine: blockage effect." Wind Energy 14.5 (2011): 691-697.
+    https://doi.org/10.1002/we.451
+
+    Attributes
+    ----------
+    pre_rotor_only: bool
+        Calculate only the pre-rotor region
+    induction: foxes.core.AxialInductionModel or str
+        The induction model
+
+    :group: models.wake_models.induction
+
+    """
+
+    def __init__(self, pre_rotor_only=False, induction="Madsen"):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        pre_rotor_only: bool
+            Calculate only the pre-rotor region
+        induction: foxes.core.AxialInductionModel or str
+            The induction model
+
+        :group: models.wake_models.induction
+
+        """
+        super().__init__()
+        self.induction = induction
+        self.pre_rotor_only = pre_rotor_only
+
+    def __repr__(self):
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        return f"{type(self).__name__}, induction={iname})"
+
+    def sub_models(self):
+        """
+        List of all sub-models
+
+        Returns
+        -------
+        smdls: list of foxes.core.Model
+            All sub models
+
+        """
+        return [self.induction]
+
+    def initialize(self, algo, verbosity=0, force=False):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
+
+        """
+        if isinstance(self.induction, str):
+            self.induction = algo.mbook.axial_induction[self.induction]
+        super().initialize(algo, verbosity, force)
+
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
+        """
+        Initialize wake delta storage.
+
+        They are added on the fly to the wake_deltas dict.
+
+        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
+        wake_deltas: dict
+            The wake deltas storage, add wake deltas
+            on the fly. Keys: Variable name str, for which the
+            wake delta applies, values: numpy.ndarray with
+            shape (n_states, n_points, ...)
+
+        """
+        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
+
+    def contribute(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        wake_coos,
+        wake_deltas,
+    ):
+        """
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.Data
+            The model data
+        fdata: foxes.core.Data
+            The farm data
+        tdata: foxes.core.Data
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        wake_coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
+
+        """
+
+        # get x, y and z. Rounding for safe x < 0 condition
+        x = np.round(wake_coos[..., 0], 12)
+        y = wake_coos[..., 1]
+        z = wake_coos[..., 2]
+        r = np.sqrt(y**2 + z**2)
+        r_sph = np.sqrt(r**2 + x**2)
+
+        # get ct
+        ct = self.get_data(
+            FV.CT,
+            FC.STATE_TARGET_TPOINT,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            upcast=True,
+            downwind_index=downwind_index,
+        )
+
+        # get ws
+        ws = self.get_data(
+            FV.REWS,
+            FC.STATE_TARGET_TPOINT,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            upcast=True,
+            downwind_index=downwind_index,
+        )
+
+        # get D
+        D = self.get_data(
+            FV.D,
+            FC.STATE_TARGET_TPOINT,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            upcast=True,
+            downwind_index=downwind_index,
+        )
+
+        sp_sel = (ct > 0) & (x <= 0)
+        ws_sel = ws[sp_sel]
+        ct_sel = ct[sp_sel]
+        r_sph_sel = r_sph[sp_sel]
+        D_sel = D[sp_sel]
+
+        if np.any(sp_sel):
+            blockage = (
+                ws_sel
+                * (
+                    1
+                    - self.induction.ct2a(ct_sel)
+                    * ((1 + 2 * r_sph_sel / D_sel) * (1 + (2 * r_sph_sel / D_sel) ** 2))
+                    ** (-0.5)
+                )
+            ) - ws_sel
+            wake_deltas[FV.WS][sp_sel] += blockage
+
+        if not self.pre_rotor_only:
+            sp_sel = (
+                (ct > 0) & (x > 0) & (r > D / 2)
+            )  # mirror in rotor plane and inverse blockage, but not directly behind rotor
+            ws_sel = ws[sp_sel]
+            ct_sel = ct[sp_sel]
+            r_sph_sel = r_sph[sp_sel]
+            D_sel = D[sp_sel]
+            if np.any(sp_sel):
+                blockage = (
+                    ws_sel
+                    * (
+                        1
+                        - self.induction.ct2a(ct_sel)
+                        * (
+                            (1 + 2 * r_sph_sel / D_sel)
+                            * (1 + (2 * r_sph_sel / D_sel) ** 2)
+                        )
+                        ** (-0.5)
+                    )
+                ) - ws_sel
+                wake_deltas[FV.WS][sp_sel] += -blockage
+
+        return wake_deltas

foxes/models/wake_models/ti/crespo_hernandez.py

@@ -1,5 +1,6 @@
 import numpy as np
 
+from foxes.core import WakeK
 from foxes.models.wake_models.top_hat import TopHatWakeModel
 import foxes.variables as FV
 import foxes.constants as FC
@@ -21,9 +22,6 @@ class CrespoHernandezTIWake(TopHatWakeModel):
 
     Attributes
     ----------
-    k: float
-        The wake growth parameter k. If not given here
-        it will be searched in the farm data.
     a_near: float
         Model parameter
     a_far: float
@@ -42,8 +40,8 @@ class CrespoHernandezTIWake(TopHatWakeModel):
     near_wake_D: float
         The near wake distance in units of D,
         calculated from TI and ct if None
-    k_var: str
-        The variable name for k
+    wake_k: foxes.core.WakeK
+        Handler for the wake growth parameter k
 
     :group: models.wake_models.ti
 
@@ -52,7 +50,6 @@ class CrespoHernandezTIWake(TopHatWakeModel):
     def __init__(
         self,
         superposition,
-        k=None,
         use_ambti=False,
         sbeta_factor=0.25,
         near_wake_D=None,
@@ -61,8 +58,8 @@ class CrespoHernandezTIWake(TopHatWakeModel):
         e1=0.83,
         e2=-0.0325,
         e3=-0.32,
-        k_var=FV.K,
-        **kwargs,
+        induction="Betz",
+        **wake_k,
     ):
         """
         Constructor.
@@ -94,11 +91,13 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             Model parameter
         k_var: str
             The variable name for k
-        kwargs: dict, optional
-            Additional parameters for the base class
+        induction: foxes.core.AxialInductionModel or str
+            The induction model
+        wake_k: dict, optional
+            Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.TI: superposition}, **kwargs)
+        super().__init__(superpositions={FV.TI: superposition}, induction=induction)
 
         self.a_near = a_near
         self.a_far = a_far
@@ -108,24 +107,29 @@ class CrespoHernandezTIWake(TopHatWakeModel):
         self.use_ambti = use_ambti
         self.sbeta_factor = sbeta_factor
         self.near_wake_D = near_wake_D
-        self.k_var = k_var
-
-        setattr(self, k_var, k)
+        self.wake_k = WakeK(**wake_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.TI]}, induction={iname}"
-        if k is None:
-            s += f", k_var={self.k_var}"
-        else:
-            s += f", {self.k_var}={k}"
-        s += ")"
+        s += f"({self.superpositions[FV.TI]}, induction={iname}, "
+        s += self.wake_k.repr() + ")"
         return s
 
+    def sub_models(self):
+        """
+        List of all sub-models
+
+        Returns
+        -------
+        smdls: list of foxes.core.Model
+            All sub models
+
+        """
+        return [self.wake_k]
+
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
         Creates new empty wake delta arrays.
@@ -200,10 +204,8 @@ class CrespoHernandezTIWake(TopHatWakeModel):
         )
 
         # get k:
-        k = self.get_data(
-            self.k_var,
+        k = self.wake_k(
             FC.STATE_TARGET,
-            lookup="sw",
             algo=algo,
             fdata=fdata,
             tdata=tdata,