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

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

foxes/models/wake_deflections/no_deflection.py

@@ -0,0 +1,94 @@
+from foxes.core.wake_deflection import WakeDeflection
+
+
+class NoDeflection(WakeDeflection):
+    """
+    Switch of wake deflection
+
+    :group: models.wake_deflections
+
+    """
+
+    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)
+
+        """
+        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,)
+
+        """
+        return None

foxes/models/wake_frames/__init__.py

@@ -2,10 +2,9 @@
 Wake frame models.
 """
 
-from .rotor_wd import RotorWD
-from .streamlines import Streamlines2D
-from .timelines import Timelines
-from .yawed_wakes import YawedWakes
-from .farm_order import FarmOrder
-from .seq_dynamic_wakes import SeqDynamicWakes
-from .dynamic_wakes import DynamicWakes
+from .rotor_wd import RotorWD as RotorWD
+from .streamlines import Streamlines2D as Streamlines2D
+from .timelines import Timelines as Timelines
+from .farm_order import FarmOrder as FarmOrder
+from .seq_dynamic_wakes import SeqDynamicWakes as SeqDynamicWakes
+from .dynamic_wakes import DynamicWakes as DynamicWakes

foxes/models/wake_frames/dynamic_wakes.py

@@ -161,7 +161,10 @@ class DynamicWakes(WakeFrame):
             for v in algo.states.output_point_vars(algo)
         }
         key = f"{self.DATA}_{downwind_index}"
-        ukey_fun = lambda fr, to: f"{self.UPDATE}_dw{downwind_index}_from_{fr}_to_{to}"
+
+        def ukey_fun(fr, to):
+            """helper function to create update key"""
+            return f"{self.UPDATE}_dw{downwind_index}_from_{fr}_to_{to}"
 
         # compute wakes that start within this chunk: x, y, z, length
         data = algo.get_from_chunk_store(name=key, mdata=mdata, error=False)
@@ -274,7 +277,6 @@ class DynamicWakes(WakeFrame):
                         # compute single state wake propagation:
                         isnan0 = np.isnan(hdata)
                         for si in range(n_states):
-
                             s = slice(si, si + 1, None)
                             hmdata = mdata.get_slice(FC.STATE, s)
                             hfdata = fdata.get_slice(FC.STATE, s)
@@ -429,4 +431,11 @@ class DynamicWakes(WakeFrame):
             (FC.STATE, FC.TARGET, FC.TPOINT),
         )
 
-        return wcoos.reshape(n_states, n_targets, n_tpoints, 3)
+        return algo.wake_deflection.calc_deflection(
+            algo,
+            mdata,
+            fdata,
+            tdata,
+            downwind_index,
+            wcoos.reshape(n_states, n_targets, n_tpoints, 3),
+        )

foxes/models/wake_frames/rotor_wd.py

@@ -116,7 +116,9 @@ class RotorWD(WakeFrame):
 
         coos = np.einsum("stpd,sad->stpa", delta, nax)
 
-        return coos
+        return algo.wake_deflection.calc_deflection(
+            algo, mdata, fdata, tdata, downwind_index, coos
+        )
 
     def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """

foxes/models/wake_frames/seq_dynamic_wakes.py

@@ -23,12 +23,14 @@ class SeqDynamicWakes(FarmOrder):
     dt_min: float, optional
         The delta t value in minutes,
         if not from timeseries data
+    induction: foxes.core.AxialInductionModel
+        The induction model
 
     :group: models.wake_frames.sequential
 
     """
 
-    def __init__(self, cl_ipars={}, dt_min=None, **kwargs):
+    def __init__(self, cl_ipars={}, dt_min=None, induction="Madsen", **kwargs):
         """
         Constructor.
 
@@ -40,6 +42,8 @@ class SeqDynamicWakes(FarmOrder):
         dt_min: float, optional
             The delta t value in minutes,
             if not from timeseries data
+        induction: foxes.core.AxialInductionModel or str
+            The induction model
         kwargs: dict, optional
             Additional parameters for the base class
 
@@ -47,9 +51,25 @@ class SeqDynamicWakes(FarmOrder):
         super().__init__(**kwargs)
         self.cl_ipars = cl_ipars
         self.dt_min = dt_min
+        self.induction = induction
 
     def __repr__(self):
-        return f"{type(self).__name__}(dt_min={self.dt_min})"
+        iname = (
+            self.induction if isinstance(self.induction, str) else self.induction.name
+        )
+        return f"{type(self).__name__}(dt_min={self.dt_min}, 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):
         """
@@ -63,7 +83,11 @@ class SeqDynamicWakes(FarmOrder):
             The verbosity level, 0 = silent
 
         """
+        if isinstance(self.induction, str):
+            self.induction = algo.mbook.axial_induction[self.induction]
+
         super().initialize(algo, verbosity)
