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

foxes/output/farm_results_eval.py

@@ -4,6 +4,7 @@ from cycler import cycler
 import matplotlib.pyplot as plt
 
 from .output import Output
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -409,7 +410,7 @@ class FarmResultsEval(Output):
         if algo is not None and P_unit_W is None:
             P_unit_W = np.array(
                 [FC.P_UNITS[t.P_unit] for t in algo.farm_controller.turbine_types],
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )[:, None]
         elif algo is None and P_unit_W is not None:
             pass
@@ -472,10 +473,10 @@ class FarmResultsEval(Output):
         if algo is not None and P_nom is None:
             P_nom = np.array(
                 [t.P_nominal for t in algo.farm_controller.turbine_types],
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
         elif algo is None and P_nom is not None:
-            P_nom = np.array(P_nom, dtype=FC.DTYPE)
+            P_nom = np.array(P_nom, dtype=config.dtype_double)
         else:
             raise KeyError("Expecting either 'algo' or 'P_nom'")
 

foxes/output/grids.py

@@ -3,6 +3,7 @@ import pandas as pd
 from xarray import Dataset
 
 from foxes.utils import wd2uv, write_nc
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -151,7 +152,7 @@ def get_grid_xy(
     N_x, N_y = len(x_pos), len(y_pos)
     n_pts = len(x_pos) * len(y_pos)
     z_pos = 0.5 * (z_min + z_max)
-    g_pts = np.zeros((n_states, N_x, N_y, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_x, N_y, 3), dtype=config.dtype_double)
     g_pts[:, :, :, 0] = x_pos[None, :, None]
     g_pts[:, :, :, 1] = y_pos[None, None, :]
     g_pts[:, :, :, 2] = z_pos
@@ -248,7 +249,7 @@ def get_grid_xz(
     n_y = np.cross(n_z, n_x)
 
     # project to axes:
-    xyz = np.zeros((n_states, n_turbines, 3), dtype=FC.DTYPE)
+    xyz = np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double)
     xyz[:, :, 0] = farm_results[FV.X]
     xyz[:, :, 1] = farm_results[FV.Y]
     xyz[:, :, 2] = farm_results[FV.H]
@@ -297,7 +298,7 @@ def get_grid_xz(
     N_x, N_z = len(x_pos), len(z_pos)
     n_pts = len(x_pos) * len(z_pos)
     y_pos = 0.5 * (y_min + y_max)
-    g_pts = np.zeros((n_states, N_x, N_z, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_x, N_z, 3), dtype=config.dtype_double)
     g_pts[:] += x_pos[None, :, None, None] * n_x[None, None, None, :]
     g_pts[:] += y_pos * n_y[None, None, None, :]
     g_pts[:] += z_pos[None, None, :, None] * n_z[None, None, None, :]
@@ -394,7 +395,7 @@ def get_grid_yz(
     n_y = np.cross(n_z, n_x)
 
     # project to axes:
-    xyz = np.zeros((n_states, n_turbines, 3), dtype=FC.DTYPE)
+    xyz = np.zeros((n_states, n_turbines, 3), dtype=config.dtype_double)
     xyz[:, :, 0] = farm_results[FV.X]
     xyz[:, :, 1] = farm_results[FV.Y]
     xyz[:, :, 2] = farm_results[FV.H]
@@ -443,7 +444,7 @@ def get_grid_yz(
     N_y, N_z = len(y_pos), len(z_pos)
     n_pts = len(y_pos) * len(z_pos)
     x_pos = 0.5 * (x_min + x_max)
-    g_pts = np.zeros((n_states, N_y, N_z, 3), dtype=FC.DTYPE)
+    g_pts = np.zeros((n_states, N_y, N_z, 3), dtype=config.dtype_double)
     g_pts[:] += x_pos * n_x[None, None, None, :]
     g_pts[:] += y_pos[None, :, None, None] * n_y[None, None, None, :]
     g_pts[:] += z_pos[None, None, :, None] * n_z[None, None, None, :]
@@ -491,7 +492,7 @@ def np2np_p(data, a_pos, b_pos):
     n_a = len(a_pos)
     n_b = len(b_pos)
     n_v = len(data)
-    out = np.zeros((n_a, n_b, n_v), dtype=FC.DTYPE)
+    out = np.zeros((n_a, n_b, n_v), dtype=config.dtype_double)
     for vi, (v, d) in enumerate(data.items()):
         out[:, :, vi] = d.reshape(n_a, n_b)
     return out
@@ -526,7 +527,7 @@ def np2np_sp(data, states, a_pos, b_pos):
     n_a = len(a_pos)
     n_b = len(b_pos)
     n_v = len(data)
-    out = np.zeros((n_s, n_a, n_b, n_v), dtype=FC.DTYPE)
+    out = np.zeros((n_s, n_a, n_b, n_v), dtype=config.dtype_double)
     for vi, (v, d) in enumerate(data.items()):
         out[:, :, :, vi] = d.reshape(n_s, n_a, n_b)
     return out

foxes/output/output.py

@@ -1,5 +1,6 @@
 from pathlib import Path
 
+from foxes.config import config, get_path
 from foxes.utils import PandasFileHelper, all_subclasses
 
 
@@ -33,9 +34,13 @@ class Output:
             Modifies file names by f(fname)
 
         """
-        self.out_dir = Path(out_dir) if out_dir is not None else None
+        self.out_dir = get_path(out_dir) if out_dir is not None else config.out_dir
         self.out_fname_fun = out_fname_fun
 
+        if not self.out_dir.is_dir():
+            print(f"{type(self).__name__}: Creating output dir {self.out_dir}")
+            self.out_dir.mkdir(parents=True)
+
     def get_fpath(self, fname):
         """
         Gets the total file path
@@ -54,7 +59,7 @@ class Output:
         fnm = Path(fname)
         if self.out_fname_fun is not None:
             fnm = self.out_fname_fun(fnm)
-        return self.out_dir / fnm if self.out_dir is not None else fnm
+        return self.out_dir / fnm if self.out_dir is not None else get_path(fnm)
 
     def write(self, file_name, data, format_col2var={}, format_dict={}, **kwargs):
         """

foxes/output/results_writer.py

@@ -1,8 +1,8 @@
 import pandas as pd
 from xarray import Dataset
 
-import foxes.constants as FC
 from foxes.utils import write_nc
+import foxes.constants as FC
 
 from .output import Output
 
@@ -70,7 +70,7 @@ class ResultsWriter(Output):
 
     def write_csv(
         self,
-        file_path,
+        file_name,
         variables=None,
         turbine_names=False,
         state_turbine_table=False,
@@ -82,8 +82,8 @@ class ResultsWriter(Output):
 
         Parameters
         ----------
-        file_path: str
-            Path for the csv file
+        file_name: str
+            Name of the csv file
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values
@@ -101,7 +101,7 @@ class ResultsWriter(Output):
 
         """
         if verbosity:
-            print(f"ResultsWriter: Writing file '{file_path}'")
+            print(f"ResultsWriter: Writing file '{file_name}'")
 
         data, variables = self._get_data_vars(variables)
         data.reset_index(inplace=True)
@@ -133,12 +133,11 @@ class ResultsWriter(Output):
         else:
             data.set_index([FC.STATE, tix], inplace=True)
 
-        fpath = self.get_fpath(file_path)
-        super().write(fpath, data, format_col2var=fc2v, **kwargs)
+        super().write(file_name, data, format_col2var=fc2v, **kwargs)
 
     def write_nc(
         self,
-        file_path,
+        file_name,
         variables=None,
         turbine_names=False,
         verbosity=1,
@@ -149,8 +148,8 @@ class ResultsWriter(Output):
 
         Parameters
         ----------
-        file_path: str
-            Path for the nc file
+        file_name: str
+            The nc file name
         variables: dict or list of str, optional
             The variables to be written. If a dict, then
             the keys are the foxes variables and the values
@@ -185,5 +184,5 @@ class ResultsWriter(Output):
             },
         )
 
-        fpath = self.get_fpath(file_path)
+        fpath = self.get_fpath(file_name)
         write_nc(ds, fpath, verbosity=verbosity, **kwargs)

foxes/output/rose_plot.py

@@ -1,12 +1,13 @@
 import numpy as np
 import pandas as pd
 
-import foxes.variables as FV
-import foxes.constants as FC
 from foxes.utils import wd2uv, uv2wd, TabWindroseAxes
 from foxes.algorithms import Downwind
 from foxes.core import WindFarm, Turbine
 from foxes.models import ModelBook
+import foxes.variables as FV
+import foxes.constants as FC
+
 from .output import Output
 
 
@@ -23,7 +24,7 @@ class RosePlotOutput(Output):
 
     """
 
-    def __init__(self, results):
+    def __init__(self, results, **kwargs):
         """
         Constructor.
 
@@ -31,8 +32,11 @@ class RosePlotOutput(Output):
         ----------
         results: xarray.Dataset
             The calculation results (farm or points)
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         dims = list(results.sizes.keys())
         if dims[1] == FC.TURBINE:
             self._rtype = FC.TURBINE
@@ -324,7 +328,7 @@ class RosePlotOutput(Output):
         Parameters
         ----------
         file_name: str
-            Path to the output file
+            Name of the output file
         sectors: int
             The number of wind direction sectors
         var: str
@@ -350,31 +354,45 @@ class RosePlotOutput(Output):
             ret_data=ret_data,
             **kwargs,
         )
+        fpath = self.get_fpath(file_name)
         if ret_data:
-            r[0].write_image(file_name)
+            r[0].write_image(fpath)
             return r[1]
         else:
-            r.write_image(file_name)
+            r.write_image(fpath)
 
 
 class StatesRosePlotOutput(RosePlotOutput):
     """
-     Class for rose plot creation directly from states
-
-     Parameters
-     ----------
-     states: foxes.core.States
-         The states from which to compute the wind rose
-     point: numpy.ndarray
-         The evaluation point, shape: (3,)
-     mbook: foxes.models.ModelBook, optional
-         The model book
-
+    Class for rose plot creation directly from states
     :group: output
-
     """
 
-    def __init__(self, states, point, mbook=None, ws_var=FV.AMB_REWS):
+    def __init__(
+        self,
+        states,
+        point,
+        mbook=None,
+        ws_var=FV.AMB_REWS,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        states: foxes.core.States
+            The states from which to compute the wind rose
+        point: numpy.ndarray
+            The evaluation point, shape: (3,)
+        mbook: foxes.models.ModelBook, optional
+            The model book
+        ws_var: str
+            The wind speed variable name
+        kwargs: dict, optional
+            Additional parameters for the base class
+
+        """
         farm = WindFarm()
         farm.add_turbine(
             Turbine(
@@ -390,4 +408,4 @@ class StatesRosePlotOutput(RosePlotOutput):
 
         results = algo.calc_farm(ambient=True).rename_vars({ws_var: FV.AMB_WS})
 
-        super().__init__(results)
+        super().__init__(results, **kwargs)

foxes/output/rotor_point_plots.py

@@ -1,14 +1,15 @@
 import numpy as np
 import matplotlib.pyplot as plt
 from matplotlib import colormaps
-from matplotlib.colors import LinearSegmentedColormap
 
 from foxes.input.states import SingleStateStates
 from foxes.core import WindFarm
 from foxes.algorithms import Downwind
 
+from .output import Output
 
-class RotorPointPlot:
+
+class RotorPointPlot(Output):
     """
     Visualizes rotor points and their weights.
 
@@ -23,7 +24,7 @@ class RotorPointPlot:
 
     """
 
-    def __init__(self, rotor_model, algo=None):
+    def __init__(self, rotor_model, algo=None, **kwargs):
         """
         Constructor.
 
@@ -33,8 +34,11 @@ class RotorPointPlot:
             The rotor model
         algo: foxes.core.Algorithm, optional
             The algorithm
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.rotor_model = rotor_model
         self.algo = algo
 

foxes/output/slice_data.py

@@ -2,8 +2,8 @@ import numpy as np
 
 from foxes.output import Output
 from foxes.utils import write_nc
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 from . import grids
 

foxes/output/state_turbine_map.py

@@ -2,6 +2,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 
 import foxes.constants as FC
+
 from .output import Output
 
 
@@ -19,7 +20,7 @@ class StateTurbineMap(Output):
 
     """
 
-    def __init__(self, farm_results):
+    def __init__(self, farm_results, **kwargs):
         """
         Constructor.
 
@@ -27,8 +28,11 @@ class StateTurbineMap(Output):
         ----------
         farm_results: xarray.Dataset
             The farm results
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.results = farm_results
 
     def plot_map(

foxes/output/state_turbine_table.py

@@ -19,7 +19,7 @@ class StateTurbineTable(Output):
 
     """
 
-    def __init__(self, farm_results):
+    def __init__(self, farm_results, **kwargs):
         """
         Constructor.
 
@@ -27,8 +27,11 @@ class StateTurbineTable(Output):
         ----------
         farm_results: xarray.Dataset
             The farm results
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.farm_results = farm_results
 
     def get_dataset(
@@ -48,7 +51,7 @@ class StateTurbineTable(Output):
         name_map: dict
             Map from foxes to output names
         to_file: str, optional
-            The output file path, if writing is desired
+            Name of the output file, if writing is desired
         kwargs: dict, optional
             Additional parameters for write_nc
 
@@ -73,6 +76,7 @@ class StateTurbineTable(Output):
         )
 
         if to_file is not None:
-            write_nc(ds=ds, fpath=to_file, **kwargs)
+            fpath = self.get_fpath(to_file)
+            write_nc(ds=ds, fpath=fpath, **kwargs)
 
         return ds

foxes/output/turbine_type_curves.py

@@ -7,8 +7,10 @@ from foxes.input.states import StatesTable
 from foxes.core import WindFarm, Turbine
 from foxes.algorithms import Downwind
 from foxes.models.turbine_models import SetFarmVars
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
+
 from .output import Output
 
 
@@ -26,7 +28,7 @@ class TurbineTypeCurves(Output):
 
     """
 
-    def __init__(self, mbook):
+    def __init__(self, mbook, **kwargs):
         """
         Constructor.
 
@@ -34,8 +36,11 @@ class TurbineTypeCurves(Output):
         ----------
         mbook: foxes.models.ModelBook
             The model book
+        kwargs: dict, optional
+            Additional parameters for the base class
 
         """
+        super().__init__(**kwargs)
         self.mbook = mbook
 
     def plot_curves(
@@ -113,7 +118,7 @@ class TurbineTypeCurves(Output):
         if not isinstance(axs, (list, tuple, np.ndarray)):
             axs = [axs]
 
-        ws = np.arange(ws_min, ws_max + ws_step, ws_step, dtype=FC.DTYPE)
+        ws = np.arange(ws_min, ws_max + ws_step, ws_step, dtype=config.dtype_double)
         n_states = len(ws)
         sdata = pd.DataFrame(index=range(n_states))
         sdata.index.name = FC.STATE

foxes/utils/dict.py

@@ -1,3 +1,7 @@
+from yaml import safe_load
+from pathlib import Path
+
+
 class Dict(dict):
     """
     A slightly enhanced dictionary.
@@ -25,10 +29,34 @@ class Dict(dict):
             Arguments passed to `dict`
 
         """
-        super().__init__(*args, **kwargs)
+        tmp = dict()
+        for a in args:
+            tmp.update(
+                {
+                    k: (
+                        Dict(d, name=f"{name}.{k}")
+                        if isinstance(d, dict) and not isinstance(d, Dict)
+                        else d
+                    )
+                    for k, d in a.items()
+                }
+            )
+
+        super().__init__(
+            **tmp,
+            **{
+                k: (
+                    Dict(d, name=k)
+                    if isinstance(d, dict) and not isinstance(d, Dict)
+                    else d
+                )
+                for k, d in kwargs.items()
+            },
+        )
+
         self.name = name if name is not None else type(self).__name__
 
-    def get_item(self, key, prnt=True):
+    def get_item(self, key, *deflt, prnt=True):
         """
         Gets an item, prints readable error if not found
 
@@ -36,12 +64,25 @@ class Dict(dict):
         ----------
         key: immutable object
             The key
+        deflt: tuple, optional
+            Tuple of length 1, containing the default
         prnt: bool
             Flag for message printing
 
+        Returns
+        -------
+        data: object
+            The data
+
         """
         try:
-            return self[key]
+            if len(deflt):
+                assert (
+                    len(deflt) == 1
+                ), f"Expecting a single default entry, got {len(deflt)}"
+                data = self.get(key, deflt[0])
+            else:
+                data = self[key]
         except KeyError as e:
             if prnt:
                 print(f"\n{self.name}: Cannot find key '{key}'.\n")
@@ -51,6 +92,35 @@ class Dict(dict):
                 print()
             raise e
 
+        if isinstance(data, dict) and not isinstance(data, Dict):
+            data = Dict(data, name=f"{self.name}.{key}")
+
+        return data
+
+    def pop_item(self, key, *deflt, prnt=True):
+        """
+        Pops an item, prints readable error if not found
+
+        Parameters
+        ----------
+        key: immutable object
+            The key
+        deflt: tuple, optional
+            Tuple of length 1, containing the default
+        prnt: bool
+            Flag for message printing
+
+        Returns
+        -------
+        data: object
+            The data
+
+        """
+        data = self.get_item(key, *deflt, prnt=prnt)
+        if key in self:
+            del self[key]
+        return data
+
     def __getitem__(self, key):
         try:
             return super().__getitem__(key)
@@ -58,3 +128,37 @@ class Dict(dict):
             k = ", ".join(sorted([f"{s}" for s in self.keys()]))
             e = f"{self.name}: Cannot find key '{key}'. Known keys: {k}"
             raise KeyError(e)
+
+    @classmethod
+    def from_yaml(self, yml_file, verbosity=1):
+        """
+        Reads a yaml file
+
+        Parameters
+        ----------
+        yml_file: str
+            Path to the yaml file
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        Returns
+        -------
+        dct: Dict
+            The data
+
+        """
+
+        def _print(*args, level=1, **kwargs):
+            if verbosity >= level:
+                print(*args, **kwargs)
+
+        fpath = Path(yml_file)
+        _print("Reading file", fpath)
+        with open(fpath) as stream:
+            data = safe_load(stream)
+        if data is None:
+            data = {}
+        dct = Dict(data, name=fpath.stem)
+        _print(dct, level=2)
+
+        return dct

foxes/utils/geopandas_utils.py

@@ -1,7 +1,8 @@
 import numpy as np
 import argparse
 
-import foxes.constants as FC
+from foxes.config import config
+
 from .dict import Dict
 from .geom2d import AreaUnion, ClosedPolygon
 
@@ -212,7 +213,7 @@ def read_shp_polygons(
                 if not len(data):
                     return []
                 if isinstance(data[0], tuple):
-                    out = np.array(data, dtype=FC.DTYPE)
+                    out = np.array(data, dtype=config.dtype_double)
                     return _to_utm(out) if apply_utm else out
                 return [_to_numpy(d) for d in data]