foxes 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

foxes/constants.py

@@ -1,5 +1,3 @@
-import numpy as np
-
 XYH = "xyh"
 """ The vector (x, y, height)
 :group: foxes.variables
@@ -126,13 +124,13 @@ STATE_SOURCE_ORDERI = "state-source-orderi"
 :group: foxes.constants
 """
 
-DTYPE = np.float64
-""" Default data type for floats
+DTYPE = "DTYPE"
+"""Identifier for default double data type
 :group: foxes.constants
 """
 
-ITYPE = np.int64
-""" Default data type for int
+ITYPE = "ITYPE"
+"""Identifier for default integer data type
 :group: foxes.constants
 """
 
@@ -184,3 +182,14 @@ POP = "pop"
 """ Population identifier
 :group: foxes.constants
 """
+
+
+WORK_DIR = "work_dir"
+"""Identifier for the working directory
+:group: foxes.constants
+"""
+
+OUT_DIR = "out_dir"
+"""Identifier for the default output directory
+:group: foxes.constants
+"""

foxes/core/algorithm.py

@@ -4,7 +4,8 @@ from abc import abstractmethod
 
 from .model import Model
 from foxes.data import StaticData
-from foxes.utils import Dict, all_subclasses
+from foxes.utils import Dict, new_instance
+from foxes.config import config
 import foxes.constants as FC
 
 from .engine import Engine
@@ -33,7 +34,6 @@ class Algorithm(Model):
         farm,
         verbosity=1,
         dbook=None,
-        engine=None,
         **engine_pars,
     ):
         """
@@ -49,8 +49,6 @@ class Algorithm(Model):
             The verbosity level, 0 means silent
         dbook: foxes.DataBook, optional
             The data book, or None for default
-        engine: str
-            The engine class name
         engine_pars: dict, optional
             Parameters for the engine constructor
 
@@ -68,14 +66,22 @@ class Algorithm(Model):
         self.__idata_mem = Dict(name="idata_mem")
         self.__chunk_store = Dict(name="chunk_store")
 
-        if engine is not None:
-            e = Engine.new(engine_type=engine, verbosity=verbosity, **engine_pars)
+        if len(engine_pars):
+            if "engine_type" in engine_pars:
+                if "engine" in engine_pars:
+                    raise KeyError(
+                        f"{self.name}: Expecting either 'engine' or 'engine_type', not both"
+                    )
+            elif "engine" in engine_pars:
+                engine_pars["engine_type"] = engine_pars.pop("engine")
+            v = engine_pars.pop("verbosity", verbosity)
+            try:
+                e = Engine.new(verbosity=v, **engine_pars)
+            except TypeError as e:
+                print(f"\nError while interpreting engine_pars {engine_pars}\n")
+                raise e
             self.print(f"Algorithm '{self.name}': Selecting engine '{e}'")
             e.initialize()
-        elif len(engine_pars):
-            self.print(
-                f"Algorithm '{self.name}': Parameter 'engine' is None; ignoring engine parameters {engine_pars}"
-            )
 
     @property
     def farm(self):
@@ -171,6 +177,28 @@ class Algorithm(Model):
         if self.verbosity >= vlim:
             print(*args, **kwargs)
 
+    def print_deco(self, func_name=None, n_points=None):
+        """
+        Helper function for printing model names
+
+        Parameters
+        ----------
+        func_name: str, optional
+            Name of the calling function
+        n_points: int, optional
+            The number of points
+
+        """
+        if self.verbosity > 0:
+            deco = "-" * 60
+            print(f"\n{deco}")
+            print(f"  Algorithm: {type(self).__name__}")
+            if func_name is not None:
+                print(f"  Running {self.name}: {func_name}")
+            print(deco)
+            print(f"  n_states : {self.n_states}")
+            print(f"  n_turbines: {self.n_turbines}")
+
     def initialize(self):
         """
         Initializes the algorithm.
@@ -375,6 +403,12 @@ class Algorithm(Model):
         else:
             idata = {"coords": {FC.STATE: states_indices}, "data_vars": {}}
 
+        if len(points.shape) == 2 and points.shape[1] == 3:
+            pts = np.zeros((n_states,) + points.shape, dtype=config.dtype_double)
+            pts[:] = points[None]
+            points = pts
+            del pts
+
         if (
             len(points.shape) != 3
             or points.shape[0] != n_states
@@ -389,7 +423,7 @@ class Algorithm(Model):
         )
         idata["data_vars"][FC.TWEIGHTS] = (
             (FC.TPOINT,),
-            np.array([1.0], dtype=FC.DTYPE),
+            np.array([1.0], dtype=config.dtype_double),
         )
 
         return xr.Dataset(**idata)
