foxes 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

examples/field_data_nc/run.py

@@ -60,7 +60,10 @@ if __name__ == "__main__":
         type=int,
     )
     parser.add_argument(
-        "-npl", "--no_pre_load", help="Do not pre-load data", action="store_true"
+        "-lm",
+        "--load_mode",
+        help="Do load mode",
+        default="preload",
     )
     parser.add_argument(
         "-nf", "--nofig", help="Do not show figures", action="store_true"
@@ -70,9 +73,7 @@ if __name__ == "__main__":
     states = foxes.input.states.FieldDataNC(
         args.file_pattern,
         output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
-        # var2ncvar={FV.WS: "ws", FV.WD: "wd", FV.TI: "ti"},
-        fixed_vars={FV.RHO: 1.225},
-        pre_load=not args.no_pre_load,
+        load_mode=args.load_mode,
     )
 
     mbook = foxes.models.ModelBook()
@@ -115,6 +116,12 @@ if __name__ == "__main__":
     fr = farm_results.to_dataframe()
     print(fr[[FV.WD, FV.AMB_REWS, FV.REWS, FV.AMB_P, FV.P]])
 
+    o = foxes.output.SlicesData(algo, farm_results)
+    ds = o.get_states_data_xy(
+        z_list=[90, 100], variables=[FV.WS], resolution=50, verbosity=1
+    )
+    print(ds)
+
     if not args.nofig:
         o = foxes.output.FlowPlots2D(algo, farm_results)
         o.get_mean_fig_xy(FV.WS, resolution=10)

examples/streamline_wakes/run.py

@@ -43,9 +43,12 @@ if __name__ == "__main__":
         "-nt", "--n_turbines", help="The number of turbines", default=9, type=int
     )
     parser.add_argument(
-        "-npl", "--no_pre_load", help="Pre-load the nc data", action="store_true"
+        "-lm",
+        "--load_mode",
+        help="Do load mode",
+        default="preload",
     )
-    parser.add_argument("-e", "--engine", help="The engine", default=None)
+    parser.add_argument("-e", "--engine", help="The engine", default="process")
     parser.add_argument(
         "-n", "--n_cpus", help="The number of cpus", default=None, type=int
     )
@@ -82,7 +85,7 @@ if __name__ == "__main__":
         output_vars=[FV.WS, FV.WD, FV.TI, FV.RHO],
         var2ncvar={FV.WS: "ws", FV.WD: "wd"},
         fixed_vars={FV.RHO: 1.225, FV.TI: 0.1},
-        pre_load=not args.no_pre_load,
+        load_mode=args.load_mode,
         bounds_error=False,
     )
 

foxes/algorithms/downwind/downwind.py

@@ -188,6 +188,7 @@ class Downwind(Algorithm):
 
         self.__farm_controller = self.mbook.farm_controllers.get_item(farm_controller)
         self.farm_controller.name = farm_controller
+        self.farm_controller.find_turbine_types(self)
 
     @property
     def states(self):

foxes/config/__init__.py

@@ -1 +1 @@
-from .config import Config, config, get_path, get_output_path
+from .config import Config, config, get_path, get_input_path, get_output_path

foxes/config/config.py

@@ -1,7 +1,8 @@
 import numpy as np
 from pathlib import Path
+from sys import version_info
 
-from foxes.utils.dict import Dict
+from foxes.utils import Dict, import_module
 import foxes.constants as FC
 
 
@@ -19,11 +20,17 @@ class Config(Dict):
                 FC.DTYPE: np.float64,
                 FC.ITYPE: np.int64,
                 FC.WORK_DIR: Path("."),
-                FC.OUT_DIR: Path("."),
+                FC.INPUT_DIR: None,
+                FC.OUTPUT_DIR: None,
+                FC.NC_ENGINE: "h5netcdf",
             },
             name="config",
         )
 
+        # special treat for Python 3.8:
+        if version_info[0] == 3 and version_info[1] == 8:
+            self["nc_engine"] = None
+
     @property
     def dtype_double(self):
         """
@@ -62,12 +69,33 @@ class Config(Dict):
 
         """
         pth = self.get_item(FC.WORK_DIR)
