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

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
@@ -186,12 +209,26 @@ class SeqDynamicWakes(FarmOrder):
 
             # compute wind vectors at wake traces:
             # TODO: dz from U_z is missing here
-            hpdata = TData.from_points(points=self._traces_p[None, :N, downwind_index])
-            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]
+            svrs = algo.states.output_point_vars(algo)
+            hpdata = TData.from_points(
+                points=self._traces_p[None, :N, downwind_index], variables=svrs
             )
-            del hpdata, res
+            res = algo.states.calculate(algo, mdata, fdata, hpdata)
+            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()
@@ -105,8 +105,8 @@ class Timelines(WakeFrame):
 
         # calculate all heights:
         self.timelines_data = {"dxy": (("height", FC.STATE, "dir"), [])}
+        weight_data = None
         for h in heights:
-
             if verbosity > 0:
                 print(f"  Height: {h} m")
 
@@ -118,6 +118,13 @@ class Timelines(WakeFrame):
             )
 
             res = states.calculate(algo, mdata, fdata, tdata)
+
+            if weight_data is None:
+                weight_data = ((FC.STATE,), tdata[FV.WEIGHT][:, 0, 0])
+            elif not np.all(tdata[FV.WEIGHT] == weight_data[1]):
+                raise AssertionError(
+                    f"States '{self.name}': weight data mismatch between heights"
+                )
             del tdata
 
             uv = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2]
@@ -163,6 +170,8 @@ class Timelines(WakeFrame):
             },
         )
 
+        return weight_data
+
     def initialize(self, algo, verbosity=0):
         """
         Initializes the model.
@@ -420,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

foxes/models/wake_models/dist_sliced.py

@@ -1,9 +1,12 @@
 from abc import abstractmethod
+import numpy as np
 
-from foxes.core import WakeModel
+from foxes.core import SingleTurbineWakeModel
+from foxes.config import config
+import foxes.variables as FV
 
 
-class DistSlicedWakeModel(WakeModel):
+class DistSlicedWakeModel(SingleTurbineWakeModel):
     """
     Abstract base class for wake models for which
     the x-denpendency can be separated from the
@@ -12,65 +15,44 @@ class DistSlicedWakeModel(WakeModel):
     The multi-yz ability is used by the `PartialDistSlicedWake`
     partial wakes model.
 
-    Attributes
-    ----------
-    superpositions: dict
-        The superpositions. Key: variable name str,
-        value: The wake superposition model name,
-        will be looked up in model book
-    superp: dict
-        The superposition dict, key: variable name str,
-        value: `foxes.core.WakeSuperposition`
-
     :group: models.wake_models
 
     """
 
-    def __init__(self, superpositions):
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
-        Constructor.
+        Creates new empty wake delta arrays.
 
         Parameters
         ----------
-        superpositions: dict
-            The superpositions. Key: variable name str,
-            value: The wake superposition model name,
-            will be looked up in model book
-
-        """
-        super().__init__()
-        self.superpositions = superpositions
-
-    def sub_models(self):
-        """
-        List of all sub-models
+        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
 
         Returns
         -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return list(self.superp.values())
-
-    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
+        wake_deltas: dict
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
 
         """
-        self.superp = {
-            v: algo.mbook.wake_superpositions[s] for v, s in self.superpositions.items()
-        }
-        super().initialize(algo, verbosity, force)
+        if self.has_uv:
+            duv = np.zeros(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints, 2),
+                dtype=config.dtype_double,
+            )
+            return {FV.UV: duv}
+        else:
+            dws = np.zeros(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                dtype=config.dtype_double,
+            )
+            return {FV.WS: dws}
 
     @abstractmethod
     def calc_wakes_x_yz(
@@ -159,6 +141,26 @@ class DistSlicedWakeModel(WakeModel):
             algo, mdata, fdata, tdata, downwind_index, x, yz
         )
 