@@ -914,22 +948,4 @@ class Algorithm(Model):
             Additional parameters for the constructor
 
         """
-
-        if algo_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = algo_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == algo_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = (
-                "Algorithm type '{}' is not defined, available types are \n {}".format(
-                    algo_type, sorted([i.__name__ for i in allc])
-                )
-            )
-            raise KeyError(estr)
+        return new_instance(cls, algo_type, *args, **kwargs)

foxes/core/axial_induction_model.py

@@ -1,5 +1,6 @@
 from abc import abstractmethod
 
+from foxes.utils import new_instance
 from .model import Model
 
 
@@ -28,3 +29,20 @@ class AxialInductionModel(Model):
 
         """
         pass
+
+    @classmethod
+    def new(cls, induction_type, *args, **kwargs):
+        """
+        Run-time axial induction model factory.
+
+        Parameters
+        ----------
+        induction_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, induction_type, *args, **kwargs)

foxes/core/data.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.utils import Dict
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -620,7 +621,7 @@ class TData(Data):
             )
         data[FC.TARGETS] = points[:, :, None, :]
         dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
-        data[FC.TWEIGHTS] = np.array([1], dtype=FC.DTYPE)
+        data[FC.TWEIGHTS] = np.array([1], dtype=config.dtype_double)
         dims[FC.TWEIGHTS] = (FC.TPOINT,)
         return cls(data, dims, [FC.STATE, FC.TARGET], name=name, **kwargs)
 

foxes/core/engine.py

@@ -5,7 +5,8 @@ from tqdm import tqdm
 from xarray import Dataset
 
 from foxes.core import MData, FData, TData
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
+from foxes.config import config
 import foxes.constants as FC
 
 __global_engine_data__ = dict(
@@ -246,26 +247,21 @@ class Engine(ABC):
             if int(n_states / n_chunks_states) > chunk_size_states:
                 n_chunks_states += 1
                 chunk_size_states = int(n_states / n_chunks_states)
-        chunk_sizes_states = np.full(n_chunks_states, chunk_size_states)
-        extra = n_states - n_chunks_states * chunk_size_states
-        if extra > 0:
-            chunk_sizes_states[-extra:] += 1
-
-        s = np.sum(chunk_sizes_states)
-        assert (
-            s == n_states
-        ), f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
 
         # determine points chunks:
         chunk_sizes_targets = [n_targets]
         if n_targets > 1:
             if self.chunk_size_points is None:
-                if n_chunks_states == 1:
-                    n_chunks_targets = min(self.n_procs, n_targets)
-                    chunk_size_targets = max(int(n_targets / self.n_procs), 1)
-                else:
+                if n_targets < max(n_states, 1000):
                     chunk_size_targets = n_targets
                     n_chunks_targets = 1
+                else:
+                    n_chunks_targets = min(self.n_procs, n_targets)
+                    chunk_size_targets = max(int(n_targets / self.n_procs), 1)
+                    if self.chunk_size_states is None and n_chunks_states > 1:
+                        while chunk_size_states * chunk_size_targets > n_targets:
+                            n_chunks_states += 1
+                            chunk_size_states = int(n_states / n_chunks_states)
             else:
                 chunk_size_targets = min(n_targets, self.chunk_size_points)
                 n_chunks_targets = max(int(n_targets / chunk_size_targets), 1)
@@ -282,6 +278,16 @@ class Engine(ABC):
                 s == n_targets
             ), f"Targets count mismatch: Expecting {n_targets}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_targets]}"
 
+        chunk_sizes_states = np.full(n_chunks_states, chunk_size_states)
+        extra = n_states - n_chunks_states * chunk_size_states
+        if extra > 0:
+            chunk_sizes_states[-extra:] += 1
+
+        s = np.sum(chunk_sizes_states)
+        assert (
+            s == n_states
+        ), f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
+
         return chunk_sizes_states, chunk_sizes_targets
 
     def get_chunk_input_data(
@@ -342,7 +348,7 @@ class Engine(ABC):
                 n_states = i1_states - i0_states
                 for o in set(out_vars).difference(data.keys()):
                     data[o] = np.full(
-                        (n_states, algo.n_turbines), np.nan, dtype=FC.DTYPE
+                        (n_states, algo.n_turbines), np.nan, dtype=config.dtype_double
                     )
                     dims[o] = (FC.STATE, FC.TURBINE)
 
@@ -366,7 +372,9 @@ class Engine(ABC):
                 n_states = i1_states - i0_states
                 n_targets = i1_targets - i0_targets
                 for o in set(out_vars).difference(data.keys()):
-                    data[o] = np.full((n_states, n_targets, 1), np.nan, dtype=FC.DTYPE)
+                    data[o] = np.full(
+                        (n_states, n_targets, 1), np.nan, dtype=config.dtype_double
+                    )
                     dims[o] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
             tdata = TData.from_dataset(
@@ -538,36 +546,24 @@ class Engine(ABC):
         """
 
         if engine_type is None:
