foxes 1.1.1__tar.gz → 1.2__tar.gz

{foxes-1.1.1 → foxes-1.2}/MANIFEST.in

@@ -5,4 +5,3 @@ include foxes/data/states/*.csv.gz
 include foxes/data/states/*.nc
 include foxes/data/states/*.tab
 include foxes/data/farms/*.csv
-include foxes/data/windio/*.yaml

{foxes-1.1.1/foxes.egg-info → foxes-1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 1.1.1
+Version: 1.2
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -163,6 +163,7 @@ The supported Python versions are:
 - `Python 3.10`
 - `Python 3.11`
 - `Python 3.12`
+- `Python 3.13`
 
 ## Installation
 

{foxes-1.1.1 → foxes-1.2}/README.md

@@ -63,6 +63,7 @@ The supported Python versions are:
 - `Python 3.10`
 - `Python 3.11`
 - `Python 3.12`
+- `Python 3.13`
 
 ## Installation
 

{foxes-1.1.1 → foxes-1.2}/docs/source/conf.py

@@ -314,13 +314,15 @@ python_apigen_modules = {
     "foxes.algorithms.iterative.models": "_foxes/algorithms/iterative/models/",
     "foxes.algorithms.sequential": "_foxes/algorithms/sequential/",
     "foxes.algorithms.sequential.models": "_foxes/algorithms/sequential/models/",
+    "foxes.config": "_foxes/config/",
     "foxes.core": "_foxes/core/",
     "foxes.data": "_foxes/data/",
     "foxes.engines": "_foxes/engines/",
     "foxes.input.farm_layout": "_foxes/input/farm_layout/",
     "foxes.input.states": "_foxes/input/states/",
     "foxes.input.states.create": "_foxes/input/states/create/",
-    "foxes.input.windio": "_foxes/input/windio/",
+    "foxes.input.yaml": "_foxes/input/yaml/",
+    "foxes.input.yaml.windio": "_foxes/input/yaml/windio/",
     "foxes.output": "_foxes/output/",
     "foxes.output.flow_plots_2d": "_foxes/output/flow_plots_2d/",
     "foxes.output.seq_plugins": "_foxes/output/seq_plugins/",

{foxes-1.1.1 → foxes-1.2}/examples/dyn_wakes/run.py

@@ -99,14 +99,14 @@ if __name__ == "__main__":
         "-c",
         "--chunksize_states",
         help="The chunk size for states",
-        default=None,
+        default=20,
         type=int,
     )
     parser.add_argument(
         "-C",
         "--chunksize_points",
         help="The chunk size for points",
-        default=5000,
+        default=None,
         type=int,
     )
     parser.add_argument(

{foxes-1.1.1 → foxes-1.2}/examples/timelines/run.py

@@ -92,7 +92,7 @@ if __name__ == "__main__":
         "-c",
         "--chunksize_states",
         help="The chunk size for states",
-        default=None,
+        default=20,
         type=int,
     )
     parser.add_argument(

foxes-1.2/foxes/__init__.py

@@ -0,0 +1,37 @@
+"""
+Farm Optimization and eXtended yield Evaluation Software
+    
+"""
+
+from .config import config, get_path  # noqa: F401
+from .core import Engine, WindFarm, Turbine, get_engine, reset_engine  # noqa: F401
+from .models import ModelBook  # noqa: F401
+from .data import (
+    parse_Pct_file_name,
+    parse_Pct_two_files,
+    FARM,
+    STATES,
+    PCTCURVE,
+    StaticData,
+)  # noqa: F401
+
+from . import algorithms  # noqa: F401
+from . import engines  # noqa: F401
+from . import models  # noqa: F401
+from . import input  # noqa: F401
+from . import output  # noqa: F401
+from . import utils  # noqa: F401
+
+import importlib
+from pathlib import Path
+
+try:
+    tomllib = importlib.import_module("tomllib")
+    source_location = Path(__file__).parent
+    if (source_location.parent / "pyproject.toml").exists():
+        with open(source_location.parent / "pyproject.toml", "rb") as f:
+            __version__ = tomllib.load(f)["project"]["version"]
+    else:
+        __version__ = importlib.metadata.version(__package__ or __name__)
+except ModuleNotFoundError:
+    __version__ = importlib.metadata.version(__package__ or __name__)

{foxes-1.1.1 → foxes-1.2}/foxes/algorithms/downwind/downwind.py

@@ -1,8 +1,12 @@
+import numpy as np
+
 from foxes.core import Algorithm, FarmDataModelList, get_engine
 from foxes.core import PointDataModel, PointDataModelList, FarmController
+from foxes.config import config
 import foxes.models as fm
 import foxes.variables as FV
 import foxes.constants as FC
+
 from . import models as mdls
 
 
@@ -570,7 +574,7 @@ class Downwind(Algorithm):
         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[v] = farm_results[v].astype(config.dtype_int)
         del model_data
 
         # finalize models:
@@ -742,6 +746,7 @@ class Downwind(Algorithm):
             )
 
         # welcome:
+        points = np.asarray(points)
         self._print_deco("calc_points", n_points=points.shape[1])
 
         # collect models and initialize:

{foxes-1.1.1 → foxes-1.2}/foxes/algorithms/downwind/models/init_farm_data.py

@@ -3,6 +3,7 @@ import numpy as np
 from foxes.core import FarmDataModel, TData
 import foxes.variables as FV
 import foxes.constants as FC
+from foxes.config import config
 
 
 class InitFarmData(FarmDataModel):
@@ -75,14 +76,16 @@ class InitFarmData(FarmDataModel):
         n_turbines = algo.n_turbines
 
         # define FV.TXYH as vector [X, Y, H]:
-        fdata[FV.TXYH] = np.full((n_states, n_turbines, 3), np.nan, dtype=FC.DTYPE)
+        fdata[FV.TXYH] = np.full(
+            (n_states, n_turbines, 3), np.nan, dtype=config.dtype_double
+        )
         fdata.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
         for i, v in enumerate([FV.X, FV.Y, FV.H]):
             fdata[v] = fdata[FV.TXYH][..., i]
             fdata.dims[v] = (FC.STATE, FC.TURBINE)
 
         # set X, Y, H, D:
-        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=FC.DTYPE)
+        fdata[FV.D] = np.zeros((n_states, n_turbines), dtype=config.dtype_double)
         for ti, t in enumerate(algo.farm.turbines):
 
             if len(t.xy.shape) == 1:

{foxes-1.1.1 → foxes-1.2}/foxes/algorithms/downwind/models/point_wakes_calc.py

@@ -1,5 +1,4 @@
 from foxes.core import PointDataModel
-import foxes.variables as FV
 
 
 class PointWakesCalculation(PointDataModel):

{foxes-1.1.1 → foxes-1.2}/foxes/algorithms/iterative/iterative.py

@@ -2,7 +2,7 @@ from foxes.algorithms.downwind.downwind import Downwind
 
 from foxes.core import FarmDataModelList
 from foxes.utils import Dict
-import foxes.variables as FV
+
 from . import models as mdls
 
 

{foxes-1.1.1 → foxes-1.2}/foxes/algorithms/sequential/sequential.py

@@ -2,9 +2,10 @@ import numpy as np
 from xarray import Dataset
 
 from foxes.algorithms import Iterative
-import foxes.constants as FC
-import foxes.variables as FV
+from foxes.config import config
 from foxes.core import get_engine
+import foxes.variables as FV
+import foxes.constants as FC
 
 from . import models as mdls
 
@@ -170,7 +171,7 @@ class Sequential(Iterative):
             self._farm_results[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
             if FV.ORDER in self._farm_results:
                 self._farm_results[FV.ORDER] = self._farm_results[FV.ORDER].astype(
-                    FC.ITYPE
+                    config.dtype_int
                 )
             self._farm_results_dwnd = self._farm_results.copy(deep=True)
 

foxes-1.2/foxes/config/__init__.py

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

foxes-1.2/foxes/config/config.py

@@ -0,0 +1,134 @@
+import numpy as np
+from pathlib import Path
+
+from foxes.utils.dict import Dict
+import foxes.constants as FC
+
+
+class Config(Dict):
+    """
+    Container for configurational data
+
+    :group: foxes.config
+    """
+
+    def __init__(self):
+        """Constructor"""
+        super().__init__(
+            {
+                FC.DTYPE: np.float64,
+                FC.ITYPE: np.int64,
+                FC.WORK_DIR: Path("."),
+                FC.OUT_DIR: Path("."),
+            },
+            name="config",
+        )
+
+    @property
+    def dtype_double(self):
+        """
+        The default double data type
+
+        Returns
+        -------
+        dtp: type
+            The default double data type
+
+        """
+        return self.get_item(FC.DTYPE)
+
+    @property
+    def dtype_int(self):
+        """
+        The default int data type
+
+        Returns
+        -------
+        dtp: type
+            The default integer data type
+
+        """
+        return self.get_item(FC.ITYPE)
+
+    @property
+    def work_dir(self):
+        """
+        The foxes working directory
+
+        Returns
+        -------
+        pth: pathlib.Path
+            Path to the foxes working directory
+
+        """
+        pth = self.get_item(FC.WORK_DIR)
+        if not isinstance(pth, Path):
+            self[FC.WORK_DIR] = Path(pth)
+        return self[FC.WORK_DIR]
+
+    @property
+    def out_dir(self):
+        """
+        The default output directory
+
+        Returns
+        -------
+        pth: pathlib.Path
+            Path to the default output directory
+
+        """
+        return get_path(self.get_item(FC.OUT_DIR))
+
+
+config = Config()
+"""Foxes configurational data object
+:group: foxes.config
+"""
+
+
+def get_path(pth):
+    """
+    Gets path object, respecting the configurations
+    work directory
+
+    Parameters
+    ----------
+    pth: str or pathlib.Path
+        The path, optionally relative
+
+    Returns
+    -------
+    out: pathlib.Path
+        The path, absolute or relative to working 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
+
+
+def get_output_path(pth):
+    """
+    Gets path object, respecting the configurations
+    output directory
+
+    Parameters
+    ----------
+    pth: str or pathlib.Path
+        The path, optionally relative
+
+    Returns
+    -------
+    out: pathlib.Path
+        The path, absolute or relative to output directory
+        from config
+
+    :group: foxes.config
+
+    """
+    if not isinstance(pth, Path):
+        pth = Path(pth)
+    return pth if pth.is_absolute() else config.out_dir / pth

{foxes-1.1.1 → foxes-1.2}/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-1.1.1 → foxes-1.2}/foxes/core/algorithm.py

@@ -5,6 +5,7 @@ from abc import abstractmethod
 from .model import Model
 from foxes.data import StaticData
 from foxes.utils import Dict, all_subclasses
+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):
@@ -375,6 +381,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 +401,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)

{foxes-1.1.1 → foxes-1.2}/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-1.1.1 → foxes-1.2}/foxes/core/engine.py

@@ -6,6 +6,7 @@ from xarray import Dataset
 
 from foxes.core import MData, FData, TData
 from foxes.utils import all_subclasses
+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,22 +546,22 @@ 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)
+            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)
 
         allc = all_subclasses(cls)
         found = engine_type in [scls.__name__ for scls in allc]
@@ -602,9 +610,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-1.1.1 → foxes-1.2}/foxes/core/farm_controller.py

@@ -1,10 +1,11 @@
 import numpy as np
 
+from foxes.config import config
+import foxes.constants as FC
+
 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 +123,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

{foxes-1.1.1 → foxes-1.2}/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-1.1.1 → foxes-1.2}/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"):