foxes 1.2.2__tar.gz → 1.2.3__tar.gz

{foxes-1.2.2/foxes.egg-info → foxes-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 1.2.2
+Version: 1.2.3
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -53,18 +53,19 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: xarray
 Requires-Dist: scipy
-Requires-Dist: netcdf4
 Requires-Dist: cycler
 Requires-Dist: tqdm
 Requires-Dist: pyyaml
 Provides-Extra: opt
 Requires-Dist: foxes-opt; extra == "opt"
 Provides-Extra: dask
+Requires-Dist: h5netcdf; extra == "dask"
 Requires-Dist: dask; extra == "dask"
 Requires-Dist: distributed; extra == "dask"
 Requires-Dist: dask-jobqueue; extra == "dask"
 Requires-Dist: setuptools; extra == "dask"
 Provides-Extra: eng
+Requires-Dist: h5netcdf; extra == "eng"
 Requires-Dist: multiprocess; extra == "eng"
 Requires-Dist: dask; extra == "eng"
 Requires-Dist: distributed; extra == "eng"
@@ -73,6 +74,7 @@ Requires-Dist: setuptools; extra == "eng"
 Requires-Dist: mpi4py; extra == "eng"
 Requires-Dist: ray; extra == "eng"
 Provides-Extra: eng0
+Requires-Dist: h5netcdf; extra == "eng0"
 Requires-Dist: multiprocess; extra == "eng0"
 Requires-Dist: dask; extra == "eng0"
 Requires-Dist: distributed; extra == "eng0"
@@ -82,7 +84,9 @@ Requires-Dist: ray; extra == "eng0"
 Provides-Extra: test
 Requires-Dist: flake8; extra == "test"
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: h5netcdf; extra == "test"
 Provides-Extra: doc
+Requires-Dist: setuptools; extra == "doc"
 Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: sphinx-immaterial; extra == "doc"
 Requires-Dist: nbsphinx; extra == "doc"

{foxes-1.2.2 → foxes-1.2.3}/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)

{foxes-1.2.2 → foxes-1.2.3}/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-1.2.2 → foxes-1.2.3}/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-1.2.3/foxes/config/__init__.py

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

{foxes-1.2.2 → foxes-1.2.3}/foxes/config/config.py

@@ -1,7 +1,7 @@
 import numpy as np
 from pathlib import Path
 
-from foxes.utils.dict import Dict
+from foxes.utils import Dict, import_module
 import foxes.constants as FC
 
 
@@ -19,7 +19,9 @@ 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",
         )
@@ -62,12 +64,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 +100,27 @@ 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
+
+        """
+        import_module(self[FC.NC_ENGINE])
+        return self[FC.NC_ENGINE]
 
 
 config = Config()
@@ -86,10 +129,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 +169,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 +197,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-1.2.2 → foxes-1.2.3}/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-1.2.2 → foxes-1.2.3}/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-1.2.2 → foxes-1.2.3}/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-1.2.2 → foxes-1.2.3}/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-1.2.2 → foxes-1.2.3}/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-1.2.3/foxes/core/wind_farm.py

@@ -0,0 +1,187 @@
+import numpy as np
+
+from foxes.config import config
+
+
+class WindFarm:
+    """
+    The wind farm.
+
+    Attributes
+    ----------
+    name: str
+        The wind farm name
+    turbines: list of foxes.core.Turbine
+        The wind turbines
+    boundary: foxes.utils.geom2d.AreaGeometry, optional
+        The wind farm boundary
+
+    :group: core
+
+    """
+
+    def __init__(self, name="wind_farm", boundary=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        name: str
+            The wind farm name
+
+        """
+        self.name = name
+        self.turbines = []
+        self.boundary = boundary
+
+    def add_turbine(self, turbine, verbosity=1):
+        """
+        Add a wind turbine to the list.
+
+        Parameters
+        ----------
+        turbine: foxes.core.Turbine
+            The wind turbine
+        verbosity: int
+            The output verbosity, 0 = silent
+
+        """
+        if turbine.index is None:
+            turbine.index = len(self.turbines)
+        if turbine.name is None:
+            turbine.name = f"T{turbine.index}"
+        self.turbines.append(turbine)
+        if verbosity > 0:
+            print(
+                f"Turbine {turbine.index}, {turbine.name}: xy=({turbine.xy[0]:.2f}, {turbine.xy[1]:.2f}), {', '.join(turbine.models)}"
+            )
+
+    @property
+    def n_turbines(self):
+        """
+        The number of turbines in the wind farm
+
+        Returns
+        -------
+        n_turbines: int
+            The total number of turbines
+
+        """
+        return len(self.turbines)
+
+    @property
+    def turbine_names(self):
+        """
+        The list of names of all turbines
+
+        Returns
+        -------
+        names: list of str
+            The names of all turbines
+
+        """
+        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)