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

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/",

examples/abl_states/run.py

@@ -137,17 +137,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

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(

examples/induction/run.py

@@ -130,17 +130,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

examples/random_timeseries/run.py

@@ -101,21 +101,21 @@ if __name__ == "__main__":
     ):
 
         if not args.nofig:
-            # fig, axs= plt.subplots(2, 1, figsize=(12,6))
-            # foxes.output.FarmLayoutOutput(farm).get_figure(ax=axs[0])
+            fig = plt.figure(figsize=(14.5, 7))
+            ax1 = fig.add_subplot(121)
+            ax2 = fig.add_subplot(122, polar=True)
+            foxes.output.FarmLayoutOutput(farm).get_figure(fig=fig, ax=ax1)
 
             o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-            fig = o.get_figure(
+            o.get_figure(
                 16,
                 FV.AMB_WS,
                 [0, 3.5, 6, 10, 15, 20],
-                figsize=(14.5, 7),
-                rect=[0.01, 0.05, 0.45, 0.85],
+                fig=fig,
+                ax=ax2,
+                freq_delta=2,
             )
 
-            ax = plt.Axes(fig, rect=[0.3, 0.1, 0.8, 0.8])
-            fig.add_axes(ax)
-            foxes.output.FarmLayoutOutput(farm).get_figure(fig=fig, ax=ax)
             plt.show()
             plt.close(fig)
 
@@ -187,17 +187,17 @@ if __name__ == "__main__":
         # results by turbine
         turbine_results = o.reduce_states(
             {
-                FV.AMB_P: "mean",
-                FV.P: "mean",
-                FV.AMB_CAP: "mean",
-                FV.CAP: "mean",
-                FV.EFF: "mean",
+                FV.AMB_P: "weights",
+                FV.P: "weights",
+                FV.AMB_CAP: "weights",
+                FV.CAP: "weights",
             }
         )
         turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
             algo=algo, annual=True, ambient=True
         )
         turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+        turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
         print("\nResults by turbine:\n")
         print(turbine_results)
 

examples/scan_row/run.py

@@ -76,8 +76,13 @@ if __name__ == "__main__":
     D = ttype.D
     H = ttype.H
 
