foxes 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/VERSION

@@ -1 +1 @@
-0.5.1
+0.5.2

foxes/algorithms/downwind/downwind.py

@@ -8,28 +8,28 @@ from . import models as mdls
 
 class Downwind(Algorithm):
     """
-     The downwind algorithm.
-
-     The turbines are evaluated once, in the order
-     that is calculated by the provided `TurbineOrder`
-     object.
-
-     Attributes
-     ----------
-     states: foxes.core.States
-         The ambient states
-     wake_models: list of foxes.core.WakeModel
-         The wake models, applied to all turbines
-     rotor_model: foxes.core.RotorModel
-         The rotor model, for all turbines
-     wake_frame: foxes.core.WakeFrame
-         The wake frame
-     partial_wakes_model: foxes.core.PartialWakesModel
-         The partial wakes model
-     farm_controller: foxes.core.FarmController
-         The farm controller
-     n_states: int
-         The number of states
+    The downwind algorithm.
+
+    The turbines are evaluated once, in the order
+    that is calculated by the provided `TurbineOrder`
+    object.
+
+    Attributes
+    ----------
+    states: foxes.core.States
+        The ambient states
+    wake_models: list of foxes.core.WakeModel
+        The wake models, applied to all turbines
+    rotor_model: foxes.core.RotorModel
+        The rotor model, for all turbines
+    wake_frame: foxes.core.WakeFrame
+        The wake frame
+    partial_wakes_model: foxes.core.PartialWakesModel
+        The partial wakes model
+    farm_controller: foxes.core.FarmController
+        The farm controller
+    n_states: int
+        The number of states
 
     :group: algorithms.downwind
 
@@ -307,6 +307,7 @@ class Downwind(Algorithm):
         finalize=True,
         ambient=False,
         chunked_results=False,
+        **kwargs,
     ):
         """
         Calculate farm data.
@@ -325,6 +326,8 @@ class Downwind(Algorithm):
             Flag for ambient instead of waked calculation
         chunked_results: bool
             Flag for chunked results
+        kwargs: dict, optional
+            Additional parameters for run_calculation
 
         Returns
         -------
@@ -358,7 +361,12 @@ class Downwind(Algorithm):
         self.print(f"\nChunks: {self.chunks}\n")
 
         # run main calculation:
-        farm_results = self._run_farm_calc(mlist, models_data, parameters=calc_pars)
+        farm_results = self._run_farm_calc(
+            mlist, 
+            models_data, 
+            parameters=calc_pars, 
+            **kwargs,
+        )
         del models_data
 
         # finalize models:
