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

foxes/algorithms/downwind/downwind.py

@@ -1,4 +1,4 @@
-from foxes.core import Algorithm, FarmDataModelList
+from foxes.core import Algorithm, FarmDataModelList, get_engine
 from foxes.core import PointDataModel, PointDataModelList, FarmController
 import foxes.models as fm
 import foxes.variables as FV
@@ -49,6 +49,7 @@ class Downwind(Algorithm):
         FV.AMB_REWS,
         FV.AMB_TI,
         FV.AMB_RHO,
+        FV.AMB_CT,
         FV.AMB_P,
         FV.WD,
         FV.REWS,
@@ -70,10 +71,8 @@ class Downwind(Algorithm):
         partial_wakes=None,
         ground_models=None,
         farm_controller="basic_ctrl",
-        chunks={FC.STATE: 1000, FC.POINT: 4000},
         mbook=None,
-        dbook=None,
-        verbosity=1,
+        **kwargs,
     ):
         """
         Constructor.
@@ -102,35 +101,29 @@ class Downwind(Algorithm):
         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
         mbook: foxes.ModelBook, optional
             The model book
-        dbook: foxes.DataBook, optional
-            The data book, or None for default
-        verbosity: int
-            The verbosity level, 0 means silent
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
         if mbook is None:
             mbook = fm.ModelBook()
 
-        super().__init__(mbook, farm, chunks, verbosity, dbook)
+        super().__init__(mbook, farm, **kwargs)
 
-        self.states = states
+        self.__states = states
         self.n_states = None
-        self.states_data = None
 
-        self.rotor_model = self.mbook.rotor_models[rotor_model]
+        self.__rotor_model = self.mbook.rotor_models.get_item(rotor_model)
         self.rotor_model.name = rotor_model
 
-        self.wake_frame = self.mbook.wake_frames[wake_frame]
+        self.__wake_frame = self.mbook.wake_frames.get_item(wake_frame)
         self.wake_frame.name = wake_frame
 
-        self.wake_models = {}
+        self.__wake_models = {}
         for w in wake_models:
-            m = self.mbook.wake_models[w]
+            m = self.mbook.wake_models.get_item(w)
             m.name = w
             self.wake_models[w] = m
 
@@ -144,10 +137,12 @@ class Downwind(Algorithm):
                     try:
                         pw = values
                         if checkw:
-                            mbooks[pw].check_wmodel(self.wake_models[w], error=True)
+                            mbooks.get_item(pw).check_wmodel(
+                                self.wake_models[w], error=True
+                            )
                     except TypeError:
                         pw = deffunc(self.wake_models[w])
-                    target[w] = mbooks[pw]
+                    target[w] = mbooks.get_item(pw)
                     target[w].name = pw
             elif isinstance(values, list):
                 for i, w in enumerate(wake_models):
@@ -156,7 +151,7 @@ class Downwind(Algorithm):
                             f"Not enough {descr} in list {values}, expecting {len(wake_models)}"
                         )
                     pw = values[i]
-                    target[w] = mbooks[pw]
+                    target[w] = mbooks.get_item(pw)
                     target[w].name = pw
             else:
                 for w in wake_models:
@@ -164,10 +159,10 @@ class Downwind(Algorithm):
                         pw = values[w]
                     else:
                         pw = deffunc(self.wake_models[w])
-                    target[w] = mbooks[pw]
+                    target[w] = mbooks.get_item(pw)
                     target[w].name = pw
 
-        self.partial_wakes = {}
+        self.__partial_wakes = {}
         _set_wspecific(
             descr="partial wakes",
             target=self.partial_wakes,
@@ -177,7 +172,7 @@ class Downwind(Algorithm):
             checkw=True,
         )
 
-        self.ground_models = {}
+        self.__ground_models = {}
         _set_wspecific(
             descr="ground models",
             target=self.ground_models,
@@ -187,9 +182,113 @@ class Downwind(Algorithm):
             checkw=False,
         )
 
-        self.farm_controller = self.mbook.farm_controllers[farm_controller]
+        self.__farm_controller = self.mbook.farm_controllers.get_item(farm_controller)
         self.farm_controller.name = farm_controller
 
+    @property
+    def states(self):
+        """
+        The states
+
+        Returns
+        -------
+        m: foxes.core.States
+            The states
+
+        """
+        return self.__states
+
+    @states.setter
+    def states(self, value):
+        """Resets the states"""
+        if self.running:
+            raise ValueError(f"{self.name}: Cannot set states while running")
+        if self.states.initialized:
+            self.states.finalize(self, verbosity=self.verbosity)
+        self.__states = value
+        self.init_states()
+
+    @property
+    def rotor_model(self):
+        """
+        The rotor model
+
+        Returns
+        -------
+        m: foxes.core.RotorModel
+            The rotor model
+
+        """
+        return self.__rotor_model
+
+    @property
+    def wake_models(self):
+        """
+        The wake models
+
+        Returns
+        -------
+        m: dict
+            The wake models. Key: name,
+            value: foxes.core.WakeModel
+
+        """
+        return self.__wake_models
+
+    @property
+    def wake_frame(self):
+        """
+        The wake frame
+
+        Returns
+        -------
+        m: foxes.core.WakeFrame
+            The wake frame
+
+        """
+        return self.__wake_frame
+
+    @property
+    def partial_wakes(self):
+        """
+        The partial wakes models
+
+        Returns
+        -------
+        m: dict
+            The partial wakes models. Key: name,
+            value: foxes.core.PartialWakesModel
+
+        """
+        return self.__partial_wakes
+
+    @property
+    def ground_models(self):
+        """
+        The ground models
+
+        Returns
+        -------
+        m: dict
+            The ground models, key: name,
+            value: foxes.core.GroundModel
+
+        """
+        return self.__ground_models
+
+    @property
+    def farm_controller(self):
+        """
+        The farm controller
+
+        Returns
+        -------
+        m: foxes.core.FarmController
+            The farm controller
+
+        """
+        return self.__farm_controller
+
     @classmethod
     def get_model(cls, name):
         """
