foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/algorithms/downwind/models/init_farm_data.py

@@ -0,0 +1,134 @@
+import numpy as np
+
+from foxes.core import FarmDataModel, TData
+import foxes.variables as FV
+import foxes.constants as FC
+
+
+class InitFarmData(FarmDataModel):
+    """
+    Sets basic turbine data and applies downwind order
+
+    :group: algorithms.downwind.models
+
+    """
+
+    def __init__(self):
+        """
+        Constructor.
+        """
+        super().__init__(pre_rotor=True)
+
+    def output_farm_vars(self, algo):
+        """
+        The variables which are being modified by the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        output_vars: list of str
+            The output variable names
+
+        """
+        return [
+            FV.X,
+            FV.Y,
+            FV.H,
+            FV.D,
+            FV.WD,
+            FV.YAW,
+            FV.ORDER,
+            FV.WEIGHT,
+            FV.ORDER_SSEL,
+            FV.ORDER_INV,
+        ]
+
+    def calculate(self, algo, mdata, fdata):
+        """ "
+        The main model calculation.
+
+        This function is executed on a single chunk of data,
+        all computations should be based on numpy arrays.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.Data
+            The model data
+        fdata: foxes.core.Data
+            The farm data
+
+        Returns
+        -------
+        results: dict
+            The resulting data, keys: output variable str.
+            Values: numpy.ndarray with shape (n_states, n_turbines)
+
+        """
+        # prepare:
+        n_states = fdata.n_states
+        n_turbines = algo.n_turbines
+
+        # define FV.TXYH as vector [X, Y, H]:
+        fdata[FV.TXYH] = np.full((n_states, n_turbines, 3), np.nan, dtype=FC.DTYPE)
+        fdata.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
+        for i, v in enumerate([FV.X, FV.Y, FV.H]):
+            fdata[v] = fdata[FV.TXYH][..., i]
+            fdata.dims[v] = (FC.STATE, FC.TURBINE)
+
+        # set X, Y, H, D:
+        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=FC.DTYPE)
+        for ti, t in enumerate(algo.farm.turbines):
+
+            if len(t.xy.shape) == 1:
+                fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
+            else:
+                i0 = fdata.states_i0()
+                s = np.s_[i0 : i0 + fdata.n_states]
+                fdata[FV.TXYH][:, ti, :2] = t.xy[s]
+
+            H = t.H
+            if H is None:
+                H = algo.farm_controller.turbine_types[ti].H
+            fdata[FV.TXYH][:, ti, 2] = H
+
+            D = t.D
+            if D is None:
+                D = algo.farm_controller.turbine_types[ti].D
+            fdata[FV.D][:, ti] = D
+
+        # calc WD and YAW at rotor centres:
+        tdata = TData.from_points(points=fdata[FV.TXYH])
+        sres = algo.states.calculate(algo, mdata, fdata, tdata)
+        fdata[FV.WD] = sres[FV.WD][:, :, 0]
+        del tdata, sres
+
+        # calculate and inverse:
+        order = algo.wake_frame.calc_order(algo, mdata, fdata)
+        ssel = np.zeros_like(order)
+        ssel[:] = np.arange(n_states)[:, None]
+        fdata[FV.ORDER] = order
+        fdata[FV.ORDER_SSEL] = ssel
+        fdata[FV.ORDER_INV] = np.zeros_like(order)
+        fdata[FV.ORDER_INV][ssel, order] = np.arange(n_turbines)[None, :]
+
+        # apply downwind order to all data:
+        fdata[FV.TXYH] = fdata[FV.TXYH][ssel, order]
+        for i, v in enumerate([FV.X, FV.Y, FV.H]):
+            fdata[v] = fdata[FV.TXYH][..., i]
+        for v in [FV.D, FV.WD, FV.WEIGHT]:
+            if np.any(fdata[v] != fdata[v][0, 0, None, None]):
+                fdata[v] = fdata[v][ssel, order]
+        fdata[FV.YAW] = fdata[FV.WD].copy()
+        for k in mdata.keys():
+            if tuple(mdata.dims[k][:2]) == (FC.STATE, FC.TURBINE) and np.any(
+                mdata[k] != mdata[k][0, 0, None, None]
+            ):
+                mdata[k] = mdata[k][ssel, order]
+
+        return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -16,7 +16,7 @@ class PointWakesCalculation(PointDataModel):
     emodels_cpars: list of dict
         The calculation parameters for extra models
     wake_models: list of foxes.core.WakeModel
-        The wake models, default: from algo
+        The wake models to be used
 
     :group: algorithms.downwind.models
 
@@ -33,7 +33,7 @@ class PointWakesCalculation(PointDataModel):
         emodels_cpars: list of dict, optional
             The calculation parameters for extra models
         wake_models: list of foxes.core.WakeModel, optional