@@ -378,8 +386,6 @@ class Downwind(Algorithm):
 
     def _collect_point_models(
         self,
-        vars=None,
-        vars_to_amb=None,
         calc_parameters={},
         point_models=None,
         ambient=False,
@@ -420,16 +426,14 @@ class Downwind(Algorithm):
 
         # 2) transfer ambient results:
         mlist.models.append(
-            self.get_model("SetAmbPointResults")(
-                point_vars=vars, vars_to_amb=vars_to_amb
-            )
+            self.get_model("SetAmbPointResults")()
         )
         calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
         # 3) calc wake effects:
         if not ambient:
             mlist.models.append(
-                self.get_model("PointWakesCalculation")(vars, emodels, emodels_cpars)
+                self.get_model("PointWakesCalculation")(emodels, emodels_cpars)
             )
             calc_pars.append(calc_parameters.get(mlist.models[-1].name, {}))
 
@@ -439,8 +443,6 @@ class Downwind(Algorithm):
         self,
         farm_results,
         points,
-        vars=None,
-        vars_to_amb=None,
         point_models=None,
         calc_parameters={},
         persist_mdata=True,
@@ -448,6 +450,7 @@ class Downwind(Algorithm):
         finalize=True,
         ambient=False,
         chunked_results=False,
+        **kwargs,
     ):
         """
         Calculate data at a given set of points.
@@ -459,12 +462,6 @@ class Downwind(Algorithm):
             dimensions (state, turbine)
         points: numpy.ndarray
             The points of interest, shape: (n_states, n_points, 3)
-        vars: list of str, optional
-            The variables that should be kept in the output,
-            or `None` for all
-        vars_to_amb: list of str, optional
-            Variables for which ambient variables should
-            be stored. None means all.
         point_models: str or foxes.core.PointDataModel
             Additional point models to be executed
         calc_parameters: dict
@@ -482,6 +479,8 @@ class Downwind(Algorithm):
             Flag for ambient instead of waked calculation
         chunked_results: bool
             Flag for chunked results
+        kwargs: dict, optional
+            Additional parameters for run_calculation
 
         Returns
         -------
@@ -503,7 +502,7 @@ class Downwind(Algorithm):
 
         # collect models and initialize:
         mlist, calc_pars = self._collect_point_models(
-            vars, vars_to_amb, calc_parameters, point_models, ambient
+            calc_parameters, point_models, ambient
         )
 
         # initialize models:
@@ -537,25 +536,21 @@ class Downwind(Algorithm):
 
         # check vars:
         ovars = mlist.output_point_vars(self)
-        if vars is None:
-            vars = ovars
-        for v in vars:
-            if v not in ovars:
-                raise KeyError(f"Variable '{v}' not in output point vars: {ovars}")
-        self.print(f"\nOutput point variables:", ", ".join(vars))
+        self.print(f"\nOutput point variables:", ", ".join(ovars))
         self.print(f"\nChunks: {self.chunks}\n")
 
         # calculate:
         self.print(
-            f"Calculating {len(vars)} variables at {points.shape[1]} points in {self.n_states} states"
+            f"Calculating {len(ovars)} variables at {points.shape[1]} points in {self.n_states} states"
         )
         point_results = mlist.run_calculation(
             self,
             models_data,
             farm_results,
             point_data,
-            out_vars=vars,
+            out_vars=ovars,
             parameters=calc_pars,
+            **kwargs,
         )
 
         del models_data, farm_results, point_data

foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -9,7 +9,7 @@ class PointWakesCalculation(PointDataModel):
 
     Attributes
     ----------
-    point_vars: list of str
+    pvars: list of str
         The variables of interest
     emodels: foxes.core.PointDataModelList
         The extra evaluation models
@@ -23,15 +23,13 @@ class PointWakesCalculation(PointDataModel):
     """
 
     def __init__(
-        self, point_vars=None, emodels=None, emodels_cpars=None, wake_models=None
+        self, emodels=None, emodels_cpars=None, wake_models=None
     ):
         """
         Constructor.
 
         Parameters
         ----------
-        point_vars: list of str, optional
-            The variables of interest
         emodels: foxes.core.PointDataModelList, optional
             The extra evaluation models
         emodels_cpars: list of dict, optional
@@ -41,7 +39,7 @@ class PointWakesCalculation(PointDataModel):
 
         """
         super().__init__()
-        self._pvars = point_vars
+        self.pvars = None
         self.emodels = emodels
         self.emodels_cpars = emodels_cpars
         self.wake_models = wake_models
@@ -71,9 +69,7 @@ class PointWakesCalculation(PointDataModel):
 
         """
         super().initialize(algo, verbosity)
-        self.pvars = (
-            algo.states.output_point_vars(algo) if self._pvars is None else self._pvars
-        )
+        self.pvars = algo.states.output_point_vars(algo)
 
     def output_point_vars(self, algo):
         """
@@ -194,7 +190,6 @@ class PointWakesCalculation(PointDataModel):
         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)
-        import numpy as np
 
         for v in self.pvars:
             if v in wdeltas:

foxes/algorithms/downwind/models/set_amb_point_results.py

@@ -17,21 +17,13 @@ class SetAmbPointResults(PointDataModel):
 
     """
 
-    def __init__(self, point_vars=None, vars_to_amb=None):
+    def __init__(self):
         """
         Constructor.