-    states = foxes.input.states.ScanWS(
-        ws_list=np.linspace(args.ws0, args.ws1, n_s), wd=270.0, ti=0.08, rho=1.225
+    states = foxes.input.states.ScanStates(
+        {
+            FV.WS: np.linspace(args.ws0, args.ws1, n_s),
+            FV.WD: [270],
+            FV.TI: [0.08],
+            FV.RHO: [1.225],
+        }
     )
 
     farm = foxes.WindFarm()
@@ -139,17 +144,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

examples/sector_management/run.py

@@ -138,25 +138,29 @@ if __name__ == "__main__":
     print(fr)
 
     if not args.nofig:
+        fig = plt.figure(figsize=(12, 4))
+        ax1 = fig.add_subplot(121, polar=True)
+        ax2 = fig.add_subplot(122, polar=True)
+
         o = foxes.output.RosePlotOutput(farm_results)
-        fig = o.get_figure(
+        o.get_figure(
             16,
             FV.P,
-            [100, 1000, 2000, 4000, 5001, 7000],
+            [0, 100, 1000, 2000, 4000, 5001, 7000],
             turbine=0,
             title="Power turbine 0",
-            figsize=(12, 6),
-            rect=[0.05, 0.1, 0.4, 0.8],
+            fig=fig,
+            ax=ax1,
         )
 
         o = foxes.output.RosePlotOutput(farm_results)
-        fig = o.get_figure(
+        o.get_figure(
             16,
             FV.P,
-            [100, 1000, 2000, 4000, 5001, 7000],
+            [0, 100, 1000, 2000, 4000, 5001, 7000],
             turbine=1,
             title="Power turbine 1",
             fig=fig,
-            rect=[0.35, 0.1, 0.8, 0.8],
+            ax=ax2,
         )
         plt.show()

examples/single_state/run.py

@@ -155,17 +155,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

examples/tab_file/run.py

@@ -89,7 +89,7 @@ if __name__ == "__main__":
     ):
         if not args.nofig:
             o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-            fig = o.get_figure(12, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
+            o.get_figure(12, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
             plt.show()
 
         farm = foxes.WindFarm()

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(

examples/timeseries/run.py

@@ -160,17 +160,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

examples/timeseries_slurm/run.py

@@ -162,17 +162,17 @@ if __name__ == "__main__":
         # results by turbine
         turbine_results = o.reduce_states(
             {
-                FV.AMB_P: "mean",
-                FV.P: "mean",
-                FV.AMB_CAP: "mean",
-                FV.CAP: "mean",
-                FV.EFF: "mean",
+                FV.AMB_P: "weights",
+                FV.P: "weights",
+                FV.AMB_CAP: "weights",
+                FV.CAP: "weights",
             }
         )
         turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
             algo=algo, annual=True, ambient=True
         )
         turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+        turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
         print("\nResults by turbine:\n")
         print(turbine_results)
 

examples/wind_rose/run.py

@@ -113,7 +113,7 @@ if __name__ == "__main__":
 
     if not args.nofig:
         o = foxes.output.StatesRosePlotOutput(states, point=[0.0, 0.0, 100.0])
-        fig = o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20])
+        o.get_figure(16, FV.AMB_WS, [0, 3.5, 6, 10, 15, 20], add_inf=True)
         plt.show()
 
     time0 = time.time()

examples/yawed_wake/run.py

@@ -173,17 +173,17 @@ if __name__ == "__main__":
     # results by turbine
     turbine_results = o.reduce_states(
         {
-            FV.AMB_P: "mean",
-            FV.P: "mean",
-            FV.AMB_CAP: "mean",
-            FV.CAP: "mean",
-            FV.EFF: "mean",
+            FV.AMB_P: "weights",
+            FV.P: "weights",
+            FV.AMB_CAP: "weights",
+            FV.CAP: "weights",
         }
     )
     turbine_results[FV.AMB_YLD] = o.calc_turbine_yield(
         algo=algo, annual=True, ambient=True
     )
     turbine_results[FV.YLD] = o.calc_turbine_yield(algo=algo, annual=True)
+    turbine_results[FV.EFF] = turbine_results[FV.P] / turbine_results[FV.AMB_P]
     print("\nResults by turbine:\n")
     print(turbine_results)
 

foxes/__init__.py

@@ -3,6 +3,7 @@ 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 (
@@ -21,6 +22,16 @@ from . import input  # noqa: F401
 from . import output  # noqa: F401
 from . import utils  # noqa: F401
 
-from importlib.metadata import version
+import importlib
+from pathlib import Path
 
-__version__ = version(__package__ or __name__)
+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/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
 
 
@@ -307,14 +311,24 @@ class Downwind(Algorithm):
         """
         return getattr(mdls, name)
 
-    def _print_deco(self, func_name, n_points=None):
+    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 = "-" * 50
+            deco = "-" * 60
             print(f"\n{deco}")
-            print(f"  Running {self.name}: {func_name}")
+            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}")
@@ -534,7 +548,7 @@ class Downwind(Algorithm):
             self.initialize()
 
         # welcome:
-        self._print_deco("calc_farm")
+        self.print_deco("calc_farm")
 
         # collect models:
         if outputs == "default":
@@ -570,7 +584,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,7 +756,8 @@ class Downwind(Algorithm):
             )
 
         # welcome:
-        self._print_deco("calc_points", n_points=points.shape[1])
+        points = np.asarray(points)
+        self.print_deco("calc_points", n_points=points.shape[1])
 
         # collect models and initialize:
         mlist, calc_pars = self._collect_point_models(

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/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/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/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
 
@@ -135,7 +136,7 @@ class Sequential(Iterative):
         if not self.iterating:
             if not self.initialized:
                 self.initialize()
-            self._print_deco("calc_farm")
+            self.print_deco("calc_farm")
 
             self._inds = self.states0.index()
             self._weights = self.states0.weights(self)
@@ -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/config/__init__.py

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

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