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

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

foxes/models/wake_models/induction/rankine_half_body.py

@@ -1,7 +1,7 @@
 import numpy as np
 
+from foxes.config import config
 from foxes.core import TurbineInductionModel
-from foxes.utils import uv2wd, wd2uv, delta_wd
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -10,9 +10,6 @@ class RankineHalfBody(TurbineInductionModel):
     """
     The Rankine half body induction wake model
 
-    The individual wake effects are superposed linearly,
-    without invoking a wake superposition model.
-
     Notes
     -----
     Reference:
@@ -30,24 +27,41 @@ class RankineHalfBody(TurbineInductionModel):
 
     """
 
-    def __init__(self, induction="Madsen"):
+    def __init__(self, superposition="vector", induction="Madsen"):
         """
         Constructor.
 
         Parameters
         ----------
+        superposition: str
+            The wind speed deficit superposition.
         induction: foxes.core.AxialInductionModel or str
             The induction model
 
         """
-        super().__init__()
+        super().__init__(wind_superposition=superposition, other_superpositions={})
         self.induction = induction
 
+        self._has_uv = True
+
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
-        return f"{type(self).__name__}(induction={iname})"
+        return f"{type(self).__name__}({self.wind_superposition}, induction={iname})"
+
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
 
     def sub_models(self):
         """
@@ -59,7 +73,7 @@ class RankineHalfBody(TurbineInductionModel):
             All sub models
 
         """