-            The wake models, default: from algo
+            Specific wake models to be used
 
         """
         super().__init__()
@@ -86,14 +86,14 @@ class PointWakesCalculation(PointDataModel):
         """
         return self.pvars
 
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        wmodels,
+        tdata,
+        downwind_index,
+        wmodel,
         wdeltas,
     ):
         """
@@ -107,30 +107,23 @@ class PointWakesCalculation(PointDataModel):
             The model data
         fdata: foxes.core.Data
             The farm data
-        pdata: foxes.core.Data
-            The point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        wmodels: list of foxes.core.WakeModel
-            The wake models
+        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_points, ...)
+            shape (n_states, n_targets, n_tpoints, ...)
 
         """
-        wcoos = algo.wake_frame.get_wake_coos(
-            algo, mdata, fdata, pdata, states_source_turbine
-        )
-
-        for w in wmodels:
-            w.contribute_to_wake_deltas(
-                algo, mdata, fdata, pdata, states_source_turbine, wcoos, wdeltas
-            )
+        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, pdata, states_source_turbine=None):
+    def calculate(self, algo, mdata, fdata, tdata, downwind_index=None):
         """ "
         The main model calculation.
 
@@ -145,55 +138,51 @@ class PointWakesCalculation(PointDataModel):
             The model data
         fdata: foxes.core.Data
             The farm data
-        pdata: foxes.core.Data
-            The point data
-        states_source_turbine: numpy.ndarray, optional
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,).
-            Default: include all turbines
+        tdata: foxes.core.Data
+            The target point data
+        downwind_index: int
+            The index in the downwind order of the wake
+            causing turbine
 
         Returns
-        -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
 
-        torder = fdata[FV.ORDER].astype(FC.ITYPE)
-        n_order = torder.shape[1]
-        wake_models = algo.wake_models if self.wake_models is None else self.wake_models
-
-        wdeltas = {}
-        wmodels = []
-        for w in wake_models:
-            hdeltas = {}
-            w.init_wake_deltas(algo, mdata, fdata, pdata, hdeltas)
-            if len(set(self.pvars).intersection(hdeltas.keys())):
-                wdeltas.update(hdeltas)
-                wmodels.append(w)
-            del hdeltas
-
-        if states_source_turbine is None:
-            for oi in range(n_order):
-                o = torder[:, oi]
-                self.contribute_to_wake_deltas(
-                    algo, mdata, fdata, pdata, o, wmodels, wdeltas
-                )
-        else:
-            self.contribute_to_wake_deltas(
-                algo, mdata, fdata, pdata, states_source_turbine, wmodels, wdeltas
-            )
-
-        amb_res = {v: pdata[FV.var2amb[v]] for v in wdeltas if v in FV.var2amb}
-        for w in wmodels:
-            w.finalize_wake_deltas(algo, mdata, fdata, pdata, amb_res, wdeltas)
-
-        for v in self.pvars:
-            if v in wdeltas:
-                pdata[v] = amb_res[v] + wdeltas[v]
+        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)
+            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)
+
+                else:
+                    self.contribute(
+                        algo, mdata, fdata, tdata, downwind_index, wmodel, wdeltas
+                    )
+
+                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)
+
+                for v in res.keys():
+                    if v in wdeltas:
+                        res[v] += wdeltas[v]
+
+        for v in res.keys():
+            tdata[v] = res[v]
 
         if self.emodels is not None:
-            self.emodels.calculate(algo, mdata, fdata, pdata, self.emodels_cpars)
+            self.emodels.calculate(algo, mdata, fdata, tdata, self.emodels_cpars)
 
-        return {v: pdata[v] for v in self.pvars}
+        return {v: tdata[v] for v in self.pvars}

foxes/algorithms/downwind/models/{calc_order.py → reorder_farm_output.py}

@@ -1,42 +1,34 @@
-import foxes.variables as FV
+import numpy as np
+
 from foxes.core import FarmDataModel
+import foxes.variables as FV
 
 
-class CalcOrder(FarmDataModel):
+class ReorderFarmOutput(FarmDataModel):
     """
-    This model calculates the turbine evaluation
-    order, via wake frames.
+    Reorders final results to state-turbine dimensions
+
+    Attributes
+    ----------
+    outputs: list of str, optional
+        The output variables, or None for defaults
 
     :group: algorithms.downwind.models
 
     """
 
-    def sub_models(self):
+    def __init__(self, outputs):
         """
-        List of all sub-models
-
-        Returns
-        -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return [self._wframe]
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
+        Constructor
 
         Parameters
         ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
+        outputs: list of str, optional
+            The output variables, or None for defaults
 
         """
-        self._wframe = algo.wake_frame
-        super().initialize(algo, verbosity)
+        super().__init__(pre_rotor=False)
+        self.outputs = outputs
 
     def output_farm_vars(self, algo):
         """