-        if not isinstance(pth, Path):
+        if self[FC.WORK_DIR] is None:
+            self[FC.WORK_DIR] = Path(".")
+        elif not isinstance(pth, Path):
             self[FC.WORK_DIR] = Path(pth)
         return self[FC.WORK_DIR]
 
     @property
-    def out_dir(self):
+    def input_dir(self):
+        """
+        The input base directory
+
+        Returns
+        -------
+        pth: pathlib.Path
+            Path to the input base directory
+
+        """
+        if self[FC.INPUT_DIR] is None:
+            return self.work_dir
+        else:
+            pth = self.get_item(FC.INPUT_DIR)
+            if not isinstance(pth, Path):
+                self[FC.INPUT_DIR] = Path(pth)
+            return self[FC.INPUT_DIR]
+
+    @property
+    def output_dir(self):
         """
         The default output directory
 
@@ -77,7 +105,29 @@ class Config(Dict):
             Path to the default output directory
 
         """
-        return get_path(self.get_item(FC.OUT_DIR))
+        if self[FC.OUTPUT_DIR] is None:
+            return self.work_dir
+        else:
+            pth = self.get_item(FC.OUTPUT_DIR)
+            if not isinstance(pth, Path):
+                self[FC.OUTPUT_DIR] = Path(pth)
+            return self[FC.OUTPUT_DIR]
+
+    @property
+    def nc_engine(self):
+        """
+        The NetCDF engine
+
+        Returns
+        -------
+        nce: str
+            The NetCDF engine
+
+        """
+        nce = self[FC.NC_ENGINE]
+        if nce is not None:
+            import_module(nce)
+        return nce
 
 
 config = Config()
@@ -86,10 +136,37 @@ config = Config()
 """
 
 
-def get_path(pth):
+def get_path(pth, base):
+    """
+    Gets path object, respecting the base directory
+
+    Parameters
+    ----------
+    pth: str or pathlib.Path
+        The path, optionally relative to base
+    base: pathlib.Path
+        The base directory
+
+    Returns
+    -------
+    out: pathlib.Path
+        The path, absolute or relative to base directory
+
+    :group: foxes.config
+
+    """
+    if not isinstance(pth, Path):
+        pth = Path(pth)
+    if pth.is_absolute():
+        return pth
+    else:
+        return base / pth
+
+
+def get_input_path(pth):
     """
     Gets path object, respecting the configurations
-    work directory
+    input directory
 
     Parameters
     ----------
@@ -99,15 +176,13 @@ def get_path(pth):
     Returns
     -------
     out: pathlib.Path
-        The path, absolute or relative to working directory
+        The path, absolute or relative to input directory
         from config
 
     :group: foxes.config
 
     """
-    if not isinstance(pth, Path):
-        pth = Path(pth)
-    return pth if pth.is_absolute() else config.work_dir / pth
+    return get_path(pth, base=config.input_dir)
 
 
 def get_output_path(pth):
@@ -129,6 +204,4 @@ def get_output_path(pth):
     :group: foxes.config
 
     """
-    if not isinstance(pth, Path):
-        pth = Path(pth)
-    return pth if pth.is_absolute() else config.out_dir / pth
+    return get_path(pth, base=config.output_dir)

foxes/constants.py

