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

foxes/input/states/single.py

@@ -1,6 +1,7 @@
 import numpy as np
 
 from foxes.core import States, VerticalProfile
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -29,7 +30,15 @@ class SingleStateStates(States):
 
     """
 
-    def __init__(self, ws=None, wd=None, ti=None, rho=None, profiles={}, **profdata):
+    def __init__(
+        self,
+        ws=None,
+        wd=None,
+        ti=None,
+        rho=None,
+        profiles={},
+        **profdata,
+    ):
         """
         Constructor.
 
@@ -163,7 +172,7 @@ class SingleStateStates(States):
             The weights, shape: (n_states, n_turbines)
 
         """
-        return np.ones((1, algo.n_turbines), dtype=FC.DTYPE)
+        return np.ones((1, algo.n_turbines), dtype=config.dtype_double)
 
     def calculate(self, algo, mdata, fdata, tdata):
         """
@@ -195,25 +204,25 @@ class SingleStateStates(States):
             tdata[FV.WS] = np.full(
                 (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
                 self.ws,
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
         if self.wd is not None:
             tdata[FV.WD] = np.full(
                 (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
                 self.wd,
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
         if self.ti is not None:
             tdata[FV.TI] = np.full(
                 (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
                 self.ti,
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
         if self.rho is not None:
             tdata[FV.RHO] = np.full(
                 (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
                 self.rho,
-                dtype=FC.DTYPE,
+                dtype=config.dtype_double,
             )
 
         if len(self._profiles):

foxes/input/states/slice_data_nc.py

@@ -2,11 +2,11 @@ import numpy as np
 import pandas as pd
 import xarray as xr
 from scipy.interpolate import interpn
-from pathlib import Path
 
 from foxes.core import States
 from foxes.utils import wd2uv, uv2wd, import_module
 from foxes.data import STATES, StaticData
+from foxes.config import config, get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -145,9 +145,11 @@ class SliceDataNC(States):
             if "*" in str(self.data_source):
                 pass
             else:
-                self.__data_source = StaticData().get_file_path(
-                    STATES, self.data_source, check_raw=True
-                )
+                self.__data_source = get_path(self.data_source)
+                if not self.data_source.is_file():
+                    self.__data_source = StaticData().get_file_path(
+                        STATES, self.data_source.name, check_raw=False
+                    )
             if verbosity:
                 if pre_load:
                     print(
@@ -159,7 +161,8 @@ class SliceDataNC(States):
                     )
 
             def _read_ds():
-                if Path(self.data_source).is_file():
+                self._data_source = get_path(self.data_source)
+                if self.data_source.is_file():
                     return xr.open_dataset(self.data_source)
                 else:
                     # try to read multiple files, needs dask:
@@ -177,8 +180,7 @@ class SliceDataNC(States):
                         import_module("dask", hint="pip install dask")
                         raise e
 
-            with _read_ds() as ds:
-                self.__data_source = ds
+            self.__data_source = _read_ds()
 
         if sel is not None:
             self.__data_source = self.data_source.sel(self.sel)
@@ -264,7 +266,9 @@ class SliceDataNC(States):
                     f"States '{self.name}': Wrong coordinate order for variable '{ncv}': Found {ds[ncv].dims}, expecting {cor_sxy}, {cor_syx}, or {cor_s}"
                 )
 
-        data = np.zeros((n_sts, n_y, n_x, len(self.var2ncvar)), dtype=FC.DTYPE)
+        data = np.zeros(
+            (n_sts, n_y, n_x, len(self.var2ncvar)), dtype=config.dtype_double
+        )
         for v in vars_syx:
             ncv = self.var2ncvar[v]
             if ds[ncv].dims == cor_syx:
@@ -276,7 +280,7 @@ class SliceDataNC(States):
             data[..., self._dkys[v]] = ds[ncv].to_numpy()[:, None, None]
         if FV.WD in self.fixed_vars:
             data[..., self._dkys[FV.WD]] = np.full(
-                (n_sts, n_y, n_x), self.fixed_vars[FV.WD], dtype=FC.DTYPE
+                (n_sts, n_y, n_x), self.fixed_vars[FV.WD], dtype=config.dtype_double
             )
 
         if verbosity > 1:
@@ -351,7 +355,7 @@ class SliceDataNC(States):
 
         if self.__weights is None:
             self.__weights = np.full(
-                (self._N, algo.n_turbines), 1.0 / self._N, dtype=FC.DTYPE
+                (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
             )
 
         idata = super().load_data(algo, verbosity)
@@ -588,7 +592,9 @@ class SliceDataNC(States):
 
         # prepare points:
         sts = np.arange(n_states)
-        pts = np.append(points, np.zeros((n_states, n_pts, 1), dtype=FC.DTYPE), axis=2)
+        pts = np.append(
+            points, np.zeros((n_states, n_pts, 1), dtype=config.dtype_double), axis=2
+        )
         pts[:, :, 3] = sts[:, None]
         pts = pts.reshape(n_states * n_pts, 3)
         pts = np.flip(pts, axis=1)
@@ -675,7 +681,7 @@ class SliceDataNC(States):
                     out[v] = data[..., self._dkys[v]]
                 else:
                     out[v] = np.full(
-                        (n_states, n_pts), self.fixed_vars[v], dtype=FC.DTYPE
+                        (n_states, n_pts), self.fixed_vars[v], dtype=config.dtype_double
                     )
 
         return {v: d.reshape(n_states, n_targets, n_tpoints) for v, d in out.items()}

foxes/input/states/states_table.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from foxes.core import States, VerticalProfile
 from foxes.utils import PandasFileHelper, read_tab_file
 from foxes.data import STATES
+from foxes.config import config, get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -214,13 +215,14 @@ class StatesTable(States):
             data = self.data_source
             isorg = True
         else:
-            if not Path(self.data_source).is_file():
+            self._data_source = get_path(self.data_source)
+            if not self.data_source.is_file():
                 if verbosity:
                     print(
                         f"States '{self.name}': Reading static data '{self.data_source}' from context '{STATES}'"
                     )
                 self._data_source = algo.dbook.get_file_path(
-                    STATES, self.data_source, check_raw=False
+                    STATES, self.data_source.name, check_raw=False
                 )
                 if verbosity:
                     print(f"Path: {self.data_source}")
@@ -238,7 +240,7 @@ class StatesTable(States):
         self.__inds = data.index.to_numpy()
 
         col_w = self.var2col.get(FV.WEIGHT, FV.WEIGHT)
-        self.__weights = np.zeros((self._N, algo.n_turbines), dtype=FC.DTYPE)
+        self.__weights = np.zeros((self._N, algo.n_turbines), dtype=config.dtype_double)
         if col_w in data:
             self.__weights[:] = data[col_w].to_numpy()[:, None]
         elif FV.WEIGHT in self.var2col:
@@ -436,14 +438,17 @@ class StatesTable(States):
                 tdata[v][:] = mdata[self.DATA][:, i, None, None]
             else:
                 tdata[v] = np.zeros(
-                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints), dtype=FC.DTYPE
+                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                    dtype=config.dtype_double,
                 )
                 tdata[v][:] = mdata[self.DATA][:, i, None, None]
                 tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
         for v, f in self.fixed_vars.items():
             tdata[v] = np.full(
-                (tdata.n_states, tdata.n_targets, tdata.n_tpoints), f, dtype=FC.DTYPE
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                f,
+                dtype=config.dtype_double,
             )
 
         z = tdata[FC.TARGETS][..., 2]
@@ -545,13 +550,14 @@ class TabStates(StatesTable):
         """
         if self.data_source is None:
             if self.__tab_data is None:
-                if not Path(self.__tab_source).is_file():
+                self.__tab_source = get_path(self.__tab_source)
+                if not self.__tab_source.is_file():
                     if verbosity:
                         print(
                             f"States '{self.name}': Reading static data '{self.__tab_source}' from context '{STATES}'"
                         )
                     self.__tab_source = algo.dbook.get_file_path(
-                        STATES, self.__tab_source, check_raw=False
+                        STATES, self.__tab_source.name, check_raw=False
                     )
                     if verbosity:
                         print(f"Path: {self.__tab_source}")
@@ -568,14 +574,15 @@ class TabStates(StatesTable):
 
             wd0 = self.__tab_data["wd"].to_numpy()
             ws0 = a * np.append(
-                np.array([0], dtype=FC.DTYPE), self.__tab_data["ws"].to_numpy()
+                np.array([0], dtype=config.dtype_double),
+                self.__tab_data["ws"].to_numpy(),
             )
             ws0 = 0.5 * (ws0[:-1] + ws0[1:])
 
             n_ws = self.__tab_data.sizes["ws"]
             n_wd = self.__tab_data.sizes["wd"]
-            ws = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
-            wd = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
+            ws = np.zeros((n_ws, n_wd), dtype=config.dtype_double)
+            wd = np.zeros((n_ws, n_wd), dtype=config.dtype_double)
             ws[:] = ws0[:, None]
             wd[:] = wd0[None, :]
 

foxes/input/yaml/__init__.py

@@ -0,0 +1,3 @@
+from .dict import run_dict
+from .yaml import foxes_yaml
+from .windio.windio import read_windio, foxes_windio

foxes/input/yaml/dict.py

@@ -0,0 +1,210 @@
+import matplotlib.pyplot as plt
+import pandas as pd
+from inspect import signature
+
+import foxes.input.farm_layout as farm_layout
+from foxes.core import States, Engine, WindFarm, Algorithm
+from foxes.models import ModelBook
+from foxes import output
+from foxes.utils import Dict
+from foxes.config import config
+import foxes.constants as FC
+
+
+def run_dict(
+    idict,
+    farm=None,
+    states=None,
+    mbook=None,
+    algo=None,
+    engine_pars=None,
+    iterative=None,
+    verbosity=None,
+    work_dir=".",
+    out_dir=".",
+    **algo_pars,
+):
+    """
+    Runs foxes from dictionary input
+
+    Parameters
+    ----------
+    idict: foxes.utils.Dict
+        The input parameter dictionary
+    farm: foxes.core.WindFarm, optional
+        The wind farm, overrules settings from idict
+    states: foxes.core.States, optional
+        The ambient states, overrules settings from idict
+    mbook: foxes.models.ModelBook, optional
+        The model book, overrules settings from idict
+    algo: foxes.core.Algorithm, optional
+        The algorithm, overrules settings from idict
+    engine_pars: dict, optional
+        Parameters for engine creation, overrules
+        settings from idict
+    iterative: bool, optional
+        Force iterative calculations, overrules
+        settings from idict
+    verbosity: int, optional
+        Force a verbosity level, 0 = silent, overrules
+        settings from idict
+    work_dir: str or pathlib.Path
+        Path to the working directory
+    out_dir: str or pathlib.Path
+        The default output directory
+    algo_pars: dict, optional
+        Additional parameters for the algorithm, overrules
+        settings from idict
+
+    Returns
+    -------
+    farm_results: xarray.Dataset, optional
+        The farm results
+    point_results: xarray.Dataset, optional
+        The point results
+    output_i: object
+        For each output either None or the output result
+
+    :group: input.yaml
+
+    """
+
+    def _print(*args, level=1, **kwargs):
+        if verbosity is None or verbosity >= level:
+            print(*args, **kwargs)
+
+    # set working directory:
+    config[FC.WORK_DIR] = work_dir
+    config[FC.OUT_DIR] = out_dir
+    _print("Working directory:", config.work_dir)
+    _print("Output directory :", config.out_dir)
+
+    # create states:
+    if states is None:
+        _print("Creating states")
+        states = States.new(**idict["states"])
+
+    # create model book:
+    if mbook is None:
+        mbook = ModelBook()
+        if "model_book" in idict:
+            _print("Creating model book")
+            mdict = idict.get_item("model_book")
+            for s, mlst in mdict.items():
+                t = mbook.sources.get_item(s)
+                c = mbook.base_classes.get_item(s)
+                ms = [Dict(m, name=f"{mdict.name}.s{i}") for i, m in enumerate(mlst)]
+                for m in ms:
+                    mname = m.pop_item("name")
+                    _print(f"  Adding {s}.{mname}")
+                    t[mname] = c.new(**m)
+
+    # create farm:
+    if farm is None:
+        _print("Creating wind farm")
+        fdict = idict.get_item("wind_farm")
+        lyts = [
+            Dict(l, name=f"{fdict.name}.layout{i}")
+            for i, l in enumerate(fdict.pop_item("layouts"))
+        ]
+        farm = WindFarm(**fdict)
+        for lyt in lyts:
+            add_fun = getattr(farm_layout, lyt.pop_item("function"))
+            if verbosity is not None:
+                lyt["verbosity"] = verbosity - 1
+            add_fun(farm, **lyt)
+
+    # create engine:
+    engine = None
+    if engine_pars is not None:
+        engine = Engine.new(**engine_pars)
+        _print(f"Initializing engine: {engine}")
+        engine.initialize()
+    elif "engine" in idict:
+        if verbosity is not None:
+            idict["verbosity"] = verbosity - 1
+        engine = Engine.new(**idict["engine"])
+        engine.initialize()
+        _print(f"Initializing engine: {engine}")
+
+    # create algorithm:
+    if algo is None:
+        _print("Creating algorithm")
+        adict = idict.get_item("algorithm")
+        if iterative is not None and iterative:
+            adict["algo_type"] = "Iterative"
+        adict.update(dict(farm=farm, states=states, mbook=mbook))
+        if verbosity is not None:
+            adict["verbosity"] = verbosity - 1
+        if algo_pars is not None:
+            adict.update(algo_pars)
+        algo = Algorithm.new(**adict)
+
+    # run farm calculation:
+    rdict = idict.get_item("calc_farm")
+    if rdict.pop_item("run"):
+        _print("Running calc_farm")
+        farm_results = algo.calc_farm(**rdict)
+    else:
+        farm_results = None
+    out = (farm_results,)
+
+    # run points calculation:
+    if "calc_points" in idict:
+        rdict = idict.get_item("calc_points")
+        if rdict.pop_item("run"):
+            _print("Running calc_points")
+            points = rdict.pop_item("points")
+            if isinstance(points, str):
+                _print("Reading file", points)
+                points = pd.read_csv(points).to_numpy()
+            point_results = algo.calc_points(farm_results, points=points, **rdict)
+        else:
+            point_results = None
+        out += (point_results,)
+
+    # run outputs:
+    if "outputs" in idict:
+        _print("Running outputs")
+        odict = idict["outputs"]
+        for ocls, d in odict.items():
+            _print(f"  Output {ocls}")
+            flist = [
+                Dict(f, name=f"{d.name}.function{i}")
+                for i, f in enumerate(d.pop_item("functions"))
+            ]
+            try:
+                cls = getattr(output, ocls)
+            except AttributeError as e:
+                print(f"\nClass '{ocls}' not found in outputs. Found:")
+            prs = list(signature(cls.__init__).parameters.keys())
+            if "algo" in prs:
+                d["algo"] = algo
+            if "farm_results" in prs:
+                if farm_results is None:
+                    print(f"No farm results; skipping output {ocls}")
+                    for fdict in flist:
+                        out += (None,)
+                    continue
+                d["farm_results"] = farm_results
+            o = cls(**d)
+            for fdict in flist:
+                fname = fdict.pop_item("name")
+                _print(f"  - {fname}")
+                plt_show = fdict.pop("plt_show", False)
+                f = getattr(o, fname)
+                prs = list(signature(f).parameters.keys())
+                if "algo" in prs:
+                    fdict["algo"] = algo
+                res = f(**fdict)
+                out += (res,) if not isinstance(res, tuple) else res
+                if plt_show:
+                    plt.show()
+                    plt.close()
+
+    # shutdown engine, if created above:
+    if engine is not None:
+        _print(f"Finalizing engine: {engine}")
+        engine.finalize()
+
+    return out

foxes/input/yaml/windio/__init__.py

@@ -0,0 +1,4 @@
+from .windio import foxes_windio, read_windio
+from .read_fields import read_wind_resource_field
+from .read_farm import read_layout, read_turbine_types
+from .read_attributes import read_attributes

foxes/input/{windio → yaml/windio}/get_states.py

@@ -4,13 +4,13 @@ from xarray import Dataset
 from numbers import Number
 
 from foxes.core import States
-import foxes.constants as FC
 import foxes.variables as FV
+import foxes.constants as FC
 
 
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
-    :group: input.windio
+    :group: input.yaml.windio
     """
     profiles = {}
     if FV.Z0 in fields:
@@ -42,7 +42,7 @@ def _get_SingleStateStates(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate single state parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     for c in coords:
         if not isinstance(c, Number):
@@ -81,7 +81,7 @@ def _get_Timeseries(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate time series parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if len(coords) == 1 and FC.TIME in coords:
         if verbosity > 2:
@@ -117,7 +117,7 @@ def _get_MultiHeightNCTimeseries(
     coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
 ):
     """Try to generate time series parameters
-    :group: input.windio
+    :group: input.yaml.windio
     """
     if len(coords) == 2 and FC.TIME in coords and FV.H in coords:
         if verbosity > 2:
@@ -176,11 +176,11 @@ def get_states(coords, fields, dims, verbosity=1):
     states: foxes.core.States
         The states object
 
-    :group: input.windio
+    :group: input.yaml.windio
 
     """
     if verbosity > 2:
-        print("      Preparing states")
+        print("      Creating states")
 
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
     fixval = {FV.TI: 0.05, FV.RHO: 1.225}