+        if self.affects_ws and self.has_uv:
+            assert self.has_vector_wind_superp, (
+                f"Wake model {self.name}: Missing vector wind superposition, got '{self.wind_superposition}'"
+            )
+            if FV.UV in wdeltas or FV.WS in wdeltas:
+                if FV.UV not in wdeltas:
+                    self.vec_superp.wdeltas_ws2uv(
+                        algo, fdata, tdata, downwind_index, wdeltas, st_sel
+                    )
+                wake_deltas[FV.UV] = self.vec_superp.add_wake_vector(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    st_sel,
+                    wake_deltas[FV.UV],
+                    wdeltas.pop(FV.UV),
+                )
+
         for v, hdel in wdeltas.items():
             try:
                 superp = self.superp[v]
@@ -178,39 +180,3 @@ class DistSlicedWakeModel(WakeModel):
                 wake_deltas[v],
                 hdel,
             )
-
-    def finalize_wake_deltas(
-        self,
-        algo,
-        mdata,
-        fdata,
-        amb_results,
-        wake_deltas,
-    ):
-        """
-        Finalize the wake calculation.
-
-        Modifies wake_deltas on the fly.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.MData
-            The model data
-        fdata: foxes.core.FData
-            The farm data
-        amb_results: dict
-            The ambient results, key: variable name str,
-            values: numpy.ndarray with shape
-            (n_states, n_targets, n_tpoints)
-        wake_deltas: dict
-            The wake deltas object at the selected target
-            turbines. Key: variable str, value: numpy.ndarray
-            with shape (n_states, n_targets, n_tpoints)
-
-        """
-        for v, s in self.superp.items():
-            wake_deltas[v] = s.calc_final_wake_delta(
-                algo, mdata, fdata, v, amb_results[v], wake_deltas[v]
-            )

foxes/models/wake_models/gaussian.py

@@ -2,6 +2,8 @@ import numpy as np
 from abc import abstractmethod
 
 from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
+import foxes.variables as FV
+import foxes.constants as FC
 
 
 class GaussianWakeModel(AxisymmetricWakeModel):
@@ -94,13 +96,31 @@ class GaussianWakeModel(AxisymmetricWakeModel):
             is non-zero, shape: (n_states, n_targets)
 
         """
+        # compute amplitude and sigma:
         amsi, st_sel = self.calc_amplitude_sigma(
             algo, mdata, fdata, tdata, downwind_index, x
         )
+
+        # evaluate the Gaussian function:
         wdeltas = {}
         rsel = r[st_sel]
         for v in amsi.keys():
             ampld, sigma = amsi[v]
             wdeltas[v] = ampld[:, None] * np.exp(-0.5 * (rsel / sigma[:, None]) ** 2)
 
+        if self.affects_ws and FV.WS in wdeltas:
+            # wake deflection causes wind vector rotation:
+            if FC.WDEFL_ROT_ANGLE in tdata:
+                dwd_defl = tdata.pop(FC.WDEFL_ROT_ANGLE)
+                if FV.WD not in wdeltas:
+                    wdeltas[FV.WD] = np.zeros_like(wdeltas[FV.WS])
+                    wdeltas[FV.WD][:] = dwd_defl[st_sel]
+                else:
+                    wdeltas[FV.WD] += dwd_defl[st_sel]
+
+            # wake deflection causes wind speed reduction:
+            if FC.WDEFL_DWS_FACTOR in tdata:
+                dws_defl = tdata.pop(FC.WDEFL_DWS_FACTOR)
+                wdeltas[FV.WS] *= dws_defl[st_sel]
+
         return wdeltas, st_sel

foxes/models/wake_models/induction/__init__.py

@@ -2,8 +2,8 @@
 Induction wake models
 """
 
-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
+from .rankine_half_body import RankineHalfBody as RankineHalfBody
+from .rathmann import Rathmann as Rathmann
+from .self_similar import SelfSimilar as SelfSimilar
+from .self_similar2020 import SelfSimilar2020 as SelfSimilar2020
+from .vortex_sheet import VortexSheet as VortexSheet