-
-        Parameters
-        ----------
-        point_vars: list of str, optional
-            The point variables to be treated
-        vars_to_amb: list of str, optional
-            The variables to be copied to output
-
         """
         super().__init__()
-        self._pvars = point_vars
-        self._vars = vars_to_amb
+        self.pvars = None
+        self.vars = None
 
     def initialize(self, algo, verbosity=0):
         """
@@ -45,14 +37,8 @@ class SetAmbPointResults(PointDataModel):
             The verbosity level, 0 = silent
 
         """
-        self.pvars = (
-            algo.states.output_point_vars(algo) if self._pvars is None else self._pvars
-        )
-        self.vars = (
-            [v for v in self.pvars if v in FV.var2amb]
-            if self._vars is None
-            else self._vars
-        )
+        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)
 
     def output_point_vars(self, algo):
@@ -70,9 +56,6 @@ class SetAmbPointResults(PointDataModel):
             The output variable names
 
         """
-        for v in algo.states.output_point_vars(algo):
-            if v not in self.vars and v in FV.var2amb:
-                self.vars.append(v)
         return [FV.var2amb[v] for v in self.vars]
 
     def calculate(self, algo, mdata, fdata, pdata):

foxes/core/algorithm.py

@@ -374,7 +374,7 @@ class Algorithm(Model):
             or points.shape[2] != 3
         ):
             raise ValueError(
-                f"points have wrong dimensions, expecting ({self.n_states}, n_points, 3), got {points.shape}"
+                f"points have wrong dimensions, expecting ({self.n_states}, {points.shape[1]}, 3), got {points.shape}"
             )
         idata["data_vars"][FC.POINTS] = ((FC.STATE, FC.POINT, FC.XYH), points)
 

foxes/core/data_calc_model.py

@@ -174,6 +174,8 @@ class DataCalcModel(Model):
         loop_dims,
         out_core_vars,
         initial_results=None,
+        sel=None,
+        isel=None,
         **calc_pars,
     ):
         """
@@ -196,10 +198,14 @@ class DataCalcModel(Model):
         out_core_vars: list of str
             The core dimensions of the output data, use
             `FC.VARS` for variables dimension (required)
-        calc_pars: dict, optional
-            Additional arguments for the `calculate` function
         initial_results: xarray.Dataset, optional
             Initial results
+        sel: dict, optional
+            Selection of loop_dim variable subset values
+        isel: dict, optional
+            Selection of loop_dim variable subset index values
+        calc_pars: dict, optional
+            Additional arguments for the `calculate` function
 
         Returns
         -------
@@ -255,6 +261,24 @@ class DataCalcModel(Model):
                     evars.append(c)
 
             dvars.append(list(ds.keys()) + list(ds.coords.keys()))
+        
+        # subset selection:
+        if sel is not None:
+            nldata = []
+            for ds in ldata:
+                s = {k: v for k, v in sel.items() if k in ds.coords}
+                if len(s):
+                    nldata.append(ds.sel(s))
+            ldata = nldata
+            del nldata
+        if isel is not None:
+            nldata = []
+            for ds in ldata:
+                s = {k: v for k, v in isel.items() if k in ds.coords}
+                if len(s):
+                    nldata.append(ds.isel(s))
+            ldata = nldata
+            del nldata
 
         # setup dask options:
         dargs = dict(output_sizes={FC.VARS: len(out_vars)})

foxes/core/partial_wakes_model.py

@@ -1,8 +1,8 @@
 from abc import abstractmethod
 
-from .model import Model
 from foxes.utils import all_subclasses
 
+from .model import Model
 
 class PartialWakesModel(Model):
     """

foxes/core/rotor_model.py

@@ -4,9 +4,9 @@ from abc import abstractmethod
 import foxes.variables as FV
 import foxes.constants as FC
 from .farm_data_model import FarmDataModel
-from .data import Data
-from foxes.utils import wd2uv, uv2wd
+from foxes.utils import wd2uv, uv2wd, all_subclasses
 
