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

foxes/models/turbine_types/calculator_type.py

@@ -0,0 +1,123 @@
+from foxes.core import TurbineType
+
+
+class CalculatorType(TurbineType):
+    """
+    Direct data infusion by a user function.
+
+    :group: models.turbine_types
+
+    """
+
+    def __init__(
+        self,
+        func,
+        out_vars,
+        *args,
+        needs_rews2=False,
+        needs_rews3=False,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        func: callable
+            The function to calculate farm variables, should have the signature:
+            f(algo, mdata, fdata, st_sel) -> dict, where the keys are
+            output variable names and the values are numpy.ndarrays
+            with shape (n_states, n_turbines).
+
+            Beware that the turbine ordering in fdata is in downwind order,
+            hence external data X of shape (n_states, n_turbines) in farm order
+            needs to be reordered by X[ssel, order] with
+            ssel = fdata[FV.ORDER_SSEL], order = fdata[FV.ORDER]
+            before using it in combination with fdata variables.
+        out_vars: list of str
+            The output variables of the function
+        args: tuple, optional
+            Additional parameters for TurbineType class
+        needs_rews2: bool
+            Flag for runs that require the REWS2 variable
+        needs_rews3: bool
+            Flag for runs that require the REWS3 variable
+        kwargs: dict, optional
+            Additional parameters for TurbineType class
+
+        """
+        super().__init__(*args, **kwargs)
+        self._func = func
+        self._ovars = out_vars
+        self._rews2 = needs_rews2
+        self._rews3 = needs_rews3
+
+    def needs_rews2(self):
+        """
+        Returns flag for requiring REWS2 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS2 is required
+
+        """
+        return self._rews2
+
+    def needs_rews3(self):
+        """
+        Returns flag for requiring REWS3 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS3 is required
+
+        """
+        return self._rews3
+
+    def output_farm_vars(self, algo):
+        """
+        The variables which are being modified by the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        output_vars: list of str
+            The output variable names
+
+        """
+        return self._ovars
+
+    def calculate(self, algo, mdata, fdata, st_sel):
+        """
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        st_sel: numpy.ndarray of bool
+            The state-turbine selection,
+            shape: (n_states, n_turbines)
+
+        Returns
+        -------
+        results: dict
+            The resulting data, keys: output variable str.
+            Values: numpy.ndarray with shape (n_states, n_turbines)
+
+        """
+        self.ensure_output_vars(algo, fdata)
+        return self._func(algo, mdata, fdata, st_sel)

foxes/models/turbine_types/null_type.py

@@ -102,4 +102,5 @@ class NullType(TurbineType):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
         return {}

foxes/models/turbine_types/wsrho2PCt_from_two.py

@@ -262,6 +262,8 @@ class WsRho2PCtFromTwo(TurbineType):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        # prepare:
+        self.ensure_output_vars(algo, fdata)
 
         # calculate P:
         st_sel_P = (

foxes/models/turbine_types/wsti2PCt_from_two.py

@@ -5,8 +5,8 @@ from scipy.interpolate import interpn
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
 from foxes.data import PCTCURVE, parse_Pct_two_files
-import foxes.variables as FV
 from foxes.config import config, get_input_path
+import foxes.variables as FV
 
 
 class WsTI2PCtFromTwo(TurbineType):
@@ -274,6 +274,8 @@ class WsTI2PCtFromTwo(TurbineType):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        # prepare:
+        self.ensure_output_vars(algo, fdata)
 
         # calculate P:
         st_sel_P = (

foxes/models/vertical_profiles/__init__.py

@@ -2,10 +2,10 @@
 Vertical profile models.
 """
 
-from .uniform import UniformProfile
-from .abl_log_neutral_ws import ABLLogNeutralWsProfile
-from .abl_log_stable_ws import ABLLogStableWsProfile
-from .abl_log_unstable_ws import ABLLogUnstableWsProfile
-from .abl_log_ws import ABLLogWsProfile
-from .sheared_ws import ShearedProfile
-from .data_profile import DataProfile
+from .uniform import UniformProfile as UniformProfile
+from .abl_log_neutral_ws import ABLLogNeutralWsProfile as ABLLogNeutralWsProfile
+from .abl_log_stable_ws import ABLLogStableWsProfile as ABLLogStableWsProfile
+from .abl_log_unstable_ws import ABLLogUnstableWsProfile as ABLLogUnstableWsProfile
+from .abl_log_ws import ABLLogWsProfile as ABLLogWsProfile
+from .sheared_ws import ShearedProfile as ShearedProfile
+from .data_profile import DataProfile as DataProfile

foxes/models/wake_deflections/__init__.py

@@ -0,0 +1,3 @@
+from .no_deflection import NoDeflection as NoDeflection
+from .bastankhah2016 import Bastankhah2016Deflection as Bastankhah2016Deflection
+from .jimenez import JimenezDeflection as JimenezDeflection

foxes/models/{wake_frames/yawed_wakes.py → wake_deflections/bastankhah2016.py}

@@ -1,18 +1,17 @@
 import numpy as np
 
-from foxes.core import WakeFrame, WakeK, TData
+from foxes.config import config
+from foxes.core.wake_deflection import WakeDeflection
+from foxes.core.wake_model import WakeK
 from foxes.models.wake_models.wind.bastankhah16 import (
     Bastankhah2016Model,
     Bastankhah2016,
 )
-from foxes.config import config
-import foxes.variables as FV
 import foxes.constants as FC
-
-from .rotor_wd import RotorWD
+import foxes.variables as FV
 
 
-class YawedWakes(WakeFrame):
+class Bastankhah2016Deflection(WakeDeflection):
     """
     Bend the wakes for yawed turbines, based on the
     Bastankhah 2016 wake model
@@ -28,25 +27,26 @@ class YawedWakes(WakeFrame):
     ----------
     model: Bastankhah2016Model
         The model for computing common data
-    model_pars: dict
-        Model parameters
-    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
-
-    :group: models.wake_frames
+    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
+    wake_k: dict
+        Parameters for the WakeK class, if not found in wake model
+    induction: foxes.core.AxialInductionModel
+        The induction model, if not found in wake model
+
+    :group: models.wake_deflections
 
     """
 
     def __init__(
         self,
-        base_frame=RotorWD(),
         alpha=0.58,
         beta=0.07,
         induction="Madsen",
-        max_length_km=30,
         **wake_k,
     ):
         """
@@ -54,8 +54,6 @@ class YawedWakes(WakeFrame):
 
         Parameters
         ----------
-        base_frame: foxes.core.WakeFrame
-            The wake frame from which to start
         alpha: float
             model parameter used to determine onset of far wake region,
             if not found in wake model
@@ -66,13 +64,10 @@ class YawedWakes(WakeFrame):
             The induction model, if not found in wake model
         wake_k: dict, optional
             Parameters for the WakeK class, if not found in wake model
-        max_length_km: float
-            The maximal wake length in km
 
         """
-        super().__init__(max_length_km=max_length_km)
+        super().__init__()
 
-        self.base_frame = base_frame
         self.model = None
         self.alpha = alpha
         self.beta = beta
@@ -98,7 +93,7 @@ class YawedWakes(WakeFrame):
             Names of all sub models
 
         """
-        return [self.wake_k, self.base_frame, self.model]
+        return [self.wake_k, self.model]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -138,30 +133,6 @@ class YawedWakes(WakeFrame):
 
         super().initialize(algo, verbosity, force)
 
-    def calc_order(self, algo, mdata, fdata):
-        """
-        Calculates the order of turbine evaluation.
-
-        This function is executed on a single chunk of data,
-        all computations should be based on numpy arrays.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.MData
-            The model data
-        fdata: foxes.core.FData
-            The farm data
-
-        Returns
-        -------
-        order: numpy.ndarray
-            The turbine order, shape: (n_states, n_turbines)
-
-        """
-        return self.base_frame.calc_order(algo, mdata, fdata)
-
     def _update_y(self, algo, mdata, fdata, tdata, downwind_index, x, y):
         """
         Helper function for y deflection
@@ -227,16 +198,20 @@ class YawedWakes(WakeFrame):
             # apply deflection:
             y[st_sel] -= ydef
 
-    def get_wake_coos(
+    def calc_deflection(
         self,
         algo,
         mdata,
         fdata,
         tdata,
         downwind_index,
+        coos,
     ):
         """
-        Calculate wake coordinates of rotor points.
+        Calculates the wake deflection.
+
+        This function optionally adds FC.WDEFL_ROT_ANGLE or
+        FC.WDEFL_DWS_FACTOR to the tdata.
 
         Parameters
         ----------
@@ -251,79 +226,25 @@ class YawedWakes(WakeFrame):
         downwind_index: int
             The index of the wake causing turbine
             in the downwind order
+        coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
 
         Returns
         -------
-        wake_coos: numpy.ndarray
+        coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
 
         """
-        # get unyawed results:
-        xyz = self.base_frame.get_wake_coos(
-            algo,
-            mdata,
-            fdata,
-            tdata,
-            downwind_index,
-        )
 
         # take rotor average:
-        xy = np.einsum("stpd,p->std", xyz[..., :2], tdata[FC.TWEIGHTS])
+        xy = np.einsum("stpd,p->std", coos[..., :2], tdata[FC.TWEIGHTS])
         x = xy[:, :, 0]
         y = xy[:, :, 1]
 
         # apply deflection:
         self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
-        xyz[..., 1] = y[:, :, None]
-
-        return xyz
-
-    def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
-        """
-        Gets the points along the centreline for given
-        values of x.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.MData
-            The model data
-        fdata: foxes.core.FData
-            The farm data
-        downwind_index: int
-            The index in the downwind order
-        x: numpy.ndarray
-            The wake frame x coordinates, shape: (n_states, n_points)
-
-        Returns
-        -------
-        points: numpy.ndarray
-            The centreline points, shape: (n_states, n_points, 3)
-
-        """
-        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]
-        nx[:, -1] = points[:, -1] - points[:, -2]
-        nx[:, 1:-1] = 0.5 * (points[:, 1:-1] - points[:, :-2]) + 0.5 * (
-            points[:, 2:] - points[:, 1:-1]
-        )
-        nx /= np.linalg.norm(nx, axis=-1)[:, :, None]
-
-        nz = np.zeros_like(nx)
-        nz[:, :, 2] = 1
-        ny = np.cross(nz, nx, axis=-1)
-        del nx, nz
-
-        y = np.zeros_like(x)
-        self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
-
-        points += y[:, :, None] * ny
+        coos[..., 1] = y[:, :, None]
 
-        return points
+        return coos

foxes/models/wake_deflections/jimenez.py

@@ -0,0 +1,277 @@
+import numpy as np
+
+from foxes.core.wake_deflection import WakeDeflection
+from foxes.algorithms import Sequential
+import foxes.constants as FC
+import foxes.variables as FV
+
+
+class JimenezDeflection(WakeDeflection):
+    """
+    Yawed rotor wake defection according to the Jimenez model
+
+    Notes
+    -----
+    Reference:
+    Jiménez, Á., Crespo, A. and Migoya, E. (2010), Application of a LES technique to characterize
+    the wake deflection of a wind turbine in yaw. Wind Energ., 13: 559-572. doi:10.1002/we.380
+
+
+    Attributes
+    ----------
+    rotate: bool
+        If True, rotate local wind vector at evaluation points.
+        If False, multiply wind speed with cos(angle) instead.
+        If None, do not modify the wind vector, only the path.
+    beta: float
+        The beta coefficient of the Jimenez model
+    step_x: float
+        The x step in m for integration
+
+    :group: models.wake_deflections
+
+    """
+
+    def __init__(self, rotate=True, beta=0.1, step_x=10.0):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        rotate: bool, optional
+            If True, rotate local wind vector at evaluation points.
+            If False, multiply wind speed with cos(angle) instead.
+            If None, do not modify the wind vector, only the path.
+        beta: float
+            The beta coefficient of the Jimenez model
+        step_x: float
+            The x step in m for integration
+
+        """
+        super().__init__()
+        self.rotate = rotate
+        self.beta = beta
+        self.step_x = step_x
+
+    def __repr__(self):
+        s = f"{type(self).__name__}("
+        s += f"rotate={self.rotate}, beta={self.beta}, step_x={self.step_x}"
+        s += ")"
+        return s
+
+    @property
+    def has_uv(self):
+        """
+        This model uses wind vector data
+
+        Returns
+        -------
+        hasuv: bool
+            Flag for wind vector data
+
+        """
+        return self.rotate is not None and self.rotate
+
+    def calc_deflection(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        coos,
+    ):
+        """
+        Calculates the wake deflection.
+
+        This function optionally adds FC.WDEFL_ROT_ANGLE or
+        FC.WDEFL_DWS_FACTOR to the tdata.
+
+        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
+        coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
+
+        Returns
+        -------
+        coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
+
+        """
+
+        if FV.YAWM not in fdata:
+            return coos
+
+        # take rotor average:
+        xyz = np.einsum("stpd,p->std", coos, tdata[FC.TWEIGHTS])
+        x = xyz[:, :, 0]
+        y = xyz[:, :, 1]
+        z = xyz[:, :, 2]
+
+        # get ct:
+        ct = self.get_data(
+            FV.CT,
+            FC.STATE_TARGET,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
+            upcast=True,
+        )
+
+        # get gamma:
+        gamma = self.get_data(
+            FV.YAWM,
+            FC.STATE_TARGET,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
+            upcast=True,
+        )
+
+        sel = (x > 1e-8) & (x < 1e10) & (ct > 1e-8) & (np.abs(gamma) > 1e-8)
+        delwd = np.zeros_like(coos[..., 0])
+        n_sel = np.sum(sel)
+        if n_sel > 0:
+            # apply selection:
+            gamma = np.deg2rad(gamma[sel])
+            ct = ct[sel]
+            x = x[sel]
+
+            # get rotor diameter:
+            D = self.get_data(
+                FV.D,
+                FC.STATE_TARGET,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                upcast=True,
+                selection=sel,
+            )[:, None]
+
+            # define x path:
+            xmax = np.max(x)
+            n_x = int(xmax / self.step_x)
+            if xmax > n_x * self.step_x:
+                n_x += 1
+            delx = np.arange(n_x + 1) * self.step_x
+            delx = np.minimum(delx[None, :], x[:, None])
+            dx = delx[:, 1:] - delx[:, :-1]
+            delx = delx[:, :-1]
+
+            # integrate deflection of y along the x path:
+            alpha0 = (
+                -(np.cos(gamma[:, None]) ** 2)
+                * np.sin(gamma[:, None])
+                * ct[:, None]
+                / 2
+            )
+            y[sel] += np.sum(
+                np.tan(alpha0 / (1 + self.beta * delx / D) ** 2) * dx, axis=-1
+            )
+            del delx, dx
+            coos[..., 1] = y[:, :, None]
+
+            # calculate wind vector modification at evaluation points:
+            if self.rotate is not None:
+                # delta wd at evaluation points, if within wake radius:
+                r2 = (y[sel, None] ** 2 + z[sel, None] ** 2) / D**2
+                WD2 = (1 + self.beta * x[:, None] / D) ** 2
+                delwd[sel] = np.where(r2 <= WD2 / 4, alpha0 / WD2, 0)
+
+                if self.rotate:
+                    tdata[FC.WDEFL_ROT_ANGLE] = np.rad2deg(delwd)
+                else:
+                    tdata[FC.WDEFL_DWS_FACTOR] = np.cos(delwd)
+
+        return coos
+
+    def get_yaw_alpha_seq(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        x,
+    ):
+        """
+        Computes sequential wind vector rotation angles.
+
+        Wind vector rotation angles are computed at the
+        current trace points due to a yawed rotor
+        for sequential runs.
+
+        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
+        x: numpy.ndarray
+            The distance from the wake causing rotor
+            for the first n_times subsequent time steps,
+            shape: (n_times,)
+
+        Returns
+        -------
+        alpha: numpy.ndarray
+            The delta WD result at the x locations,
+            shape: (n_times,)
+
+        """
+        assert isinstance(algo, Sequential), (
+            f"Wake deflection '{self.name}' requires Sequential algorithm, got '{type(algo).__name__}'"
+        )
+
+        n_times = len(x)
+
+        def _get_data(var):
+            data = algo.farm_results_downwind[var].to_numpy()[:n_times, downwind_index]
+            data[-1] = fdata[var][0, downwind_index]
+            return data
+
+        gamma = _get_data(FV.YAWM)
+        ct = _get_data(FV.CT)
+        alpha = np.zeros_like(gamma)
+
+        sel = (ct > 1e-8) & (np.abs(gamma) > 1e-8)
+        if np.any(sel):
+            D = _get_data(FV.D)[sel]
+            gamma = np.deg2rad(gamma[sel])
+            ct = ct[sel]
+
+            alpha[sel] = np.rad2deg(
+                -(np.cos(gamma) ** 2)
+                * np.sin(gamma)
+                * ct
+                / 2
+                / (1 + self.beta * x / D) ** 2
+            )
+
+        return alpha