@@ -276,29 +375,25 @@ class Downwind(Algorithm):
             self.states.initialize(self, self.verbosity)
             self.n_states = self.states.size()
 
-    def all_models(self, with_states=True):
+    def sub_models(self):
         """
-        Return all models
-
-        Parameters
-        ----------
-        with_states: bool
-            Flag for including states
+        List of all sub-models
 
         Returns
         -------
-        mdls: list of foxes.core.Model
-            The list of models
+        smdls: list of foxes.core.Model
+            All sub models
 
         """
-        mdls = [self.states] if with_states else []
-        mdls += [
-            self.rotor_model,
+        mdls = [
+            self.states,
             self.farm_controller,
+            self.rotor_model,
             self.wake_frame,
         ]
         mdls += list(self.wake_models.values())
         mdls += list(self.partial_wakes.values())
+        mdls += list(self.ground_models.values())
 
         return mdls
 
@@ -306,13 +401,10 @@ class Downwind(Algorithm):
         """
         Initializes the algorithm.
         """
-        self.print(f"\nInitializing algorithm '{self.name}'")
-        super().initialize()
-
         self.init_states()
 
-        for m in self.all_models(with_states=False):
-            m.initialize(self, self.verbosity)
+        self.print(f"\nInitializing algorithm '{self.name}'")
+        super().initialize()
 
     def _collect_farm_models(
         self,
@@ -370,17 +462,38 @@ class Downwind(Algorithm):
         """Helper function that gathers the farm variables"""
         self.farm_vars = sorted(list(set([FV.WEIGHT] + mlist.output_farm_vars(self))))
 
-    def _run_farm_calc(self, mlist, *data, outputs=None, **kwargs):
-        """Helper function for running the main farm calculation"""
-        self.print(
-            f"\nCalculating {self.n_states} states for {self.n_turbines} turbines"
-        )
+    def _launch_parallel_farm_calc(
+        self,
+        mlist,
+        *data,
+        outputs=None,
+        **kwargs,
+    ):
+        """
+        Runs the main calculation, launching parallelization
+
+        Parameters
+        ----------
+        mlist: foxes.models.FarmDataModelList
+            The model list
+        data: tuple of xarray.Dataset
+            The (mdata, fdata) inputs
+        outputs: list of str, optional
+            The output variables, or None for defaults
+        kwargs: dict, optional
+            Additional parameters for running
+
+        Returns
+        -------
+        farm_results: xarray.Dataset
+            The farm results. The calculated variables have
+            dimensions (state, turbine)
+
+        """
         out_vars = self.farm_vars if outputs is None else outputs
-        farm_results = mlist.run_calculation(self, *data, out_vars=out_vars, **kwargs)
-        farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
-        for v in [FV.ORDER, FV.ORDER_SSEL, FV.ORDER_INV]:
-            if v in farm_results:
-                farm_results[v] = farm_results[v].astype(FC.ITYPE)
+        farm_results = get_engine().run_calculation(
+            self, mlist, *data, out_vars=out_vars, **kwargs
+        )
 
         return farm_results
 
@@ -388,10 +501,8 @@ class Downwind(Algorithm):
         self,
         outputs=None,
         calc_parameters={},
-        persist=True,
         finalize=True,
         ambient=False,
-        chunked_results=False,
         **kwargs,
     ):
         """
@@ -404,15 +515,10 @@ class Downwind(Algorithm):
             Key: model name str, value: parameter dict
         outputs: list of str, optional
             The output variables, or None for defaults
-        persist: bool
-            Switch for forcing dask to load all model data
-            into memory
         finalize: bool
             Flag for finalization after calculation
         ambient: bool
             Flag for ambient instead of waked calculation
-        chunked_results: bool
-            Flag for chunked results
         kwargs: dict, optional
             Additional parameters for run_calculation
 
@@ -437,7 +543,7 @@ class Downwind(Algorithm):
 
         # initialize models:
         if not mlist.initialized:
-            mlist.initialize(self, self.verbosity)
+            mlist.initialize(self, self.verbosity - 1)
             self._calc_farm_vars(mlist)
         self._print_model_oder(mlist, calc_pars)
 
@@ -448,37 +554,37 @@ class Downwind(Algorithm):
             outputs = sorted(list(set(outputs).intersection(self.farm_vars)))
 
         # get input model data:
-        models_data = self.get_models_data()
-        if persist:
-            models_data = models_data.persist()
-        self.print("\nInput data:\n\n", models_data, "\n")
+        model_data = self.get_models_data()
+        self.print("\nInput data:\n\n", model_data, "\n")
         self.print(f"\nFarm variables:", ", ".join(self.farm_vars))
         self.print(f"\nOutput variables:", ", ".join(outputs))
-        self.print(f"\nChunks: {self.chunks}\n")
 
         # run main calculation:
-        farm_results = self._run_farm_calc(
+        farm_results = super().calc_farm(
             mlist,
-            models_data,
+            model_data,
             parameters=calc_pars,
             outputs=outputs,
             **kwargs,
         )
-        del models_data
+        farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
+        for v in [FV.ORDER, FV.ORDER_SSEL, FV.ORDER_INV]:
+            if v in farm_results:
+                farm_results[v] = farm_results[v].astype(FC.ITYPE)
+        del model_data
 
         # finalize models:
         if finalize:
             self.print("\n")
-            mlist.finalize(self, self.verbosity)
+            mlist.finalize(self, self.verbosity - 1)
             self.finalize()
+        else:
+            self.del_model_data(mlist)
 
         if ambient:
             dvars = [v for v in farm_results.data_vars.keys() if v in FV.var2amb]
             farm_results = farm_results.drop_vars(dvars)
 
-        if chunked_results:
-            farm_results = self.chunked(farm_results)
-
         return farm_results
 
     def _collect_point_models(
@@ -534,17 +640,55 @@ class Downwind(Algorithm):
 
         return mlist, calc_pars
 
+    def _launch_parallel_points_calc(self, mlist, *data, outputs=None, **kwargs):
+        """
+        Runs the main points calculation, launching parallelization
+
+        Parameters
+        ----------
+        mlist: foxes.models.FarmDataModelList
+            The model list
+        data: tuple of xarray.Dataset
+            The (mdata, fdata) inputs
+        outputs: list of str, optional
+            The output variables, or None for defaults
+        kwargs: dict, optional
+            Additional parameters for running
+
+        Returns
+        -------
+        point_results: xarray.Dataset
+            The point results. The calculated variables have
+            dimensions (state, point)
+
+        """
+        return (
+            get_engine()
+            .run_calculation(
+                self,
+                mlist,
+                *data,
+                out_vars=outputs,
+                **kwargs,
+            )
+            .sel({FC.TPOINT: 0})
+            .rename({FC.TARGET: FC.POINT})
+        )
+
     def calc_points(
         self,
         farm_results,
         points,
         point_models=None,
+        outputs=None,
         calc_parameters={},
         persist_mdata=True,
         persist_pdata=False,
         finalize=True,
         ambient=False,
         chunked_results=False,
+        states_sel=None,
+        states_isel=None,
         **kwargs,
     ):
         """
@@ -557,6 +701,8 @@ class Downwind(Algorithm):
             dimensions (state, turbine)
         points: numpy.ndarray
             The points of interest, shape: (n_states, n_points, 3)
+        outputs: list of str, optional
+            The output variables, or None for defaults
         point_models: str or foxes.core.PointDataModel
             Additional point models to be executed
         calc_parameters: dict
@@ -574,6 +720,10 @@ class Downwind(Algorithm):
             Flag for ambient instead of waked calculation
         chunked_results: bool
             Flag for chunked results
+        states_sel: list, optional
+            Reduce to selected states
+        states_isel: list, optional
+            Reduce to the selected states indices
         kwargs: dict, optional
             Additional parameters for run_calculation
 
@@ -584,7 +734,6 @@ class Downwind(Algorithm):
             dimensions (state, point)
 
         """
-
         if not self.initialized:
             self.initialize()
         if not ambient and farm_results is None:
@@ -602,59 +751,61 @@ class Downwind(Algorithm):
 
         # initialize models:
         if not mlist.initialized:
-            mlist.initialize(self, self.verbosity)
+            mlist.initialize(self, self.verbosity - 1)
+
+        # subset selections:
+        sel = {} if states_sel is None else {FC.STATE: states_sel}
+        isel = {} if states_isel is None else {FC.STATE: states_isel}
+        if states_isel is not None:
+            farm_results = farm_results.isel(isel)
+        if states_sel is not None:
+            farm_results = farm_results.sel(sel)
+        n_states = farm_results.sizes[FC.STATE]
 
         # get input model data:
-        models_data = self.get_models_data()
+        model_data = self.get_models_data(sel=sel, isel=isel)
         if persist_mdata:
-            models_data = models_data.persist()
-        self.print("\nInput data:\n\n", models_data, "\n")
+            model_data = model_data.persist()
+        self.print("\nInput data:\n\n", model_data, "\n")
         self.print(f"\nOutput farm variables:", ", ".join(self.farm_vars))
-        self.print(f"\nChunks: {self.chunks}\n")
 
         # chunk farm results:
-        if self.chunks is not None:
-            farm_results = self.chunked(farm_results)
         self.print("\nInput farm data:\n\n", farm_results, "\n")
 
         # get point data:
         if FC.STATE in farm_results.coords:
             sinds = farm_results.coords[FC.STATE]
-        elif models_data is not None and FC.STATE in models_data.coords:
-            sinds = models_data.coords[FC.STATE]
+        elif model_data is not None and FC.STATE in model_data.coords:
+            sinds = model_data.coords[FC.STATE]
         else:
             sinds = None
-        point_data = self.new_point_data(points, sinds)
+        point_data = self.new_point_data(points, sinds, n_states=n_states)
         if persist_pdata:
             point_data = point_data.persist()
         self.print("\nInput point data:\n\n", point_data, "\n")
 
         # check vars:
-        ovars = mlist.output_point_vars(self)
+        ovars = mlist.output_point_vars(self) if outputs is None else outputs
         self.print(f"\nOutput point variables:", ", ".join(ovars))
-        self.print(f"\nChunks: {self.chunks}\n")
 
         # calculate:
-        self.print(
-            f"Calculating {len(ovars)} variables at {points.shape[1]} points in {self.n_states} states"
-        )
-
-        point_results = mlist.run_calculation(
-            self,
-            models_data,
+        point_results = super().calc_points(
+            mlist,
+            model_data,
             farm_results,
             point_data,
-            out_vars=ovars,
+            outputs=ovars,
             parameters=calc_pars,
+            # sel=sel,
+            # isel=isel,
             **kwargs,
         )
-
-        del models_data, farm_results, point_data
+        del model_data, farm_results, point_data
 
         # finalize models:
         if finalize:
             self.print("\n")
-            mlist.finalize(self, self.verbosity)
+            mlist.finalize(self, self.verbosity - 1)
             self.finalize()
 
         if ambient:
@@ -665,18 +816,3 @@ class Downwind(Algorithm):
             point_results = self.chunked(point_results)
 
         return point_results
-
-    def finalize(self, clear_mem=False):
-        """
-        Finalizes the algorithm.
-
-        Parameters
-        ----------
-        clear_mem: bool
-            Clear idata memory
-
-        """
-        for m in self.all_models():
-            m.finalize(self, self.verbosity)
-
-        super().finalize(clear_mem)

foxes/algorithms/downwind/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):
@@ -33,7 +34,7 @@ class FarmWakesCalculation(FarmDataModel):
         return list(dict.fromkeys(ovars))
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -57,8 +58,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)
@@ -69,9 +70,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
 
@@ -127,7 +128,9 @@ class FarmWakesCalculation(FarmDataModel):
                         )
 
                     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
                         )
@@ -150,7 +153,9 @@ class FarmWakesCalculation(FarmDataModel):
                         )
 
                     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
                         )

foxes/algorithms/downwind/models/init_farm_data.py

@@ -48,7 +48,7 @@ class InitFarmData(FarmDataModel):
         ]
 
     def calculate(self, algo, mdata, fdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -88,7 +88,7 @@ class InitFarmData(FarmDataModel):
             if len(t.xy.shape) == 1:
                 fdata[FV.TXYH][:, ti, :2] = t.xy[None, :]
             else:
-                i0 = fdata.states_i0()
+                i0 = fdata.states_i0(counter=True)
                 s = np.s_[i0 : i0 + fdata.n_states]
                 fdata[FV.TXYH][:, ti, :2] = t.xy[s]