+from .data import Data
 
 class RotorModel(FarmDataModel):
     """
@@ -412,3 +412,37 @@ class RotorModel(FarmDataModel):
         )
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}
+
+    @classmethod
+    def new(cls, rmodel_type, *args, **kwargs):
+        """
+        Run-time rotor model factory.
+
+        Parameters
+        ----------
+        rmodel_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if rmodel_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = rmodel_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == rmodel_type:
+                    return scls(*args, **kwargs)
+
+        else:
+            estr = "Rotor model type '{}' is not defined, available types are \n {}".format(
+                rmodel_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)
+        

foxes/core/turbine_model.py

@@ -1,5 +1,7 @@
 from abc import abstractmethod
 
+from foxes.utils import all_subclasses
+
 from .farm_data_model import FarmDataModel
 
 
@@ -42,3 +44,37 @@ class TurbineModel(FarmDataModel):
 
         """
         pass
+
+    @classmethod
+    def new(cls, tmodel_type, *args, **kwargs):
+        """
+        Run-time turbine model factory.
+
+        Parameters
+        ----------
+        tmodel_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if tmodel_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = tmodel_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == tmodel_type:
+                    return scls(*args, **kwargs)
+
+        else:
+            estr = "Turbine model type '{}' is not defined, available types are \n {}".format(
+                tmodel_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)
+        

foxes/core/turbine_type.py

@@ -1,6 +1,7 @@
-from .turbine_model import TurbineModel
 import foxes.constants as FC
+from foxes.utils import all_subclasses
 
+from .turbine_model import TurbineModel
 
 class TurbineType(TurbineModel):
     """
@@ -57,3 +58,36 @@ class TurbineType(TurbineModel):
             raise KeyError(
                 f"Turbine type '{self.name}': Unkown P_unit '{P_unit}', expecting {list(FC.P_UNITS.keys())}"
             )
+
+    @classmethod
+    def new(cls, ttype_type, *args, **kwargs):
+        """
+        Run-time turbine type factory.
+
+        Parameters
+        ----------
+        ttype_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if ttype_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = ttype_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == ttype_type:
+                    return scls(*args, **kwargs)
+
+        else:
+            estr = "Turbine type class '{}' is not defined, available types are \n {}".format(
+                ttype_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)

foxes/core/wake_frame.py

@@ -2,11 +2,13 @@ from abc import abstractmethod
 import numpy as np
 from scipy.interpolate import interpn
 
-from .data import Data
-from .model import Model
+from foxes.utils import all_subclasses
 import foxes.constants as FC
 import foxes.variables as FV
 
+from .data import Data
+from .model import Model
+
 
 class WakeFrame(Model):
     """
@@ -234,7 +236,7 @@ class WakeFrame(Model):
         # calc wakes:
         if not ambient:
             wcalc = algo.get_model("PointWakesCalculation")(
-                vrs, wake_models=wake_models
+                wake_models=wake_models
             )
             wcalc.initialize(algo, verbosity=0)
             wsrc = states_source_turbine if self_wake else None
@@ -263,3 +265,37 @@ class WakeFrame(Model):
         )
 
         return results.reshape(n_states, n_points, n_vars)
+
+    @classmethod
+    def new(cls, wframe_type, *args, **kwargs):
+        """
+        Run-time wake frame factory.
+
+        Parameters
+        ----------
+        wframe_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if wframe_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = wframe_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == wframe_type:
+                    return scls(*args, **kwargs)
+
+        else:
+            estr = "Wake frame type '{}' is not defined, available types are \n {}".format(
+                wframe_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)
+        

foxes/core/wake_model.py

@@ -1,5 +1,7 @@
 from abc import abstractmethod
 
+from foxes.utils import all_subclasses
+
 from .model import Model
 
 
@@ -115,3 +117,37 @@ class WakeModel(Model):
 
         """
         pass
+
+    @classmethod
+    def new(cls, wmodel_type, *args, **kwargs):
+        """
+        Run-time wake model factory.
+
+        Parameters
+        ----------
+        wmodel_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if wmodel_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = wmodel_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == wmodel_type:
+                    return scls(*args, **kwargs)
+
+        else:
+            estr = "Wake model type '{}' is not defined, available types are \n {}".format(
+                wmodel_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)
+