@@ -53,7 +45,7 @@ class CalcOrder(FarmDataModel):
             The output variable names
 
         """
-        return [FV.ORDER]
+        return self.outputs if self.outputs is not None else algo.farm_vars
 
     def calculate(self, algo, mdata, fdata):
         """ "
@@ -78,4 +70,14 @@ class CalcOrder(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        return {FV.ORDER: self._wframe.calc_order(algo, mdata, fdata)}
+        ssel = fdata[FV.ORDER_SSEL]
+        order_inv = fdata[FV.ORDER_INV]
+
+        out = {}
+        for v in self.output_farm_vars(algo):
+            if v != FV.ORDER and np.any(fdata[v] != fdata[v][0, 0, None, None]):
+                out[v] = fdata[v][ssel, order_inv]
+            else:
+                out[v] = fdata[v]
+
+        return out

foxes/algorithms/iterative/iterative.py

@@ -44,7 +44,7 @@ class Iterative(Downwind):
         except AttributeError:
             return super().get_model(name)
 
-    def __init__(self, *args, max_it=None, conv_crit=None, **kwargs):
+    def __init__(self, *args, max_it=None, conv_crit="default", mod_cutin={}, **kwargs):
         """
         Constructor.
 
@@ -56,6 +56,8 @@ class Iterative(Downwind):
             The maximal number of iterations
         conv_crit: foxes.algorithms.iterative.ConvCrit, optional
             The convergence criteria
+        mod_cutin: dict, optional
+            Parameters for cutin modification
         kwargs: dict, optional
             Keyword arguments for Downwind
 
@@ -64,15 +66,16 @@ class Iterative(Downwind):
 
         self.max_it = 2 * self.farm.n_turbines if max_it is None else max_it
         self.conv_crit = (
-            self.get_model("DefaultConv")() if conv_crit is None else conv_crit
+            self.get_model("DefaultConv")() if conv_crit == "default" else conv_crit
         )
         self.prev_farm_results = None
         self._it = None
         self._mlist = None
         self._reamb = False
-        self._urelax = Dict(
-            first={}, pre_rotor={}, post_rotor={}, pre_wake={FV.CT: 0.5}, last={}
-        )
+        self._urelax = None
+
+        self._mod_cutin = dict(modify_ct=True, modify_P=False)
+        self._mod_cutin.update(mod_cutin)
 
     def set_urelax(self, entry_point, **urel):
         """
@@ -89,8 +92,25 @@ class Iterative(Downwind):
         """
         if self.initialized:
             raise ValueError(f"Attempt to set_urelax after initialization")
+        if self._urelax is None:
+            self._urelax = Dict(
+                first={},
+                pre_rotor={},
+                post_rotor={},
+                pre_wake={},
+                last={},
+            )
         self._urelax[entry_point].update(urel)
 
+    def initialize(self):
+        """
+        Initializes the algorithm.
+        """
+        super().initialize()
+        if len(self._mod_cutin):
+            for t in self.farm_controller.turbine_types:
+                t.modify_cutin(**self._mod_cutin)
+
     @property
     def urelax(self):
         """
@@ -119,46 +139,50 @@ class Iterative(Downwind):
 
     def _collect_farm_models(
         self,
+        outputs,
         calc_parameters,
         ambient,
     ):
         """
         Helper function that creates model list
         """
-
         if self._it == 0:
             self._mlist0, self._calc_pars0 = super()._collect_farm_models(
-                calc_parameters,
+                outputs=False,
+                calc_parameters=calc_parameters,
                 ambient=ambient,
             )
 
             n = 0
-            if len(self._urelax["first"]):
-                self._mlist0.insert(0, mdls.URelax(**self._urelax["first"]))
-                self._calc_pars0.insert(0, {})
-                self._reamb = True
-                n += 1
-
-            if len(self._urelax["pre_rotor"]):
-                self._mlist0.insert(2 + n, mdls.URelax(**self._urelax["pre_rotor"]))
-                self._calc_pars0.insert(2 + n, {})
-                self._reamb = True
-                n += 1
-
-            if len(self._urelax["post_rotor"]):
-                self._mlist0.insert(4 + n, mdls.URelax(**self._urelax["post_rotor"]))
-                self._calc_pars0.insert(4 + n, {})
-                self._reamb = True
-                n += 1
-
-            if len(self._urelax["pre_wake"]):
-                self._mlist0.models[7 + n].urelax = mdls.URelax(
-                    **self._urelax["pre_wake"]
-                )
-
-            if len(self._urelax["last"]):
-                self._mlist0.append(mdls.URelax(**self._urelax["last"]))
-                self._calc_pars0.append({})
+            if self._urelax is not None:
+                if len(self._urelax["first"]):
+                    self._mlist0.insert(0, mdls.URelax(**self._urelax["first"]))
+                    self._calc_pars0.insert(0, {})
+                    self._reamb = True
+                    n += 1
+
+                if len(self._urelax["pre_rotor"]):
+                    self._mlist0.insert(2 + n, mdls.URelax(**self._urelax["pre_rotor"]))
+                    self._calc_pars0.insert(2 + n, {})
+                    self._reamb = True
+                    n += 1
+
+                if len(self._urelax["post_rotor"]):
+                    self._mlist0.insert(
+                        4 + n, mdls.URelax(**self._urelax["post_rotor"])
+                    )
+                    self._calc_pars0.insert(4 + n, {})
+                    self._reamb = True
+                    n += 1
+
+                if len(self._urelax["pre_wake"]):
+                    self._mlist0.models[5 + n].urelax = mdls.URelax(
+                        **self._urelax["pre_wake"]
+                    )
+
+                if len(self._urelax["last"]):
+                    self._mlist0.append(mdls.URelax(**self._urelax["last"]))
+                    self._calc_pars0.append({})
 
             return self._mlist0, self._calc_pars0
 
@@ -170,19 +194,34 @@ class Iterative(Downwind):
             calc_pars = []
             mlist = FarmDataModelList(models=[])
 
-            # add under-relaxation during wake calculation:
-            urelax = None
-            if len(self._urelax["pre_wake"]):
-                urelax = mdls.URelax(**self._urelax["pre_wake"])
+            # do not rotate back from downwind order:
+            if not self._final_run:
 
-            # add model that calculates wake effects:
-            mlist.models.append(self.get_model("FarmWakesCalculation")(urelax=urelax))
-            calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
+                # add under-relaxation during wake calculation:
+                urelax = None
+                if self._urelax is not None and len(self._urelax["pre_wake"]):
+                    urelax = mdls.URelax(**self._urelax["pre_wake"])
 
-            # add under-relaxation:
-            if len(self._urelax["last"]):
-                mlist.append(mdls.URelax(**self._urelax["last"]))
-                calc_pars.append({})
+                # add model that calculates wake effects:
+                mlist.models.append(
+                    self.get_model("FarmWakesCalculation")(urelax=urelax)
+                )
+                calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
+
+                # add under-relaxation:
+                if self._urelax is not None and len(self._urelax["last"]):
+                    mlist.append(mdls.URelax(**self._urelax["last"]))
+                    calc_pars.append({})
+
+            # rotate back from downwind order:
+            else:
+
+                # add model that calculates wake effects:
+                # mlist.models.append(self.get_model("FarmWakesCalculation")(urelax=None))
+                # calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
+
+                mlist.models.append(self.get_model("ReorderFarmOutput")(outputs))
+                calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
             return mlist, calc_pars
 
@@ -218,23 +257,33 @@ class Iterative(Downwind):
             dimensions (state, turbine)
 
         """
+        outputs = kwargs.pop("outputs", self.DEFAULT_FARM_OUTPUTS)
+        outputs = list(set(outputs + [FV.ORDER_SSEL, FV.ORDER_INV, FV.WEIGHT]))
+
         fres = None
         self._it = -1
+        self._final_run = False
         while self._it < self.max_it:
             self._it += 1
 
             self.print(f"\nAlgorithm {self.name}: Iteration {self._it}\n", vlim=0)
 
             self.prev_farm_results = fres
-            fres = super().calc_farm(finalize=False, **kwargs)
+            fres = super().calc_farm(outputs=None, finalize=False, **kwargs)
 
-            conv = self.conv_crit.check_converged(
-                self, self.prev_farm_results, fres, verbosity=self.verbosity + 1
-            )
+            if self.conv_crit is not None:
+                conv = self.conv_crit.check_converged(
+                    self, self.prev_farm_results, fres, verbosity=self.verbosity + 1
+                )
 
-            if conv:
-                self.print(f"\nAlgorithm {self.name}: Convergence reached.\n", vlim=0)
-                break
+                if conv:
+                    self.print(
+                        f"\nAlgorithm {self.name}: Convergence reached.\n", vlim=0
+                    )
+                    self.print("Starting final run")
+                    self._final_run = True
+                    fres = super().calc_farm(outputs=outputs, finalize=False, **kwargs)
+                    break
 
             if self._it == 0:
                 self.verbosity -= 1

foxes/algorithms/iterative/models/convergence.py

@@ -273,8 +273,8 @@ class DefaultConv(ConvVarDelta):
         """
         super().__init__(
             {
-                FV.REWS: 1e-5,
-                FV.TI: 1e-6,
-                FV.CT: 1e-6,
+                FV.REWS: 1e-6,
+                FV.TI: 1e-7,
+                FV.CT: 1e-7,
             }
         )