@@ -189,7 +189,18 @@ WORK_DIR = "work_dir"
 :group: foxes.constants
 """
 
-OUT_DIR = "out_dir"
+INPUT_DIR = "in_dir"
+"""Identifier for the input base directory
+:group: foxes.constants
+"""
+
+OUTPUT_DIR = "out_dir"
 """Identifier for the default output directory
 :group: foxes.constants
 """
+
+
+NC_ENGINE = "nc_engine"
+"""Identifier for the NetCDF engine
+:group: foxes.constants
+"""

foxes/core/algorithm.py

@@ -74,14 +74,19 @@ class Algorithm(Model):
                     )
             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()
+
+            if "engine_type" in engine_pars:
+                try:
+                    e = Engine.new(verbosity=verbosity, **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()
+            else:
+                raise KeyError(
+                    f"{self.name}: Found unsupported parameters {list(engine_pars.keys())}"
+                )
 
     @property
     def farm(self):

foxes/core/engine.py

@@ -157,6 +157,36 @@ class Engine(ABC):
         if self.verbosity >= level:
             print(*args, **kwargs)
 
+    def map(
+        self,
+        func,
+        inputs,
+        *args,
+        **kwargs,
+    ):
+        """
+        Runs a function on a list of files
+
+        Parameters
+        ----------
+        func: Callable
+            Function to be called on each file,
+            func(input, *args, **kwargs) -> data
+        inputs: array-like
+            The input data list
+        args: tuple, optional
+            Arguments for func
+        kwargs: dict, optional
+            Keyword arguments for func
+
+        Returns
+        -------
+        results: list
+            The list of results
+
+        """
+        raise NotImplementedError
+
     @property
     def loop_dims(self):
         """

foxes/core/farm_controller.py

@@ -176,6 +176,39 @@ class FarmController(FarmDataModel):
 
         return [m.name for m in tmodels], tmsels
 
+    def find_turbine_types(self, algo):
+        """
+        Collects the turbine types.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The algorithm
+
+        """
+
+        # check turbine models, and find turbine types and pre/post-rotor models:
+        self.turbine_types = [None for t in algo.farm.turbines]
+        for ti, t in enumerate(algo.farm.turbines):
+            for mname in t.models:
+                if mname in algo.mbook.turbine_types:
+                    m = algo.mbook.turbine_types[mname]
+                    if not isinstance(m, TurbineType):
+                        raise TypeError(
+                            f"Model {mname} type {type(m).__name__} is not derived from {TurbineType.__name__}"
+                        )
+                    if self.turbine_types[ti] is not None:
+                        raise TypeError(
+                            f"Two turbine type models found for turbine {ti}: {self.turbine_types[ti].name} and {mname}"
+                        )
+                    m.name = mname
+                    self.turbine_types[ti] = m
+
+            if self.turbine_types[ti] is None:
+                raise ValueError(
+                    f"Turbine {ti}, {t.name}: Missing a turbine type model among models {t.models}"
+                )
+
     def collect_models(self, algo):
         """
         Analyze and gather turbine models, based on the
@@ -188,22 +221,18 @@ class FarmController(FarmDataModel):
 
         """
 
+        if self.turbine_types is None:
+            self.find_turbine_types(algo)
+
         # check turbine models, and find turbine types and pre/post-rotor models:
-        self.turbine_types = [None for t in algo.farm.turbines]
         prer_models = [[] for t in algo.farm.turbines]
         postr_models = [[] for t in algo.farm.turbines]
+        ttypes = {m.name: m for m in self.turbine_types}
         for ti, t in enumerate(algo.farm.turbines):
             prer = None
             for mi, mname in enumerate(t.models):
-                istype = False
-                if mname in algo.mbook.turbine_types:
-                    m = algo.mbook.turbine_types[mname]
-                    if not isinstance(m, TurbineType):
-                        raise TypeError(
-                            f"Model {mname} type {type(m).__name__} is not derived from {TurbineType.__name__}"
-                        )
-                    models = [m]
-                    istype = True
+                if mname in ttypes:
+                    models = [ttypes[mname]]
                 elif mname in algo.mbook.turbine_models:
                     m = algo.mbook.turbine_models[mname]
                     models = m.models if isinstance(m, FarmDataModelList) else [m]
@@ -212,21 +241,14 @@ class FarmController(FarmDataModel):
                             raise TypeError(
                                 f"Model {mname} type {type(mm).__name__} is not derived from {TurbineModel.__name__}"
                             )
+                    m.name = mname
                 else:
                     raise KeyError(
                         f"Model {mname} not found in model book types or models"
                     )
 
-                if istype:
-                    if self.turbine_types[ti] is None:
-                        self.turbine_types[ti] = m
-                    else:
-                        raise ValueError(
-                            f"Turbine {ti}, {t.name}: Multiple turbine types found in self.turbine_models list, {self.turbine_types[ti].name} and {mname}"
-                        )
-
+                prer = None
                 for m in models:
-                    m.name = mname
                     if prer is None:
                         prer = m.pre_rotor
                     elif not prer and m.pre_rotor:
@@ -238,11 +260,6 @@ class FarmController(FarmDataModel):
                     else:
                         postr_models[ti].append(m)
 
-            if self.turbine_types[ti] is None:
-                raise ValueError(
-                    f"Turbine {ti}, {t.name}: Missing a turbine type model among models {t.models}"
-                )
-
         # analyze models:
         mnames_pre, tmsels_pre = self._analyze_models(
             algo, pre_rotor=True, models=prer_models

foxes/core/states.py

@@ -277,7 +277,7 @@ class ExtendedStates(States):
             The output variable names
 
         """
-        return self.states.output_point_vars(algo)
+        return self.pmodels.output_point_vars(algo)
 
     def calculate(self, algo, mdata, fdata, tdata):
         """

foxes/core/wind_farm.py

@@ -1,3 +1,8 @@
+import numpy as np
+
+from foxes.config import config
+
+
 class WindFarm:
     """
     The wind farm.
@@ -76,3 +81,107 @@ class WindFarm:
 
         """
         return [t.name for t in self.turbines]
+
+    @property
+    def xy_array(self):
+        """
+        Returns an array of the wind farm ground points
+
+        Returns
+        -------
+        xya: numpy.ndarray
+            The turbine ground positions, shape: (n_turbines, 2)
+
+        """
+        return np.array([t.xy for t in self.turbines], dtype=config.dtype_double)
+
+    def get_xy_bounds(self, extra_space=None, algo=None):
+        """
+        Returns min max points of the wind farm ground points
+
+        Parameters
+        ----------
+        extra_space: float or str, optional
+            The extra space, either float in m,
+            or str for units of D, e.g. '2.5D'
+        algo: foxes.core.Algorithm, optional
+            The algorithm
+
+        Returns
+        -------
+        x_mima: numpy.ndarray
+            The (x_min, x_max) point
+        y_mima: numpy.ndarray
+            The (y_min, y_max) point
+
+        """
+        if self.boundary is not None:
+            xy = None
+            p_min, p_max = self.boundary.p_min(), self.boundary.p_max()
+        else:
+            xy = self.xy_array
+            p_min, p_max = np.min(xy, axis=0), np.max(xy, axis=0)
+
+        if extra_space is not None:
+            if isinstance(extra_space, str):
+                assert (
+                    algo is not None
+                ), f"WindFarm: require algo argument for extra_space '{extra_space}'"
+                assert (
+                    len(extra_space) > 1 and extra_space[-1] == "D"
+                ), f"Expecting float or str like '2.5D', got extra_space = '{extra_space}'"
+                extra_space = float(extra_space[:-1])
+                rds = self.get_rotor_diameters(algo)
+                if xy is None:
+                    extra_space *= np.max(rds)
+                else:
+                    p_min = np.min(xy - extra_space * rds[:, None], axis=0)
+                    p_max = np.max(xy + extra_space * rds[:, None], axis=0)
+                    return p_min, p_max
+
+            p_min -= extra_space
+            p_max += extra_space
+
+        return p_min, p_max
+
+    def get_rotor_diameters(self, algo):
+        """
+        Gets the rotor diameters
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The algorithm
+
+        Returns
+        -------
+        rds: numpy.ndarray
+            The rotor diameters, shape: (n_turbienes,)
+
+        """
+        rds = [
+            t.D if t.D is not None else algo.farm_controller.turbine_types[i].D
+            for i, t in enumerate(self.turbines)
+        ]
+        return np.array(rds, dtype=config.dtype_double)
+
+    def get_hub_heights(self, algo):
+        """
+        Gets the hub heights
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The algorithm
+
+        Returns
+        -------
+        hhs: numpy.ndarray
+            The hub heights, shape: (n_turbienes,)
+
+        """
+        hhs = [
+            t.H if t.H is not None else algo.farm_controller.turbine_types[i].H
+            for i, t in enumerate(self.turbines)
+        ]
+        return np.array(hhs, dtype=config.dtype_double)

foxes/engines/dask.py

@@ -22,9 +22,11 @@ def load_dask():
     """On-demand loading of the dask package"""
     global dask, ProgressBar, delayed
     if dask is None:
-        dask = import_module("dask", hint="pip install dask")
+        dask = import_module("dask")
         ProgressBar = import_module(
-            "dask.diagnostics", hint="pip install dask"
+            "dask.diagnostics",
+            pip_hint="pip install dask",
+            conda_hint="conda install dask -c conda-forge",
         ).ProgressBar
         delayed = dask.delayed
 
@@ -33,7 +35,7 @@ def load_distributed():
     """On-demand loading of the distributed package"""
     global distributed
     if distributed is None:
-        distributed = import_module("distributed", hint="pip install distributed")
+        distributed = import_module("distributed")
 
 
 class DaskBaseEngine(Engine):
@@ -98,6 +100,49 @@ class DaskBaseEngine(Engine):
         dask.config.set(**self.dask_config)
         super().initialize()
 
+    def map(
+        self,
+        func,
+        inputs,
+        *args,
+        **kwargs,
+    ):
+        """
+        Runs a function on a list of files
+
+        Parameters
+        ----------
+        func: Callable
+            Function to be called on each file,
+            func(input, *args, **kwargs) -> data
+        inputs: array-like
+            The input data list
+        args: tuple, optional
+            Arguments for func
+        kwargs: dict, optional
+            Keyword arguments for func
+
+        Returns
+        -------
+        results: list
+            The list of results
+
+        """
+        if len(inputs) == 0:
+            return []
+        elif len(inputs) == 1:
+            return [func(inputs[0], *args, **kwargs)]
+        else:
+            inptl = np.array_split(inputs, min(self.n_procs, len(inputs)))
+            jobs = []
+            for subi in inptl:
+                jobs.append(_run_map(func, subi, *args, **kwargs))
+            results = dask.compute(jobs)[0]
+            out = []
+            for r in results:
+                out += r
+            return out
+
     def chunk_data(self, data):
         """
         Applies the selected chunking
@@ -280,6 +325,36 @@ class XArrayEngine(DaskBaseEngine):
 
     """
 
+    def map(
+        self,
+        func,
+        inputs,
+        *args,
+        **kwargs,
+    ):
+        """
+        Runs a function on a list of files
+
+        Parameters
+        ----------
+        func: Callable
+            Function to be called on each file,
+            func(input, *args, **kwargs) -> data
+        inputs: array-like
+            The input data list
+        args: tuple, optional
+            Arguments for func
+        kwargs: dict, optional
+            Keyword arguments for func
+
+        Returns
+        -------
+        results: list
+            The list of results
+
+        """
+        return [func(input, *args, **kwargs) for input in inputs]
+
     def run_calculation(
         self,
         algo,
@@ -476,6 +551,12 @@ def _run_lazy(algo, model, iterative, chunk_store, i0_t0, *data, **cpars):
     return results, cstore
 
 
+@delayed
+def _run_map(func, inputs, *args, **kwargs):
+    """Helper function for running map func on proc"""
+    return [func(x, *args, **kwargs) for x in inputs]
+
+
 class DaskEngine(DaskBaseEngine):
     """
     The dask engine for delayed foxes calculations.
@@ -969,8 +1050,11 @@ class SlurmClusterEngine(LocalClusterEngine):
         nodes = cargs.pop("nodes", 1)
 
         dask_jobqueue = import_module(
-            "dask_jobqueue", hint="pip install setuptools dask-jobqueue"
+            "dask_jobqueue",
+            pip_hint="pip install setuptools dask-jobqueue",
+            conda_hint="conda install setuptools dask-jobqueue -c conda-forge",
         )
+
         self._cluster = dask_jobqueue.SLURMCluster(**cargs)
         self._cluster.scale(jobs=nodes)
         self._cluster = self._cluster.__enter__()