-            return None
-        else:
-            engine_type = dict(
-                default="DefaultEngine",
-                threads="ThreadsEngine",
-                process="ProcessEngine",
-                xarray="XArrayEngine",
-                dask="DaskEngine",
-                multiprocess="MultiprocessEngine",
-                local_cluster="LocalClusterEngine",
-                slurm_cluster="SlurmClusterEngine",
-                mpi="MPIEngine",
-                ray="RayEngine",
-                numpy="NumpyEngine",
-                single="SingleChunkEngine",
-            ).get(engine_type, engine_type)
-
-        allc = all_subclasses(cls)
-        found = engine_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == engine_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = "engine type '{}' is not defined, available types are \n {}".format(
-                engine_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+            engine_type = "default"
+
+        engine_type = dict(
+            default="DefaultEngine",
+            threads="ThreadsEngine",
+            process="ProcessEngine",
+            xarray="XArrayEngine",
+            dask="DaskEngine",
+            multiprocess="MultiprocessEngine",
+            local_cluster="LocalClusterEngine",
+            slurm_cluster="SlurmClusterEngine",
+            mpi="MPIEngine",
+            ray="RayEngine",
+            numpy="NumpyEngine",
+            single="SingleChunkEngine",
+        ).get(engine_type, engine_type)
+
+        return new_instance(cls, engine_type, *args, **kwargs)
 
 
 def get_engine(error=True, default=True):
@@ -602,9 +598,7 @@ def get_engine(error=True, default=True):
             default.initialize()
             return default
         elif isinstance(default, bool) and default:
-            engine = Engine.new(
-                engine_type="DefaultEngine", chunk_size_points=20000, verbosity=0
-            )
+            engine = Engine.new(engine_type="DefaultEngine", verbosity=1)
             print(f"Selecting '{engine}'")
             engine.initialize()
             return engine

foxes/core/farm_controller.py

@@ -1,10 +1,12 @@
 import numpy as np
 
+from foxes.config import config
+import foxes.constants as FC
+from foxes.utils import new_instance
+
 from .farm_data_model import FarmDataModelList, FarmDataModel
 from .turbine_model import TurbineModel
 from .turbine_type import TurbineType
-import foxes.constants as FC
-import foxes.variables as FV
 
 
 class FarmController(FarmDataModel):
@@ -122,7 +124,7 @@ class FarmController(FarmDataModel):
         tmodels = []
         tmsels = []
         mnames = [[m.name for m in mlist] for mlist in models]
-        tmis = np.zeros(algo.n_turbines, dtype=FC.ITYPE)
+        tmis = np.zeros(algo.n_turbines, dtype=config.dtype_int)
         news = True
         while news:
             news = False
@@ -394,3 +396,20 @@ class FarmController(FarmDataModel):
         """
         super().finalize(algo, verbosity)
         self.turbine_model_names = None
+
+    @classmethod
+    def new(cls, controller_type, *args, **kwargs):
+        """
+        Run-time farm controller factory.
+
+        Parameters
+        ----------
+        controller_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, controller_type, *args, **kwargs)

foxes/core/farm_data_model.py

@@ -1,9 +1,11 @@
 from abc import abstractmethod
 import numpy as np
 
-from .data_calc_model import DataCalcModel
+from foxes.config import config
 import foxes.constants as FC
 
+from .data_calc_model import DataCalcModel
+
 
 class FarmDataModel(DataCalcModel):
     """
@@ -82,7 +84,9 @@ class FarmDataModel(DataCalcModel):
         n_turbines = fdata.n_turbines
         for v in self.output_farm_vars(algo):
             if v not in fdata:
-                fdata[v] = np.full((n_states, n_turbines), np.nan, dtype=FC.DTYPE)
+                fdata[v] = np.full(
+                    (n_states, n_turbines), np.nan, dtype=config.dtype_double
+                )
                 fdata.dims[v] = (FC.STATE, FC.TURBINE)
 
     @abstractmethod

foxes/core/ground_model.py

@@ -1,3 +1,5 @@
+from foxes.utils import new_instance
+
 from .model import Model
 
 
@@ -252,3 +254,20 @@ class GroundModel(Model):
 
         """
         wmodel.finalize_wake_deltas(algo, mdata, fdata, amb_results, wake_deltas)