-        return [self.induction]
+        return super().sub_models() + [self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -98,15 +112,14 @@ class RankineHalfBody(TurbineInductionModel):
         -------
         wake_deltas: dict
             Key: variable name, value: The zero filled
-            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
 
         """
-        return {
-            FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0]),
-            FV.WD: np.zeros_like(tdata[FC.TARGETS][..., 0]),
-            "U": np.zeros_like(tdata[FC.TARGETS][..., 0]),
-            "V": np.zeros_like(tdata[FC.TARGETS][..., 0]),
-        }
+        duv = np.zeros(
+            (tdata.n_states, tdata.n_targets, tdata.n_tpoints, 2),
+            dtype=config.dtype_double,
+        )
+        return {FV.UV: duv}
 
     def contribute(
         self,
@@ -205,8 +218,7 @@ class RankineHalfBody(TurbineInductionModel):
 
             # calc velocity components
             vel_factor = m[st_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
-            wake_deltas["U"][st_sel] += vel_factor * xyz[:, 0]
-            wake_deltas["V"][st_sel] += vel_factor * xyz[:, 1]
+            wake_deltas[FV.UV][st_sel] += vel_factor[:, None] * xyz[:, :2]
 
         # set values inside body shape
         st_sel = (ct > 1e-8) & (RHB_shape >= -1) & (x >= xs) & (x <= 0)
@@ -217,57 +229,4 @@ class RankineHalfBody(TurbineInductionModel):
 
             # calc velocity components
             vel_factor = m[st_sel] / (4 * np.linalg.norm(xyz, axis=-1) ** 3)
-            wake_deltas["U"][st_sel] += vel_factor * xyz[:, 0]
-
-    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)
-
-        """
-        # calc ambient wind vector:
-        ws0 = amb_results[FV.WS]
-        nx = wd2uv(amb_results[FV.WD])
-        wind_vec = nx * ws0[:, :, :, None]
-
-        # wake deltas are in wake frame, rotate back to global frame:
-        ny = np.stack((-nx[..., 1], nx[..., 0]), axis=-1)
-        delta_uv = (
-            wake_deltas["U"][:, :, :, None] * nx + wake_deltas["V"][:, :, :, None] * ny
-        )
-        del ws0, nx, ny
-
-        # add ambient result to wake deltas:
-        wind_vec += delta_uv
-        del delta_uv
-
-        # deduce WS and WD deltas:
-        new_wd = uv2wd(wind_vec)
-        new_ws = np.linalg.norm(wind_vec, axis=-1)
-        wake_deltas[FV.WS] += new_ws - amb_results[FV.WS]
-        wake_deltas[FV.WD] += delta_wd(amb_results[FV.WD], new_wd)
+            wake_deltas[FV.UV][st_sel, 0] += vel_factor * xyz[:, 0]

foxes/models/wake_models/induction/rathmann.py

@@ -1,5 +1,6 @@
 import numpy as np
 
+from foxes.config import config
 from foxes.core import TurbineInductionModel
 import foxes.variables as FV
 import foxes.constants as FC
@@ -50,16 +51,28 @@ class Rathmann(TurbineInductionModel):
             Calculate only the pre-rotor region
 
         """
-        super().__init__()
+        super().__init__(wind_superposition=superposition)
         self.induction = induction
         self.pre_rotor_only = pre_rotor_only
-        self._superp_name = superposition
 
     def __repr__(self):
         iname = (
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
-        return f"{type(self).__name__}({self._superp_name}, induction={iname})"
+        return f"{type(self).__name__}({self.wind_superposition}, induction={iname})"
+
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
 
     def sub_models(self):
         """
@@ -71,7 +84,7 @@ class Rathmann(TurbineInductionModel):
             All sub models
 
         """
-        return [self._superp, self.induction]
+        return super().sub_models() + [self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -87,7 +100,6 @@ class Rathmann(TurbineInductionModel):
             Overwrite existing data
 
         """
-        self._superp = algo.mbook.wake_superpositions[self._superp_name]
         if isinstance(self.induction, str):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
@@ -111,10 +123,21 @@ class Rathmann(TurbineInductionModel):
         -------
         wake_deltas: dict
             Key: variable name, value: The zero filled
-            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
 
         """
-        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
+        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}
 
     def contribute(
         self,
@@ -195,6 +218,39 @@ class Rathmann(TurbineInductionModel):
             sin_beta = 1 / np.sqrt(x_R**2 + r_R**2 + 1)  # eqn 19
             return sin_alpha * sin_beta * (1 + x_R**2)
 
+        def add_wake(sp_sel, wake_deltas, blockage):
+            """adds to wake deltas"""
+            if self.has_uv:
+                assert self.has_vector_wind_superp, (
+                    f"Wake model {self.name}: Missing vector wind superposition, got '{self.wind_superposition}'"
+                )
+                wdeltas = {FV.WS: blockage}
+                self.vec_superp.wdeltas_ws2uv(
+                    algo, fdata, tdata, downwind_index, wdeltas, sp_sel
+                )
+                wake_deltas[FV.UV] = self.vec_superp.add_wake_vector(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    sp_sel,
+                    wake_deltas[FV.UV],
+                    wdeltas.pop(FV.UV),
+                )
+            else:
+                self.superp[FV.WS].add_wake(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdata,
+                    downwind_index,
+                    sp_sel,
+                    FV.WS,
+                    wake_deltas[FV.WS],
+                    blockage,
+                )
+
         # ws delta in front of rotor
         sp_sel = (ct > 1e-8) & (x_R <= 0)
         if np.any(sp_sel):
@@ -202,17 +258,7 @@ class Rathmann(TurbineInductionModel):
             a = self.induction.ct2a(ct[sp_sel])
             blockage = a * mu(xr) * G(xr, r_R[sp_sel])  # eqn 10
 
-            self._superp.add_wake(
-                algo,
-                mdata,
-                fdata,
-                tdata,
-                downwind_index,
-                sp_sel,
-                FV.WS,
-                wake_deltas[FV.WS],
-                -blockage,
-            )
+            add_wake(sp_sel, wake_deltas, -blockage)
 
         # ws delta behind rotor
         if not self.pre_rotor_only:
@@ -223,51 +269,6 @@ class Rathmann(TurbineInductionModel):
                 a = self.induction.ct2a(ct[sp_sel])
                 blockage = a * mu(-xr) * G(-xr, r_R[sp_sel])  # eqn 10
 
-                self._superp.add_wake(
-                    algo,
-                    mdata,
-                    fdata,
-                    tdata,
-                    downwind_index,
-                    sp_sel,
-                    FV.WS,
-                    wake_deltas[FV.WS],
-                    blockage,
-                )
+                add_wake(sp_sel, wake_deltas, blockage)
 
         return wake_deltas
-
-    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)
-
-        """
-        wake_deltas[FV.WS] = self._superp.calc_final_wake_delta(
-            algo, mdata, fdata, FV.WS, amb_results[FV.WS], wake_deltas[FV.WS]
-        )