foxes 1.1.1__tar.gz → 1.2.1__tar.gz

{foxes-1.1.1 → foxes-1.2.1}/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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 1.1.1
+Version: 1.2.1
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Jonas Schulte
 Maintainer: Jonas Schulte
@@ -54,7 +54,6 @@ Requires-Dist: pandas
 Requires-Dist: xarray
 Requires-Dist: scipy
 Requires-Dist: netcdf4
-Requires-Dist: windrose
 Requires-Dist: cycler
 Requires-Dist: tqdm
 Requires-Dist: pyyaml
@@ -163,6 +162,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.1}/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.1}/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.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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()

{foxes-1.1.1 → foxes-1.2.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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()

{foxes-1.1.1 → foxes-1.2.1}/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.1.1 → foxes-1.2.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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)
 

{foxes-1.1.1 → foxes-1.2.1}/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()

{foxes-1.1.1 → foxes-1.2.1}/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-1.2.1/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.1}/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-1.1.1 → foxes-1.2.1}/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.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-1.1.1 → foxes-1.2.1}/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.1}/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-1.2.1/foxes/config/__init__.py

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