+
+    @classmethod
+    def new(cls, ground_type, *args, **kwargs):
+        """
+        Run-time ground model factory.
+
+        Parameters
+        ----------
+        ground_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, ground_type, *args, **kwargs)

foxes/core/model.py

@@ -2,6 +2,7 @@ import numpy as np
 from abc import ABC
 from itertools import count
 
+from foxes.config import config
 import foxes.constants as FC
 
 
@@ -522,7 +523,7 @@ class Model(ABC):
             if target == FC.STATE_TARGET and tdata.n_tpoints != 1:
                 # find the mean index and round it to nearest integer:
                 sts = tdata.tpoint_mean(FC.STATES_SEL)[:, :, None]
-                sts = (sts + 0.5).astype(FC.ITYPE)
+                sts = (sts + 0.5).astype(config.dtype_int)
             sel = sts < i0
             if np.any(sel):
                 if not hasattr(algo, "farm_results_downwind"):

foxes/core/partial_wakes_model.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 
 from .model import Model
 
@@ -189,30 +189,18 @@ class PartialWakesModel(Model):
         pass
 
     @classmethod
-    def new(cls, pwake_type, **kwargs):
+    def new(cls, pwakes_type, *args, **kwargs):
         """
-        Run-time partial wakes factory.
+        Run-time partial wakes model factory.
 
         Parameters
         ----------
-        pwake_type: str
+        pwakes_type: str
             The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
 
         """
-
-        if pwake_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = pwake_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == pwake_type:
-                    return scls(**kwargs)
-
-        else:
-            estr = "Partial wakes model type '{}' is not defined, available types are \n {}".format(
-                pwake_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, pwakes_type, *args, **kwargs)

foxes/core/point_data_model.py

@@ -1,9 +1,12 @@
 import numpy as np
 from abc import abstractmethod
 
-from .data_calc_model import DataCalcModel
+from foxes.config import config
+from foxes.utils import new_instance
 import foxes.constants as FC
 
+from .data_calc_model import DataCalcModel
+
 
 class PointDataModel(DataCalcModel):
     """
@@ -60,7 +63,7 @@ class PointDataModel(DataCalcModel):
                 tdata[v] = np.full(
                     (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
                     np.nan,
-                    dtype=FC.DTYPE,
+                    dtype=config.dtype_double,
                 )
                 tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
@@ -261,3 +264,20 @@ class PointDataModelList(PointDataModel):
             tdata.update(res)
 
         return {v: tdata[v] for v in self.output_point_vars(algo)}
+
+    @classmethod
+    def new(cls, model_type, *args, **kwargs):
+        """
+        Run-time point model factory.
+
+        Parameters
+        ----------
+        model_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        """
+        return new_instance(cls, model_type, *args, **kwargs)

foxes/core/rotor_model.py

@@ -1,12 +1,14 @@
 import numpy as np
 from abc import abstractmethod
 
+from foxes.config import config
+from foxes.utils import wd2uv, uv2wd, new_instance
+
 import foxes.variables as FV
 import foxes.constants as FC
-from .farm_data_model import FarmDataModel
-from foxes.utils import wd2uv, uv2wd, all_subclasses
 
 from .data import TData
+from .farm_data_model import FarmDataModel
 
 
 class RotorModel(FarmDataModel):
@@ -146,14 +148,16 @@ class RotorModel(FarmDataModel):
         dpoints = self.design_points()
         D = fdata[FV.D]
 
-        rax = np.zeros((n_states, n_turbines, 3, 3), dtype=FC.DTYPE)
+        rax = np.zeros((n_states, n_turbines, 3, 3), dtype=config.dtype_double)
         n = rax[:, :, 0, 0:2]
         m = rax[:, :, 1, 0:2]
         n[:] = wd2uv(fdata[FV.YAW], axis=-1)
         m[:] = np.stack([-n[:, :, 1], n[:, :, 0]], axis=-1)
         rax[:, :, 2, 2] = 1
 
-        points = np.zeros((n_states, n_turbines, n_points, 3), dtype=FC.DTYPE)
+        points = np.zeros(
+            (n_states, n_turbines, n_points, 3), dtype=config.dtype_double
+        )
         points[:] = fdata[FV.TXYH][:, :, None, :]
         points[:] += (
             0.5 * D[:, :, None, None] * np.einsum("stad,pa->stpd", rax, dpoints)
@@ -413,20 +417,4 @@ class RotorModel(FarmDataModel):
             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)
+        return new_instance(cls, rmodel_type, *args, **kwargs)

foxes/core/states.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
 from .point_data_model import PointDataModel, PointDataModelList
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -163,22 +163,7 @@ class States(PointDataModel):
             Additional parameters for constructor
 
         """
-
-        if states_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = states_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == states_type:
-                    return scls(*args, **kwargs)
-        else:
-            estr = "States type '{}' is not defined, available types are \n {}".format(
-                states_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, states_type, *args, **kwargs)
 
 
 class ExtendedStates(States):

foxes/core/turbine_model.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 
 from .farm_data_model import FarmDataModel
 
@@ -60,20 +60,4 @@ class TurbineModel(FarmDataModel):
             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)
+        return new_instance(cls, tmodel_type, *args, **kwargs)