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

foxes/models/rotor_models/centre.py

@@ -89,7 +89,7 @@ class CentreRotor(RotorModel):
         mdata,
         fdata,
         rpoint_results,
-        weights,
+        rpoint_weights,
         downwind_index=None,
         copy_to_ambient=False,
     ):
@@ -124,9 +124,9 @@ class CentreRotor(RotorModel):
             variables after calculation
 
         """
-        if len(weights) > 1:
+        if len(rpoint_weights) > 1:
             return super().eval_rpoint_results(
-                algo, mdata, fdata, rpoint_results, weights, downwind_index
+                algo, mdata, fdata, rpoint_results, rpoint_weights, downwind_index
             )
 
         n_states = mdata.n_states
@@ -192,7 +192,9 @@ class CentreRotor(RotorModel):
         del uvp
 
         for v in self.calc_vars:
-            if v not in vdone:
+            if v not in vdone and (
+                fdata[v].shape[1] > 1 or downwind_index is None or downwind_index == 0
+            ):
                 res = rpoint_results[v][:, :, 0]
                 self._set_res(fdata, v, res, downwind_index)
                 del res

foxes/models/turbine_models/__init__.py

@@ -2,14 +2,14 @@
 Turbine models.
 """
 
-from .kTI_model import kTI
-from .set_farm_vars import SetFarmVars
-from .thrust2ct import Thrust2Ct
-from .power_mask import PowerMask
-from .sector_management import SectorManagement
-from .table_factors import TableFactors
-from .yaw2yawm import YAW2YAWM
-from .yawm2yaw import YAWM2YAW
-from .calculator import Calculator
-from .rotor_centre_calc import RotorCentreCalc
-from .lookup_table import LookupTable
+from .kTI_model import kTI as kTI
+from .set_farm_vars import SetFarmVars as SetFarmVars
+from .thrust2ct import Thrust2Ct as Thrust2Ct
+from .power_mask import PowerMask as PowerMask
+from .sector_management import SectorManagement as SectorManagement
+from .table_factors import TableFactors as TableFactors
+from .yaw2yawm import YAW2YAWM as YAW2YAWM
+from .yawm2yaw import YAWM2YAW as YAWM2YAW
+from .calculator import Calculator as Calculator
+from .rotor_centre_calc import RotorCentreCalc as RotorCentreCalc
+from .lookup_table import LookupTable as LookupTable

foxes/models/turbine_models/set_farm_vars.py

@@ -270,7 +270,6 @@ class SetFarmVars(TurbineModel):
         """
         i0 = mdata.states_i0(counter=True)
         if not self.once or i0 not in self.__once_done:
-
             if self.pre_rotor:
                 order = np.s_[:]
                 ssel = np.s_[:]

foxes/models/turbine_types/PCt_file.py

@@ -1,6 +1,5 @@
 import numpy as np
 import pandas as pd
-from pathlib import Path
 
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
@@ -232,7 +231,6 @@ class PCtFile(TurbineType):
 
         """
         if modify_ct or modify_P:
-
             ws = self.data_ws
             ct = self.data_ct
             P = self.data_P

foxes/models/turbine_types/PCt_from_two.py

@@ -263,7 +263,6 @@ class PCtFromTwo(TurbineType):
 
         """
         if modify_ct:
-
             ws = self._data_ws_ct
             ct = self._data_ct
 
@@ -291,7 +290,6 @@ class PCtFromTwo(TurbineType):
                 self._data_ct = np.concatenate([new_ct[:-1], ct], axis=0)
 
         if modify_P:
-
             ws = self._data_ws_P
             P = self._data_P
 

foxes/models/turbine_types/__init__.py

@@ -2,12 +2,12 @@
 Turbine type models.
 """
 
-from .PCt_file import PCtFile
-from .PCt_from_two import PCtFromTwo
-from .CpCt_file import CpCtFile
-from .CpCt_from_two import CpCtFromTwo
-from .null_type import NullType
-from .wsrho2PCt_from_two import WsRho2PCtFromTwo
-from .wsti2PCt_from_two import WsTI2PCtFromTwo
-from .lookup import FromLookupTable
-from .TBL_file import TBLFile
+from .PCt_file import PCtFile as PCtFile
+from .PCt_from_two import PCtFromTwo as PCtFromTwo
+from .CpCt_file import CpCtFile as CpCtFile
+from .CpCt_from_two import CpCtFromTwo as CpCtFromTwo
+from .null_type import NullType as NullType
+from .wsrho2PCt_from_two import WsRho2PCtFromTwo as WsRho2PCtFromTwo
+from .wsti2PCt_from_two import WsTI2PCtFromTwo as WsTI2PCtFromTwo
+from .lookup import FromLookupTable as FromLookupTable
+from .TBL_file import TBLFile as TBLFile

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