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

foxes/models/wake_models/induction/vortex_sheet.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
@@ -45,16 +46,28 @@ class VortexSheet(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):
         """
@@ -66,7 +79,7 @@ class VortexSheet(TurbineInductionModel):
             All sub models
 
         """
-        return [self._superp, self.induction]
+        return super().sub_models() + [self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -82,35 +95,44 @@ class VortexSheet(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)
 
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
-        Initialize wake delta storage.
-
-        They are added on the fly to the wake_deltas dict.
+        Creates new empty wake delta arrays.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
+        tdata: foxes.core.TData
+            The target point data
+
+        Returns
+        -------
         wake_deltas: dict
-            The wake deltas storage, add wake deltas
-            on the fly. Keys: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            Key: variable name, value: The zero filled
+            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,
@@ -186,20 +208,39 @@ class VortexSheet(TurbineInductionModel):
         R_sel = D[sp_sel] / 2
         xi = r_sph_sel / R_sel
 
+        def add_wake(sp_sel, wake_deltas, blockage):
+            """adds to wake deltas"""
+            if self.has_vector_wind_superp:
+                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,
+                )
+
         if np.any(sp_sel):
             blockage = self.induction.ct2a(ct_sel) * (1 + -xi / np.sqrt(1 + xi**2))
-
-            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)
 
         if not self.pre_rotor_only:
             sp_sel = (
@@ -211,51 +252,6 @@ class VortexSheet(TurbineInductionModel):
             xi = r_sph_sel / R_sel
             if np.any(sp_sel):
                 blockage = self.induction.ct2a(ct_sel) * (1 + -xi / np.sqrt(1 + xi**2))
-                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/ti/__init__.py

@@ -2,5 +2,5 @@
 Turbulence intensity wake models.
 """
 
-from .crespo_hernandez import CrespoHernandezTIWake
-from .iec_ti import IECTIWake
+from .crespo_hernandez import CrespoHernandezTIWake as CrespoHernandezTIWake
+from .iec_ti import IECTIWake as IECTIWake

foxes/models/wake_models/ti/crespo_hernandez.py

@@ -98,7 +98,9 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.TI: superposition}, induction=induction)
+        super().__init__(
+            other_superpositions={FV.TI: superposition}, induction=induction
+        )
 
         self.a_near = a_near
         self.a_far = a_far
@@ -115,7 +117,7 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.TI]}, induction={iname}, "
+        s += f"({self.other_superpositions[FV.TI]}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
@@ -129,7 +131,7 @@ class CrespoHernandezTIWake(TopHatWakeModel):
             All sub models
 
         """
-        return [self.wake_k]
+        return super().sub_models() + [self.wake_k]
 
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """

foxes/models/wake_models/ti/iec_ti.py

@@ -53,7 +53,9 @@ class IECTIWake(TopHatWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.TI: superposition}, induction=induction)
+        super().__init__(
+            other_superpositions={FV.TI: superposition}, induction=induction
+        )
         self.iec_type = iec_type
         self.wake_k = None
 
@@ -62,7 +64,7 @@ class IECTIWake(TopHatWakeModel):
         else:
             if "k" in wake_k or "ka" in wake_k or "kb" in wake_k:
                 raise KeyError(
-                    f"Can handle 'opening_angle' or ('k', 'ka', 'kb') parameters, not both"
+                    "Can handle 'opening_angle' or ('k', 'ka', 'kb') parameters, not both"
                 )
             self._k = float(np.tan(np.deg2rad(opening_angle / 2.0)))
 
@@ -71,7 +73,7 @@ class IECTIWake(TopHatWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.TI]}, induction={iname}"
+        s += f"({self.other_superpositions[FV.TI]}, induction={iname}"
         if self.wake_k is not None:
             s += ", " + self.wake_k.repr()
         s += ")"
@@ -87,7 +89,7 @@ class IECTIWake(TopHatWakeModel):
             All sub models
 
         """
-        return [self.wake_k] if self.wake_k is not None else []
+        return super().sub_models() + ([self.wake_k] if self.wake_k is not None else [])
 
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """

foxes/models/wake_models/top_hat.py

@@ -2,6 +2,7 @@ import numpy as np
 from abc import abstractmethod
 
 from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -19,21 +20,21 @@ class TopHatWakeModel(AxisymmetricWakeModel):
 
     """
 
-    def __init__(self, superpositions, induction="Betz"):
+    def __init__(self, *args, induction="Betz", **kwargs):
         """
         Constructor.
 
         Parameters
         ----------
-        superpositions: dict
-            The superpositions. Key: variable name str,
-            value: The wake superposition model name,
-            will be looked up in model book
+        args: tuple, optional
+            Additional parameters for the base class
         induction: foxes.core.AxialInductionModel or str
             The induction model
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
-        super().__init__(superpositions)
+        super().__init__(*args, **kwargs)
         self.induction = induction
 
     def sub_models(self):
@@ -46,7 +47,7 @@ class TopHatWakeModel(AxisymmetricWakeModel):
             All sub models
 
         """
-        return [self.induction]
+        return super().sub_models() + [self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -66,6 +67,41 @@ class TopHatWakeModel(AxisymmetricWakeModel):
             self.induction = algo.mbook.axial_induction[self.induction]
         super().initialize(algo, verbosity, force)
 
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
+        """
+        Creates new empty wake delta arrays.
+
+        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
+
+        Returns
+        -------
+        wake_deltas: dict
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
+
+        """
+        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_wake_radius(
         self,
@@ -224,4 +260,19 @@ class TopHatWakeModel(AxisymmetricWakeModel):
             for v, wdel in cl_del.items():
                 wdeltas[v] = np.where(isin, wdel[:, None], 0.0)
 
+        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[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[FC.WDEFL_DWS_FACTOR]
+                wdeltas[FV.WS] *= dws_defl[st_sel]
+
         return wdeltas, st_sel

foxes/models/wake_models/wind/__init__.py

@@ -2,7 +2,9 @@
 Wind deficit wake models.
 """
 
-from .jensen import JensenWake
-from .bastankhah14 import Bastankhah2014
-from .bastankhah16 import Bastankhah2016Model, Bastankhah2016
-from .turbopark import TurbOParkWake, TurbOParkWakeIX
+from .jensen import JensenWake as JensenWake
+from .bastankhah14 import Bastankhah2014 as Bastankhah2014
+from .bastankhah16 import Bastankhah2016Model as Bastankhah2016Model
+from .bastankhah16 import Bastankhah2016 as Bastankhah2016
+from .turbopark import TurbOParkWake as TurbOParkWake
+from .turbopark import TurbOParkWakeIX as TurbOParkWakeIX

foxes/models/wake_models/wind/bastankhah14.py

@@ -22,7 +22,7 @@ class Bastankhah2014(GaussianWakeModel):
     ----------
     sbeta_factor: float
         Factor multiplying sbeta
-    induction: foxes.core.AxialInductionModel or str
+    induction: foxes.core.AxialInductionModel
         The induction model
     wake_k: foxes.core.WakeK
         Handler for the wake growth parameter k
@@ -31,7 +31,13 @@ class Bastankhah2014(GaussianWakeModel):
 
     """
 
-    def __init__(self, superposition, sbeta_factor=0.2, induction="Madsen", **wake_k):
+    def __init__(
+        self,
+        superposition,
+        sbeta_factor=0.2,
+        induction="Madsen",
+        **wake_k,
+    ):
         """
         Constructor.
 
@@ -47,8 +53,7 @@ class Bastankhah2014(GaussianWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition})
-
+        super().__init__(wind_superposition=superposition)
         self.sbeta_factor = sbeta_factor
         self.induction = induction
         self.wake_k = WakeK(**wake_k)
@@ -58,10 +63,23 @@ class Bastankhah2014(GaussianWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @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):
         """
         List of all sub-models
@@ -72,7 +90,7 @@ class Bastankhah2014(GaussianWakeModel):
             All sub models
 
         """
-        return [self.wake_k, self.induction]
+        return super().sub_models() + [self.wake_k, self.induction]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -182,7 +200,7 @@ class Bastankhah2014(GaussianWakeModel):
 
             # calculate amplitude:
             ct_eff = ct / (8 * (sigma / D) ** 2)
-            ampld = np.maximum(-2 * self.induction.ct2a(ct_eff), -1)
+            ampld = np.maximum(-2 * self.induction.ct2a(ct_eff), -0.9999)
 
         # case no targets:
         else:

foxes/models/wake_models/wind/bastankhah16.py

@@ -447,7 +447,7 @@ class Bastankhah2016(DistSlicedWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition})
+        super().__init__(wind_superposition=superposition)
 
         self.model = None
         self.alpha = alpha
@@ -460,10 +460,23 @@ class Bastankhah2016(DistSlicedWakeModel):
     def __repr__(self):
         iname = self.induction
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @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):
         """
         List of all sub-models
@@ -474,7 +487,7 @@ class Bastankhah2016(DistSlicedWakeModel):
             Names of all sub models
 
         """
-        return [self.wake_k, self.model]
+        return super().sub_models() + [self.wake_k, self.model]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -621,4 +634,23 @@ class Bastankhah2016(DistSlicedWakeModel):
                     * np.exp(-0.5 * (z / sigma_z) ** 2)
                 )
 
+        # 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)
+            if FV.WS not in wdeltas:
+                raise AssertionError(
+                    f"Wake model '{self.name}': Expecting '{FV.WS}' in wdeltas, found {list(wdeltas.keys())}"
+                )
+            else:
+                wdeltas[FV.WS] *= dws_defl[st_sel]
+
         return wdeltas, st_sel

foxes/models/wake_models/wind/jensen.py

@@ -31,7 +31,7 @@ class JensenWake(TopHatWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition}, induction=induction)
+        super().__init__(wind_superposition=superposition, induction=induction)
         self.wake_k = WakeK(**wake_k)
 
     def __repr__(self):
@@ -39,10 +39,23 @@ class JensenWake(TopHatWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return True
+
     def calc_wake_radius(
         self,
         algo,

foxes/models/wake_models/wind/turbopark.py

@@ -63,7 +63,7 @@ class TurbOParkWake(GaussianWakeModel):
             Parameters for the WakeK class
 
         """
-        super().__init__(superpositions={FV.WS: superposition})
+        super().__init__(wind_superposition=superposition)
 
         self.sbeta_factor = sbeta_factor
         self.c1 = c1
@@ -76,10 +76,23 @@ class TurbOParkWake(GaussianWakeModel):
             self.induction if isinstance(self.induction, str) else self.induction.name
         )
         s = f"{type(self).__name__}"
-        s += f"({self.superpositions[FV.WS]}, induction={iname}, "
+        s += f"({self.wind_superposition}, induction={iname}, "
         s += self.wake_k.repr() + ")"
         return s
 
+    @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):
         """
         List of all sub-models
@@ -329,6 +342,19 @@ class TurbOParkWakeIX(GaussianWakeModel):
         s += self.wake_k.repr() + ")"
         return s
 
+    @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):
         """
         List of all sub-models

foxes/models/wake_superpositions/__init__.py

@@ -2,12 +2,21 @@
 Wake superposition models.
 """
 
-from .ws_linear import WSLinear, WSLinearLocal
-from .ws_quadratic import WSQuadratic, WSQuadraticLocal
-from .ws_pow import WSPow, WSPowLocal
-from .ws_max import WSMax, WSMaxLocal
-from .ws_product import WSProduct
-from .ti_linear import TILinear
-from .ti_quadratic import TIQuadratic
-from .ti_pow import TIPow
-from .ti_max import TIMax
+from .ws_linear import WSLinear as WSLinear
+from .ws_linear import WSLinearLocal as WSLinearLocal
+
+from .ws_pow import WSPow as WSPow
+from .ws_pow import WSPowLocal as WSPowLocal
+
+from .ws_max import WSMax as WSMax
+from .ws_max import WSMaxLocal as WSMaxLocal
+
+from .ws_quadratic import WSQuadratic as WSQuadratic
+from .ws_quadratic import WSQuadraticLocal as WSQuadraticLocal
+
+from .wind_vector import WindVectorLinear as WindVectorLinear
+from .ws_product import WSProduct as WSProduct
+from .ti_linear import TILinear as TILinear
+from .ti_quadratic import TIQuadratic as TIQuadratic
+from .ti_pow import TIPow as TIPow
+from .ti_max import TIMax as TIMax