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

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]
-        )

foxes/models/wake_models/induction/self_similar.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
@@ -10,9 +11,6 @@ class SelfSimilar(TurbineInductionModel):
     The self-similar induction wake model
     from Troldborg and Meyer Forsting
 
-    The individual wake effects are superposed linearly,
-    without invoking a wake superposition model.
-
     Notes
     -----
     References:
@@ -60,17 +58,29 @@ class SelfSimilar(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.gamma = gamma
-        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}, gamma={self.gamma})"
+        return f"{type(self).__name__}({self.wind_superposition}, induction={iname}, gamma={self.gamma})"
+
+    @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):
         """
@@ -82,7 +92,7 @@ class SelfSimilar(TurbineInductionModel):
             All sub models
 
         """
-        return [self._superp, self.induction]
+        return super().sub_models() + [self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -98,7 +108,6 @@ class SelfSimilar(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)
@@ -122,10 +131,21 @@ class SelfSimilar(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 _mu(self, x_R):
         """Helper function: define mu (eqn 11 from [1])"""
@@ -211,6 +231,39 @@ class SelfSimilar(TurbineInductionModel):
         x_R = np.round(wake_coos[..., 0] / R, 12)
         r_R = np.linalg.norm(wake_coos[..., 1:3], axis=-1) / R
 
+        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,
+                )
+
         # select values
         sp_sel = (ct > 1e-8) & (x_R <= 0)  # upstream
         if np.any(sp_sel):
@@ -218,17 +271,7 @@ class SelfSimilar(TurbineInductionModel):
             xr = x_R[sp_sel]
             blockage = self._a(ct[sp_sel], xr) * self._rad_fn(xr, r_R[sp_sel])
 
-            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)
 
         # set area behind to mirrored value EXCEPT for area behind turbine
         if not self.pre_rotor_only:
@@ -238,52 +281,6 @@ class SelfSimilar(TurbineInductionModel):
                 xr = x_R[sp_sel]
                 blockage = self._a(ct[sp_sel], -xr) * self._rad_fn(-xr, r_R[sp_sel])
 
-                # wdelta[sp_sel] += blockage
-                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]
-        )

foxes/models/wake_models/induction/self_similar2020.py

@@ -8,9 +8,6 @@ class SelfSimilar2020(SelfSimilar):
     The self-similar 2020 induction wake model
     from Troldborg and Meyer Forsting
 
-    The individual wake effects are superposed linearly,
-    without invoking a wake superposition model.
-
     Notes
     -----
     References: