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

foxes/VERSION

@@ -1 +1 @@
-0.7.2
+0.7.3

foxes/algorithms/downwind/downwind.py

@@ -28,6 +28,9 @@ class Downwind(Algorithm):
     partial_wakes: dict
         The partial wakes mapping. Key: wake model name,
         value: foxes.core.PartialWakesModel
+    ground_models: dict
+        The ground models mapping. Key: wake model name,
+        value: foxes.core.GroundModel
     farm_controller: foxes.core.FarmController
         The farm controller
     n_states: int
@@ -65,9 +68,9 @@ class Downwind(Algorithm):
         rotor_model="centre",
         wake_frame="rotor_wd",
         partial_wakes=None,
+        ground_models=None,
         farm_controller="basic_ctrl",
         chunks={FC.STATE: 1000, FC.POINT: 4000},
-        wake_mirrors={},
         mbook=None,
         dbook=None,
         verbosity=1,
@@ -93,15 +96,15 @@ class Downwind(Algorithm):
         partial_wakes: dict, list or str, optional
             The partial wakes mapping. Key: wake model name,
             value: partial wake model name
+        ground_models: dict, list or str, optional
+            The ground models mapping. Key: wake model name,
+            value: ground model name
         farm_controller: str
             The farm controller. Will be
             looked up in the model book
         chunks: dict
             The chunks choice for running in parallel with dask,
             e.g. `{"state": 1000}` for chunks of 1000 states
-        wake_mirrors: dict
-            Switch on wake mirrors for wake models.
-            Key: wake model name, value: list of heights
         mbook: foxes.ModelBook, optional
             The model book
         dbook: foxes.DataBook, optional
@@ -129,51 +132,60 @@ class Downwind(Algorithm):
         for w in wake_models:
             m = self.mbook.wake_models[w]
             m.name = w
-
-            # optionally add wake mirrors:
-            if w in wake_mirrors:
-                hts = wake_mirrors[w]
-                if isinstance(m, fm.wake_models.WakeMirror):
-                    if list(m.heights) != list(hts):
-                        raise ValueError(
-                            f"Wake model '{w}' is mirrored with heights {m.heights}, cannot apply WakeMirror with heights {hts}"
+            self.wake_models[w] = m
+
+        def _set_wspecific(descr, target, values, deffunc, mbooks, checkw):
+            if values is None:
+                values = {}
+            if isinstance(values, list) and len(values) == 1:
+                values = values[0]
+            if isinstance(values, str):
+                for w in wake_models:
+                    try:
+                        pw = values
+                        if checkw:
+                            mbooks[pw].check_wmodel(self.wake_models[w], error=True)
+                    except TypeError:
+                        pw = deffunc(self.wake_models[w])
+                    target[w] = mbooks[pw]
+                    target[w].name = pw
+            elif isinstance(values, list):
+                for i, w in enumerate(wake_models):
+                    if i >= len(values):
+                        raise IndexError(
+                            f"Not enough {descr} in list {values}, expecting {len(wake_models)}"
                         )
-                else:
-                    self.wake_models[w] = fm.wake_models.WakeMirror(m, heights=hts)
-
+                    pw = values[i]
+                    target[w] = mbooks[pw]
+                    target[w].name = pw
             else:
-                self.wake_models[w] = m
+                for w in wake_models:
+                    if w in values:
+                        pw = values[w]
+                    else:
+                        pw = deffunc(self.wake_models[w])
+                    target[w] = mbooks[pw]
+                    target[w].name = pw
 
         self.partial_wakes = {}
-        if partial_wakes is None:
-            partial_wakes = {}
-        if isinstance(partial_wakes, list) and len(partial_wakes) == 1:
-            partial_wakes = partial_wakes[0]
-        if isinstance(partial_wakes, str):
-            for w in wake_models:
-                try:
-                    pw = partial_wakes
-                except TypeError:
-                    pw = mbook.default_partial_wakes(self.wake_models[w])
-                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
-                self.partial_wakes[w].name = pw
-        elif isinstance(partial_wakes, list):
-            for i, w in enumerate(wake_models):
-                if i >= len(partial_wakes):
-                    raise IndexError(
-                        f"Not enough partial wakes in list {partial_wakes}, expecting {len(wake_models)}"
-                    )
-                pw = partial_wakes[i]
-                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
-                self.partial_wakes[w].name = pw
-        else:
-            for w in wake_models:
-                if w in partial_wakes:
-                    pw = partial_wakes[w]
-                else:
-                    pw = mbook.default_partial_wakes(self.wake_models[w])
-                self.partial_wakes[w] = self.mbook.partial_wakes[pw]
-                self.partial_wakes[w].name = pw
+        _set_wspecific(
+            descr="partial wakes",
+            target=self.partial_wakes,
+            values=partial_wakes,
+            deffunc=mbook.default_partial_wakes,
+            mbooks=self.mbook.partial_wakes,
+            checkw=True,
+        )
+
+        self.ground_models = {}
+        _set_wspecific(
+            descr="ground models",
+            target=self.ground_models,
+            values=ground_models,
+            deffunc=lambda w: "no_ground",
+            mbooks=self.mbook.ground_models,
+            checkw=False,
+        )
 
         self.farm_controller = self.mbook.farm_controllers[farm_controller]
         self.farm_controller.name = farm_controller

foxes/algorithms/downwind/models/farm_wakes_calc.py

@@ -75,10 +75,12 @@ class FarmWakesCalculation(FarmDataModel):
             wdelta = {v: d[s] for v, d in wdeltas.items()}
             return tdata, wdelta
 
-        def _evaluate(tdata, amb_res, weights, wake_res, wdeltas, oi, wmodel, pwake):
+        def _evaluate(
+            gmodel, tdata, amb_res, weights, wake_res, wdeltas, oi, wmodel, pwake
+        ):
             """Helper function for data evaluation at turbines"""
-            wres = pwake.finalize_wakes(
-                algo, mdata, fdata, tdata, amb_res, weights, wdeltas, wmodel, oi
+            wres = gmodel.finalize_farm_wakes(
+                algo, mdata, fdata, tdata, amb_res, weights, wdeltas, wmodel, oi, pwake
             )
 
             hres = {v: d[:, oi, None] for v, d in wake_res.items()}
@@ -101,8 +103,11 @@ class FarmWakesCalculation(FarmDataModel):
         run_down = None
         for wname, wmodel in algo.wake_models.items():
             pwake = algo.partial_wakes[wname]
+            gmodel = algo.ground_models[wname]
             tdatap = pwake2tdata[pwake.name]
-            wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
+            wdeltas = gmodel.new_farm_wake_deltas(
+                algo, mdata, fdata, tdatap, wmodel, pwake
+            )
 
             # downwind:
             if wmodel.affects_downwind:
@@ -110,6 +115,7 @@ class FarmWakesCalculation(FarmDataModel):
                 for oi in range(n_turbines):
                     if oi > 0:
                         _evaluate(
+                            gmodel,
                             tdatap,
                             amb_res,
                             weights,
@@ -122,7 +128,9 @@ class FarmWakesCalculation(FarmDataModel):
 
                     if oi < n_turbines - 1:
                         tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, oi + 1 :])
-                        pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+                        gmodel.contribute_to_farm_wakes(
+                            algo, mdata, fdata, tdata, oi, wdelta, wmodel, pwake
+                        )
 
             # upwind:
             else:
@@ -130,6 +138,7 @@ class FarmWakesCalculation(FarmDataModel):
                 for oi in range(n_turbines - 1, -1, -1):
                     if oi < n_turbines - 1:
                         _evaluate(
+                            gmodel,
                             tdatap,
                             amb_res,
                             weights,
@@ -142,7 +151,9 @@ class FarmWakesCalculation(FarmDataModel):
 
                     if oi > 0:
                         tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, :oi])
-                        pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+                        gmodel.contribute_to_farm_wakes(
+                            algo, mdata, fdata, tdata, oi, wdelta, wmodel, pwake
+                        )
 
             if run_up is not None and run_down is not None:
                 raise KeyError(

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -1,6 +1,7 @@
+import numpy as np
+from foxes.core import PointDataModel, TData
 import foxes.variables as FV
 import foxes.constants as FC
-from foxes.core import PointDataModel
 
 
 class PointWakesCalculation(PointDataModel):
@@ -86,43 +87,6 @@ class PointWakesCalculation(PointDataModel):
         """
         return self.pvars
 
-    def contribute(
-        self,
-        algo,
-        mdata,
-        fdata,
-        tdata,
-        downwind_index,
-        wmodel,
-        wdeltas,
-    ):
-        """
-        Contribute to wake deltas from source turbines
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-        tdata: foxes.core.Data
-            The target point data
-        downwind_index: int
-            The index in the downwind order
-        wmodel: foxes.core.WakeModel
-            The wake model
-        wdeltas: dict
-            The wake deltas, are being modified ob the fly.
-            Key: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_targets, n_tpoints, ...)
-
-        """
-        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
-        wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wdeltas)
-
     def calculate(self, algo, mdata, fdata, tdata, downwind_index=None):
         """ "
         The main model calculation.
