foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -1,7 +1,5 @@
-import numpy as np
-from foxes.core import PointDataModel, TData
+from foxes.core import PointDataModel
 import foxes.variables as FV
-import foxes.constants as FC
 
 
 class PointWakesCalculation(PointDataModel):
@@ -55,7 +53,7 @@ class PointWakesCalculation(PointDataModel):
         """
         return [self.emodels] if self.emodels is not None else []
 
-    def initialize(self, algo, verbosity=0):
+    def initialize(self, algo, verbosity=0, force=False):
         """
         Initializes the model.
 
@@ -65,9 +63,11 @@ class PointWakesCalculation(PointDataModel):
             The calculation algorithm
         verbosity: int
             The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
 
         """
-        super().initialize(algo, verbosity)
+        super().initialize(algo, verbosity, force)
         self.pvars = algo.states.output_point_vars(algo)
 
     def output_point_vars(self, algo):
@@ -88,7 +88,7 @@ class PointWakesCalculation(PointDataModel):
         return self.pvars
 
     def calculate(self, algo, mdata, fdata, tdata, downwind_index=None):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -120,7 +120,6 @@ class PointWakesCalculation(PointDataModel):
             algo.wake_models.values() if self.wake_models is None else self.wake_models
         )
         for wmodel in wmodels:
-            pwake = algo.partial_wakes[wmodel.name]
             gmodel = algo.ground_models[wmodel.name]
 
             wdeltas = gmodel.new_point_wake_deltas(algo, mdata, fdata, tdata, wmodel)

foxes/algorithms/downwind/models/reorder_farm_output.py

@@ -48,7 +48,7 @@ class ReorderFarmOutput(FarmDataModel):
         return self.outputs if self.outputs is not None else algo.farm_vars
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -79,5 +79,4 @@ class ReorderFarmOutput(FarmDataModel):
                 out[v] = fdata[v][ssel, order_inv]
             else:
                 out[v] = fdata[v]
-
         return out

foxes/algorithms/downwind/models/set_amb_farm_results.py

@@ -42,7 +42,7 @@ class SetAmbFarmResults(FarmDataModel):
         return [FV.var2amb[v] for v in self.vars]
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -25,7 +25,7 @@ class SetAmbPointResults(PointDataModel):
         self.pvars = None
         self.vars = None
 
-    def initialize(self, algo, verbosity=0):
+    def initialize(self, algo, verbosity=0, force=False):
         """
         Initializes the model.
 
@@ -35,11 +35,13 @@ class SetAmbPointResults(PointDataModel):
             The calculation algorithm
         verbosity: int
             The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
 
         """
         self.pvars = algo.states.output_point_vars(algo)
         self.vars = [v for v in self.pvars if v in FV.var2amb]
-        super().initialize(algo, verbosity)
+        super().initialize(algo, verbosity, force)
 
     def output_point_vars(self, algo):
         """
