foxes 0.8.1__py3-none-any.whl → 1.0__py3-none-any.whl

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():
+                if m not in self.sub_models():
                     m.finalize(self, self.verbosity)
             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):
@@ -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/sequential/models/plugin.py

@@ -56,4 +56,4 @@ class SequentialPlugin:
             The final sequetial algorithm
 
         """
-        self.algo = None
+        self.algo = algo