foxes 0.7.2__py3-none-any.whl → 0.7.3.1__py3-none-any.whl

foxes/models/ground_models/no_ground.py

@@ -0,0 +1,12 @@
+from foxes.core import GroundModel
+
+
+class NoGround(GroundModel):
+    """
+    No ground effects
+
+    :group: models.ground_models
+
+    """
+
+    pass

foxes/models/ground_models/wake_mirror.py

@@ -0,0 +1,161 @@
+from foxes.core import GroundModel
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class WakeMirror(GroundModel):
+    """
+    Wake reflection from ground and/or other horizontal planes.
+
+    Attributes
+    ----------
+    heights: list of float
+        The reflection heights
+
+    :group: models.ground_models
+
+    """
+
+    def __init__(self, heights):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        heights: list of float
+            The reflection heights
+
+        """
+        super().__init__()
+        self.heights = heights
+
+    def contribute_to_farm_wakes(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        wake_deltas,
+        wmodel,
+        pwake,
+    ):
+        """
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
+
+        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 downwnd order
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
+        wmodel: foxes.core.WakeModel
+            The wake model
+        pwake: foxes.core.PartialWakesModel
+            The partial wakes model
+
+        """
+        # prepare:
+        hh = fdata[FV.H][:, downwind_index].copy()
+
+        # contribution from main wake:
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
+
+        # contribution from mirrors:
+        tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
+        for h in self.heights:
+
+            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+
+            pwake.contribute(
+                algo, mdata, fdata, tdata, downwind_index, wake_deltas, wmodel
+            )
+
+        # reset heights:
+        fdata[FV.H][:, downwind_index] = hh
+
+    def contribute_to_point_wakes(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        wake_deltas,
+        wmodel,
+    ):
+        """
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
+
+        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 downwnd order
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
+        wmodel: foxes.core.WakeModel
+            The wake model
+
+        """
+        # prepare:
+        hh = fdata[FV.H][:, downwind_index].copy()
+
+        # contribution from main wake:
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
+
+        # contribution from mirrors:
+        tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
+        for h in self.heights:
+
+            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+
+            wcoos = algo.wake_frame.get_wake_coos(
+                algo, mdata, fdata, tdata, downwind_index
+            )
+            wmodel.contribute(
+                algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas
+            )
+
+        # reset heights:
+        fdata[FV.H][:, downwind_index] = hh
+
+
+class GroundMirror(WakeMirror):
+    """
+    Wake reflection from the ground.
+
+    :group: models.ground_models
+
+    """
+
+    def __init__(self):
+        """
+        Constructor.
+        """
+        super().__init__(heights=[0.0])

foxes/models/model_book.py

@@ -16,6 +16,7 @@ from foxes.core import (
     WakeModel,
     AxialInductionModel,
     TurbineInductionModel,
+    GroundModel,
 )
 
 
@@ -58,6 +59,9 @@ class ModelBook:
     induction_models: foxes.utils.FDict
         The induction models. Keys: model name str,
         values: foxes.core.AxialInductionModel
+    ground_models: foxes.utils.FDict
+        The ground models. Keys: model name str,
+        values: foxes.core.GroundModel
     sources: foxes.utils.FDict
         All sources dict
     base_classes: foxes.utils.FDict
@@ -231,13 +235,10 @@ class ModelBook:
             name="wake_frames",
             rotor_wd=fm.wake_frames.RotorWD(var_wd=FV.WD),
             rotor_wd_farmo=fm.wake_frames.FarmOrder(),
-            yawed=fm.wake_frames.YawedWakes(),
         )
-        self.wake_frames.add_factory(
+        self.wake_frames.add_k_factory(
             fm.wake_frames.YawedWakes,
-            "yawed_k<k>",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"k": "(Value, e.g. 004 for 0.04)"},
+            "yawed_[wake_k]",
         )
         self.wake_frames.add_factory(
             fm.wake_frames.Streamlines2D,
@@ -324,169 +325,76 @@ class ModelBook:
 
         self.wake_models = FDict(name="wake_models")
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.JensenWake,
-            "Jensen_<superposition>",
+            "Jensen_<superposition>_[wake_k]",
+            kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.JensenWake,
-            "Jensen_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014_<superposition>",
-            kwargs=dict(sbeta_factor=0.2),
+            "Bastankhah2014_<superposition>_[wake_k]",
+            kwargs=dict(sbeta_factor=0.2, induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.2),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014B_<superposition>",
+            "Bastankhah2014B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.2, induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014B_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.2, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025_<superposition>",
-            kwargs=dict(sbeta_factor=0.25),
+            "Bastankhah025_<superposition>_[wake_k]",
+            kwargs=dict(sbeta_factor=0.25, induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.25),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025B_<superposition>",
+            "Bastankhah025B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.25, induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025B_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.25, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016_<superposition>",
+            "Bastankhah2016_<superposition>_[wake_k]",
+            kwargs=dict(induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016B_<superposition>",
+            "Bastankhah2016B_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016B_<superposition>_k<k>",
-            kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
-            "TurbOPark_<superposition>",
+            "TurbOPark_<superposition>_[wake_k]",
+            kwargs=dict(induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
-            "TurbOPark_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWake,
-            "TurbOParkB_<superposition>",
+            "TurbOParkB_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWake,
-            "TurbOParkB_<superposition>_k<k>",
-            kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWakeIX,
-            "TurbOParkIX_<superposition>_dx<dx>",
+            "TurbOParkIX_<superposition>_[wake_k]_dx<dx>",
             superposition=lambda s: f"ws_{s}",
             dx=lambda x: float(x),
             hints={
@@ -495,37 +403,35 @@ class ModelBook:
             },
         )
 
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWakeIX,
-            "TurbOParkIX_<superposition>_k<k>_dx<dx>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            dx=lambda x: float(x),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ws_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-                "dx": "(Integration step in m)",
-            },
+        self.wake_models.add_k_factory(
+            fm.wake_models.ti.CrespoHernandezTIWake,
+            "CrespoHernandez_<superposition>_[wake_k]",
+            kwargs=dict(use_ambti=False),
+            superposition=lambda s: f"ti_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
         self.wake_models.add_factory(
-            fm.wake_models.ti.CrespoHernandezTIWake,
-            "CrespoHernandez_<superposition>",
-            kwargs=dict(use_ambti=False),
+            fm.wake_models.ti.IECTIWake,
+            "IECTI2005_<superposition>",
+            kwargs=dict(iec_type="2005"),
             superposition=lambda s: f"ti_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
         self.wake_models.add_factory(
-            fm.wake_models.ti.CrespoHernandezTIWake,
-            "CrespoHernandez_<superposition>_k<k>",
-            kwargs=dict(use_ambti=False),
+            fm.wake_models.ti.IECTIWake,
+            "IECTI2019_<superposition>",
+            kwargs=dict(iec_type="2019"),
             superposition=lambda s: f"ti_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={
-                "superposition": "(Superposition, e.g. linear for ti_linear)",
-                "k": "(Value, e.g. 004 for 0.04)",
-            },
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
+        )
+        self.wake_models.add_k_factory(
+            fm.wake_models.ti.IECTIWake,
+            "IECTI2019k_<superposition>_[wake_k]",
+            kwargs=dict(iec_type="2019", opening_angle=None),
+            superposition=lambda s: f"ti_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
         self.wake_models.add_factory(
@@ -535,11 +441,10 @@ class ModelBook:
             superposition=lambda s: f"ti_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
-
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.ti.IECTIWake,
-            "IECTI2019_<superposition>",
-            kwargs=dict(iec_type="2019"),
+            "IECTI2005k_<superposition>_[wake_k]",
+            kwargs=dict(iec_type="2005", opening_angle=None),
             superposition=lambda s: f"ti_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
@@ -550,6 +455,18 @@ class ModelBook:
         self.wake_models[f"SelfSimilar2020"] = (
             fm.wake_models.induction.SelfSimilar2020()
         )
+        self.wake_models[f"VortexSheet"] = fm.wake_models.induction.VortexSheet()
+
+        self.ground_models = FDict(name="ground_models")
+        self.ground_models["no_ground"] = fm.ground_models.NoGround()
+        self.ground_models["ground_mirror"] = fm.ground_models.GroundMirror()
+        self.ground_models.add_factory(
+            fm.ground_models.WakeMirror,
+            "blh_mirror_h<height>",
+            var2arg={"height": "heights"},
+            height=lambda h: [0.0, float(h)],
+            hints={"height": "(Boundary layer wake reflection height)"},
+        )
 
         self.sources = FDict(
             name="sources",
@@ -564,6 +481,7 @@ class ModelBook:
             wake_superpositions=self.wake_superpositions,
             wake_models=self.wake_models,
             axial_induction=self.axial_induction,
+            ground_models=self.ground_models,
         )
         self.base_classes = FDict(
             name="base_classes",
@@ -578,6 +496,7 @@ class ModelBook:
             wake_superpositions=WakeSuperposition,
             wake_models=WakeModel,
             axial_induction=AxialInductionModel,
+            ground_models=GroundModel,
         )
 
         for s in self.sources.values():

foxes/models/partial_wakes/axiwake.py

@@ -44,6 +44,31 @@ class PartialAxiwake(PartialCentre):
     def __repr__(self):
         return f"{type(self).__name__}(n={self.n})"
 
+    def check_wmodel(self, wmodel, error=True):
+        """
+        Checks the wake model type
+
+        Parameters
+        ----------
+        wmodel: foxes.core.WakeModel
+            The wake model to be tested
+        error: bool
+            Flag for raising TypeError
+
+        Returns
+        -------
+        chk: bool
+            True if wake model is compatible
+
+        """
+        if not isinstance(wmodel, AxisymmetricWakeModel):
+            if error:
+                raise TypeError(
+                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not an AxisymmetricWakeModel"
+                )
+            return False
+        return True
+
     def contribute(
         self,
         algo,
@@ -79,10 +104,8 @@ class PartialAxiwake(PartialCentre):
             The wake model
 
         """