@@ -151,29 +115,33 @@ class PointWakesCalculation(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
-
         res = {}
         wmodels = (
             algo.wake_models.values() if self.wake_models is None else self.wake_models
         )
         for wmodel in wmodels:
-            wdeltas = wmodel.new_wake_deltas(algo, mdata, fdata, tdata)
+            pwake = algo.partial_wakes[wmodel.name]
+            gmodel = algo.ground_models[wmodel.name]
+
+            wdeltas = gmodel.new_point_wake_deltas(algo, mdata, fdata, tdata, wmodel)
+
             if len(set(self.pvars).intersection(wdeltas.keys())):
 
                 if downwind_index is None:
                     for oi in range(fdata.n_turbines):
-                        self.contribute(algo, mdata, fdata, tdata, oi, wmodel, wdeltas)
-
+                        gmodel.contribute_to_point_wakes(
+                            algo, mdata, fdata, tdata, oi, wdeltas, wmodel
+                        )
                 else:
-                    self.contribute(
-                        algo, mdata, fdata, tdata, downwind_index, wmodel, wdeltas
+                    gmodel.contribute_to_point_wakes(
+                        algo, mdata, fdata, tdata, downwind_index, wdeltas, wmodel
                     )
 
                 for v in self.pvars:
                     if v not in res and v in tdata:
                         res[v] = tdata[v].copy()
 
-                wmodel.finalize_wake_deltas(algo, mdata, fdata, res, wdeltas)
+                gmodel.finalize_point_wakes(algo, mdata, fdata, res, wdeltas, wmodel)
 
                 for v in res.keys():
                     if v in wdeltas:

foxes/algorithms/iterative/iterative.py

@@ -64,7 +64,7 @@ class Iterative(Downwind):
         """
         super().__init__(*args, **kwargs)
 
-        self.max_it = 2 * self.farm.n_turbines if max_it is None else max_it
+        self.max_it = 2 + self.farm.n_turbines**2 if max_it is None else max_it
         self.conv_crit = (
             self.get_model("DefaultConv")() if conv_crit == "default" else conv_crit
         )

foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -109,6 +109,7 @@ class FarmWakesCalculation(FarmDataModel):
         n_turbines = mdata.n_turbines
         for wname, wmodel in algo.wake_models.items():
             pwake = algo.partial_wakes[wname]
+            gmodel = algo.ground_models[wname]
             tdatap = pwake2tdata[pwake.name]
             wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
 
@@ -116,15 +117,28 @@ class FarmWakesCalculation(FarmDataModel):
 
                 if oi > 0:
                     tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, :oi])
-                    pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+                    gmodel.contribute_to_farm_wakes(
+                        algo, mdata, fdata, tdata, oi, wdelta, wmodel, pwake
+                    )
 
                 if oi < n_turbines - 1:
                     tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, oi + 1 :])
-                    pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+                    gmodel.contribute_to_farm_wakes(
+                        algo, mdata, fdata, tdata, oi, wdelta, wmodel, pwake
+                    )
 
             for oi in range(n_turbines):
-                wres = pwake.finalize_wakes(
-                    algo, mdata, fdata, tdatap, amb_res, weights, wdeltas, wmodel, oi
+                wres = gmodel.finalize_farm_wakes(
+                    algo,
+                    mdata,
+                    fdata,
+                    tdatap,
+                    amb_res,
+                    weights,
+                    wdeltas,
+                    wmodel,
+                    oi,
+                    pwake,
                 )
                 for v, d in wres.items():
                     if v in wake_res:

foxes/constants.py

@@ -15,6 +15,11 @@ STATE = "state"
 :group: foxes.constants
 """
 
+TIME = "time"
+""" Time identifier
+:group: foxes.constants
+"""
+
 TURBINE = "turbine"
 """ Wind turbine identifier
 :group: foxes.constants

foxes/core/__init__.py

@@ -18,7 +18,8 @@ from .farm_controller import FarmController
 from .turbine import Turbine
 from .partial_wakes_model import PartialWakesModel
 from .wake_frame import WakeFrame
-from .wake_model import WakeModel, TurbineInductionModel
+from .wake_model import WakeModel, TurbineInductionModel, WakeK
 from .wake_superposition import WakeSuperposition
 from .vertical_profile import VerticalProfile
 from .axial_induction_model import AxialInductionModel
+from .ground_model import GroundModel

foxes/core/ground_model.py

@@ -0,0 +1,254 @@
+from .model import Model
+
+
+class GroundModel(Model):
+    """
+    Base class for ground models.
+    """
+
+    def new_farm_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        wmodel,
+        pwake,
+    ):
+        """
+        Creates new initial wake deltas, filled
+        with zeros.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.Data
+            The model data
+        fdata: foxes.core.Data
+            The farm data
+        tdata: foxes.core.Data
+            The target point data
+        wmodel: foxes.core.WakeModel
+            The wake model
+        pwake: foxes.core.PartialWakesModel
+            The partial wakes model
+
+        Returns
+        -------
+        wake_deltas: dict
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_turbines, n_tpoints, ...)
+
+        """
+        return pwake.new_wake_deltas(algo, mdata, fdata, tdata, wmodel)
+
+    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
+
+        """
+        pwake.contribute(algo, mdata, fdata, tdata, downwind_index, wake_deltas, wmodel)
+
+    def finalize_farm_wakes(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        amb_res,
+        rpoint_weights,
+        wake_deltas,
+        wmodel,
+        downwind_index,
+        pwake,
+    ):
+        """
+        Updates the wake_deltas at the selected target
+        downwind index.
+
+        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
+        tdata: foxes.core.Data
+            The target point data
+        amb_res: dict
+            The ambient results at the target points
+            of all rotors. Key: variable name, value
+            np.ndarray of shape:
+            (n_states, n_turbines, n_rotor_points)
+        rpoint_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: np.ndarray of shape
+            (n_states, n_turbines, n_tpoints)
+        wmodel: foxes.core.WakeModel
+            The wake model
+        downwind_index: int
+            The index in the downwind order
+
+        Returns
+        -------
+        final_wake_deltas: dict
+            The final wake deltas at the selected downwind
+            turbines. Key: variable name, value: np.ndarray
+            of shape (n_states, n_rotor_points)
+
+        """
+        return pwake.finalize_wakes(
+            algo,
+            mdata,
+            fdata,
+            tdata,
+            amb_res,
+            rpoint_weights,
+            wake_deltas,
+            wmodel,
+            downwind_index,
+        )
+
+    def new_point_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        wmodel,
+    ):
+        """
+        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
+        wmodel: foxes.core.WakeModel
+            The wake model
+
+        Returns
+        -------
+        wake_deltas: dict
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
+
+        """
+        return wmodel.new_wake_deltas(algo, mdata, fdata, tdata)
+
+    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
+
+        """
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
+
+    def finalize_point_wakes(
+        self,
+        algo,
+        mdata,
+        fdata,
+        amb_results,
+        wake_deltas,
+        wmodel,
+    ):
+        """
+        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)
+
+        """
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, amb_results, wake_deltas)

foxes/core/model.py

@@ -31,8 +31,9 @@ class Model(ABC):
             self._ids[t] = count(0)
         self._id = next(self._ids[t])
 
-        ext = "" if self._id == 0 else f"{self._id}"
-        self.name = f"{type(self).__name__}{ext}"
+        self.name = f"{type(self).__name__}"
+        if self._id > 0:
+            self.name += f"_instance{self._id}"
 
         self._store = {}
         self.__initialized = False

foxes/core/partial_wakes_model.py

@@ -23,6 +23,25 @@ class PartialWakesModel(Model):
 
     """
 
+    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
+
+        """
+        return True
+
     @abstractmethod
     def get_wake_points(self, algo, mdata, fdata):
         """
@@ -66,9 +85,6 @@ class PartialWakesModel(Model):
             The target point data
         wmodel: foxes.core.WakeModel
             The wake model
-        wpoints: numpy.ndarray
-            The wake evaluation points,
-            shape: (n_states, n_turbines, n_tpoints, 3)
 
         Returns
         -------