@@ -59,7 +61,7 @@ class SetAmbPointResults(PointDataModel):
         return [FV.var2amb[v] for v in self.vars]
 
     def calculate(self, algo, mdata, fdata, pdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/algorithms/iterative/iterative.py

@@ -44,7 +44,14 @@ class Iterative(Downwind):
         except AttributeError:
             return super().get_model(name)
 
-    def __init__(self, *args, max_it=None, conv_crit="default", mod_cutin={}, **kwargs):
+    def __init__(
+        self,
+        *args,
+        max_it=None,
+        conv_crit="default",
+        mod_cutin={},
+        **kwargs,
+    ):
         """
         Constructor.
 
@@ -68,7 +75,7 @@ class Iterative(Downwind):
         self.conv_crit = (
             self.get_model("DefaultConv")() if conv_crit == "default" else conv_crit
         )
-        self.prev_farm_results = None
+        self.__prev_farm_results = None
         self._it = None
         self._mlist = None
         self._reamb = False
@@ -77,6 +84,22 @@ class Iterative(Downwind):
         self._mod_cutin = dict(modify_ct=True, modify_P=False)
         self._mod_cutin.update(mod_cutin)
 
+        self.verbosity = self.verbosity - 1
+
+    @property
+    def farm_results_downwind(self):
+        """
+        Gets the all-chunks farm results in downwind order
+        from the previous iteration
+
+        Returns
+        -------
+        fres: xarray.Datatset
+            The all-chunks farm results during calculations
+
+        """
+        return self.__prev_farm_results
+
     def set_urelax(self, entry_point, **urel):
         """
         Sets under-relaxation parameters.
@@ -215,11 +238,6 @@ class Iterative(Downwind):
 
             # 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, {}))
 
@@ -230,16 +248,26 @@ class Iterative(Downwind):
         if self._it == 0:
             super()._calc_farm_vars(mlist)
 
-    def _run_farm_calc(self, mlist, *data, **kwargs):
+    def _launch_parallel_farm_calc(self, mlist, *data, **kwargs):
         """Helper function for running the main farm calculation"""
-        ir = (
-            None
-            if self.prev_farm_results is None
-            else self.chunked(self.prev_farm_results)
+        return super()._launch_parallel_farm_calc(
+            mlist, *data, farm_data=self.__prev_farm_results, iterative=True, **kwargs
         )
-        return super()._run_farm_calc(mlist, *data, initial_results=ir, **kwargs)
 
-    def calc_farm(self, finalize=True, **kwargs):
+    @property
+    def final_iteration(self):
+        """
+        Flag for the final iteration
+
+        Returns
+        -------
+        flag: bool
+            Flag for the final iteration
+
+        """
+        return self._final_run
+
+    def calc_farm(self, finalize=True, ret_dwnd_order=False, **kwargs):
         """
         Calculate farm data.
 
@@ -247,6 +275,8 @@ class Iterative(Downwind):
         ----------
         finalize: bool
             Flag for finalization after calculation
+        ret_dwnd_order: bool
+            Also return the results in downwind order
         kwargs: dict, optional
             Arguments for calc_farm in the base class.
 
@@ -257,44 +287,54 @@ 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]))
+        outputs = kwargs.pop("outputs", None)
+        if outputs == "default":
+            outputs = self.DEFAULT_FARM_OUTPUTS
 
         fres = None
         self._it = -1
         self._final_run = False
+        fres_dwnd = None
         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
+            self.__prev_farm_results = fres
             fres = super().calc_farm(outputs=None, finalize=False, **kwargs)
 
+            fres_dwnd = fres
             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
+                if self.eval_conv_block():
+                    self.print(f"{self.name}: Convergence blocked", vlim=0)
+                else:
+                    conv = self.conv_crit.check_converged(
+                        self,
+                        self.__prev_farm_results,
+                        fres,
+                        verbosity=self.verbosity + 1,
                     )
-                    self.print("Starting final run")
-                    self._final_run = True
-                    fres = super().calc_farm(outputs=outputs, finalize=False, **kwargs)
-                    break
+                    if conv:
+                        self.print(
+                            f"\nAlgorithm {self.name}: Convergence reached.\n", vlim=0
+                        )
+                        break
 
-            if self._it == 0:
-                self.verbosity -= 1
+        # final run, recovers farm order of results:
+        self.print("Starting final run", vlim=0)
+        self._final_run = True
+        fres = super().calc_farm(outputs=outputs, finalize=False, **kwargs)
 
         # finalize models:
         if finalize:
-            self.print("\n")
+            self.print("\n", vlim=0)
             self.finalize()
             for m in self._mlist0.models:
-                if m not in self.all_models():
-                    m.finalize(self, self.verbosity)
+                if m not in self.sub_models():
+                    m.finalize(self, self.verbosity - 1)
             del self._mlist0, self._calc_pars0
 
-        return fres
+        if ret_dwnd_order:
+            return fres, fres_dwnd
+        else:
+            return fres

foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -2,6 +2,7 @@ import numpy as np
 from copy import deepcopy
 
 from foxes.core import FarmDataModel, TData
+import foxes.constants as FC
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -63,7 +64,7 @@ class FarmWakesCalculation(FarmDataModel):
         return [] if self.urelax is None else [self.urelax]
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -87,8 +88,8 @@ class FarmWakesCalculation(FarmDataModel):
         """
         # collect ambient rotor results and weights:
         rotor = algo.rotor_model
-        weights = rotor.from_data_or_store(rotor.RWEIGHTS, algo, mdata)
-        amb_res = rotor.from_data_or_store(rotor.AMBRES, algo, mdata)
+        weights = algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata)
+        amb_res = algo.get_from_chunk_store(FC.AMB_ROTOR_RES, mdata=mdata)
 
         # generate all wake evaluation points
         # (n_states, n_order, n_rpoints)
@@ -99,9 +100,9 @@ class FarmWakesCalculation(FarmDataModel):
                 tpoints, tweights = pwake.get_wake_points(algo, mdata, fdata)
                 pwake2tdata[pwake.name] = TData.from_tpoints(tpoints, tweights)
 
-        def _get_wdata(tdatap, wdeltas, s):
+        def _get_wdata(tdatap, wdeltas, variables, s):
             """Helper function for wake data extraction"""
-            tdata = tdatap.get_slice(s, keep=True)
+            tdata = tdatap.get_slice(variables, s)
             wdelta = {v: d[s] for v, d in wdeltas.items()}
             return tdata, wdelta
 
@@ -116,13 +117,17 @@ class FarmWakesCalculation(FarmDataModel):
             for oi in range(n_turbines):
 
                 if oi > 0:
-                    tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, :oi])
+                    tdata, wdelta = _get_wdata(
+                        tdatap, wdeltas, [FC.STATE, FC.TARGET], np.s_[:, :oi]
+                    )
                     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 :])