+
         if not isinstance(algo, Sequential):
             raise TypeError(
                 f"Incompatible algorithm type {type(algo).__name__}, expecting {Sequential.__name__}"
@@ -168,7 +192,6 @@ class SeqDynamicWakes(FarmOrder):
         N = counter + 1
 
         if np.isnan(self._traces_l[counter, downwind_index]):
-
             # new wake starts at turbine:
             self._traces_p[counter, downwind_index][:] = fdata[FV.TXYH][
                 0, downwind_index
@@ -191,10 +214,21 @@ class SeqDynamicWakes(FarmOrder):
                 points=self._traces_p[None, :N, downwind_index], variables=svrs
             )
             res = algo.states.calculate(algo, mdata, fdata, hpdata)
-            self._traces_v[:N, downwind_index, :2] = wd2uv(
-                res[FV.WD][0, :, 0], res[FV.WS][0, :, 0]
-            )
-            del hpdata, res, svrs
+            wd = res[FV.WD][0, :, 0]
+            if FV.YAWM in fdata:
+                wddef = algo.wake_deflection.get_yaw_alpha_seq(
+                    algo,
+                    mdata,
+                    fdata,
+                    hpdata,
+                    downwind_index,
+                    self._traces_l[:N, downwind_index],
+                )
+                if wddef is not None:
+                    wd += wddef
+                del wddef
+            self._traces_v[:N, downwind_index, :2] = wd2uv(wd, res[FV.WS][0, :, 0])
+            del hpdata, res, svrs, wd
 
         # find nearest wake point:
         dists = cdist(points[0], self._traces_p[:N, downwind_index])

foxes/models/wake_frames/streamlines.py

@@ -67,7 +67,6 @@ class Streamlines2D(WakeFrame):
         # calc data: x, y, z, wd
         data = np.zeros((n_states, n_turbines, N, 4), dtype=config.dtype_double)
         for i in range(N):
-
             # set streamline start point data (rotor centre):
             if i == 0:
                 data[:, :, i, :3] = fdata[FV.TXYH]
@@ -75,7 +74,6 @@ class Streamlines2D(WakeFrame):
 
             # compute next step:
             else:
-
                 # calculate next point:
                 xyz = data[:, :, i - 1, :3]
                 n = wd2uv(data[:, :, i - 1, 3])
@@ -198,9 +196,9 @@ class Streamlines2D(WakeFrame):
         # n_states, n_turbines_source, n_turbines_target
         coosx = np.zeros((n_states, n_turbines, n_turbines), dtype=config.dtype_double)
         for ti in range(n_turbines):
-            coosx[:, ti, :] = self.get_wake_coos(algo, mdata, fdata, tdata, ti)[
-                :, :, 0, 0
-            ]
+            coosx[:, ti, :] = self._calc_coos(
+                algo, mdata, fdata, tdata[FC.TARGETS], ti
+            )[:, :, 0, 0]
 
         # derive turbine order:
         # TODO: Remove loop over states
@@ -242,7 +240,11 @@ class Streamlines2D(WakeFrame):
             points, shape: (n_states, n_targets, n_tpoints, 3)
 
         """
-        return self._calc_coos(algo, mdata, fdata, tdata[FC.TARGETS], downwind_index)
+        coos = self._calc_coos(algo, mdata, fdata, tdata[FC.TARGETS], downwind_index)
+
+        return algo.wake_deflection.calc_deflection(
+            algo, mdata, fdata, tdata, downwind_index, coos
+        )
 
     def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """

foxes/models/wake_frames/timelines.py

@@ -92,7 +92,7 @@ class Timelines(WakeFrame):
         del mdict, mdims, data
 
         # prepare fdata:
-        fdata = FData({}, {}, loop_dims=[FC.STATE])
+        fdata = FData()
 
         # prepare tdata:
         n_states = states.size()
@@ -107,7 +107,6 @@ class Timelines(WakeFrame):
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
         weight_data = None
         for h in heights:
-
             if verbosity > 0:
                 print(f"  Height: {h} m")
 
@@ -430,7 +429,14 @@ class Timelines(WakeFrame):
             (FC.STATE, FC.TARGET, FC.TPOINT),
         )
 
-        return wcoos.reshape(n_states, n_targets, n_tpoints, 3)
+        return algo.wake_deflection.calc_deflection(
+            algo,
+            mdata,
+            fdata,
+            tdata,
+            downwind_index,
+            wcoos.reshape(n_states, n_targets, n_tpoints, 3),
+        )
 
     def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """

foxes/models/wake_models/__init__.py

@@ -2,11 +2,11 @@
 Wake models.
 """
 
-from .dist_sliced import DistSlicedWakeModel
-from .axisymmetric import AxisymmetricWakeModel
-from .top_hat import TopHatWakeModel
-from .gaussian import GaussianWakeModel
+from .dist_sliced import DistSlicedWakeModel as DistSlicedWakeModel
+from .axisymmetric import AxisymmetricWakeModel as AxisymmetricWakeModel
+from .top_hat import TopHatWakeModel as TopHatWakeModel
+from .gaussian import GaussianWakeModel as GaussianWakeModel
 
-from . import wind
-from . import ti
-from . import induction
+from . import wind as wind
+from . import ti as ti
+from . import induction as induction