-        if not isinstance(wmodel, AxisymmetricWakeModel):
-            raise TypeError(
-                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not an AxisymmetricWakeModel"
-            )
+        # check:
+        self.check_wmodel(wmodel, error=True)
 
         # prepare:
         n_states = mdata.n_states

foxes/models/partial_wakes/top_hat.py

@@ -24,6 +24,31 @@ class PartialTopHat(PartialCentre):
 
     """
 
+    def check_wmodel(self, wmodel, error=True):
+        """
+        Checks the wake model type
+
+        Parameters
+        ----------
+        wmodel: foxes.core.WakeModel
+            The wake model to be tested
+        error: bool
+            Flag for raising TypeError
+
+        Returns
+        -------
+        chk: bool
+            True if wake model is compatible
+
+        """
+        if not isinstance(wmodel, TopHatWakeModel):
+            if error:
+                raise TypeError(
+                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not a TopHatWakeModel"
+                )
+            return False
+        return True
+
     def __init__(self, rotor_model=None):
         """
         Constructor.
@@ -105,10 +130,7 @@ class PartialTopHat(PartialCentre):
             The wake model
 
         """
-        if not isinstance(wmodel, TopHatWakeModel):
-            raise TypeError(
-                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not a TopHatWakeModel"
-            )
+        self.check_wmodel(wmodel, error=True)
 
         wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
         x = wcoos[:, :, 0, 0]

foxes/models/turbine_types/PCt_file.py

@@ -103,6 +103,7 @@ class PCtFile(TurbineType):
 
     def __repr__(self):
         a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}, rho={self.rho}"
+        a += f", var_ws_ct={self.WSCT}, var_ws_P={self.WSP}"
         return f"{type(self).__name__}({a})"
 
     def output_farm_vars(self, algo):