+                    tdata, wdelta = _get_wdata(
+                        tdatap, wdeltas, [FC.STATE, FC.TARGET], np.s_[:, oi + 1 :]
+                    )
                     gmodel.contribute_to_farm_wakes(
                         algo, mdata, fdata, tdata, oi, wdelta, wmodel, pwake
                     )

foxes/algorithms/iterative/models/urelax.py

@@ -10,7 +10,7 @@ class URelax(FarmDataModel):
     ----------
     urel: dict
         The variables and their under-relaxation
-        factors bewteen 0 and 1
+        factors between 0 and 1
 
     :group: algorithms.iterative.models
 
@@ -24,7 +24,7 @@ class URelax(FarmDataModel):
         ----------
         urel: dict
             The variables and their under-relaxation
-            factors bewteen 0 and 1
+            factors between 0 and 1
 
         """
         super().__init__()
@@ -49,7 +49,7 @@ class URelax(FarmDataModel):
         return list(self.urel.keys())
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/algorithms/sequential/models/plugin.py

@@ -6,7 +6,7 @@ class SequentialPlugin:
     Parameters
     ----------
     algo: foxes.algorithms.sequential.Sequential
-        The sequetial algorithm
+        The sequential algorithm
 
     :group: algorithms.sequential.models
 
@@ -25,7 +25,7 @@ class SequentialPlugin:
         Parameters
         ----------
         algo: foxes.algorithms.sequential.Sequential
-            The current sequetial algorithm
+            The current sequential algorithm
 
         """
         self.algo = algo
@@ -37,7 +37,7 @@ class SequentialPlugin:
         Parameters
         ----------
         algo: foxes.algorithms.sequential.Sequential
-            The latest sequetial algorithm
+            The latest sequential algorithm
         fres: xarray.Dataset
             The latest farm results
         pres: xarray.Dataset, optional
@@ -53,7 +53,7 @@ class SequentialPlugin:
         Parameters
         ----------
         algo: foxes.algorithms.sequential.Sequential
-            The final sequetial algorithm
+            The final sequential algorithm
 
         """
-        self.algo = None
+        self.algo = algo

foxes/algorithms/sequential/models/seq_state.py

@@ -135,7 +135,7 @@ class SeqState(States):
         return self.states.output_point_vars(algo)
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,