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

foxes/input/states/multi_height.py

@@ -1,15 +1,15 @@
 import numpy as np
 import pandas as pd
 from xarray import Dataset, open_dataset
-from pathlib import Path
 from scipy.interpolate import interp1d
 
 from foxes.core import States
 from foxes.utils import PandasFileHelper
 from foxes.data import STATES
+from foxes.config import config, get_path
+from foxes.utils import wd2uv, uv2wd
 import foxes.variables as FV
 import foxes.constants as FC
-from foxes.utils import wd2uv, uv2wd
 
 
 class MultiHeightStates(States):
@@ -92,7 +92,7 @@ class MultiHeightStates(States):
         super().__init__()
 
         self.ovars = output_vars
-        self.heights = np.array(heights, dtype=FC.DTYPE)
+        self.heights = np.array(heights, dtype=config.dtype_double)
         self.rpars = pd_read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
@@ -198,13 +198,14 @@ class MultiHeightStates(States):
 
         """
         if not isinstance(self.data_source, pd.DataFrame):
-            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}")
@@ -226,7 +227,7 @@ class MultiHeightStates(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:
@@ -446,7 +447,7 @@ class MultiHeightStates(States):
         vrs = list(mdata[self.VARS])
         n_vars = len(vrs)
 
-        coeffs = np.zeros((n_h, n_h), dtype=FC.DTYPE)
+        coeffs = np.zeros((n_h, n_h), dtype=config.dtype_double)
         np.fill_diagonal(coeffs, 1.0)
         ipars = dict(
             assume_sorted=True,
@@ -499,10 +500,14 @@ class MultiHeightStates(States):
             elif has_wd and v == FV.WS:
                 results[v] = np.linalg.norm(uv, axis=-1)
             elif v in self.fixed_vars:
-                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
+                results[v] = np.zeros(
+                    (n_states, n_targets, n_tpoints), dtype=config.dtype_double
+                )
                 results[v][:] = self.fixed_vars[v]
             elif v in self._solo:
-                results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
+                results[v] = np.zeros(
+                    (n_states, n_targets, n_tpoints), dtype=config.dtype_double
+                )
                 results[v][:] = mdata[self.var(v)][:, None, None]
             else:
                 results[v] = ires[vrs.index(v)]
@@ -620,13 +625,14 @@ class MultiHeightNCStates(MultiHeightStates):
 
         """
         if not isinstance(self.data_source, Dataset):
-            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}")
@@ -652,7 +658,7 @@ class MultiHeightNCStates(MultiHeightStates):
             self._inds = format_times_func(self._inds)
 
         w_name = 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 w_name in data.data_vars:
             if data[w_name].dims != (self.state_coord,):
                 raise ValueError(
@@ -664,7 +670,9 @@ class MultiHeightNCStates(MultiHeightStates):
                 f"Weight variable '{w_name}' defined in var2col, but not found in data_vars {list(data.data_vars.keys())}"
             )
         else:
-            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
+            )
             self._weights[:] = 1.0 / self._N
 
         cols = {}
@@ -707,11 +715,14 @@ class MultiHeightNCStates(MultiHeightStates):
             dims,
             np.stack(
                 [data.data_vars[c].to_numpy() for c in cols.values()], axis=1
-            ).astype(FC.DTYPE),
+            ).astype(config.dtype_double),
         )
 
         for v, d in self._solo.items():
-            idata["data_vars"][self.var(v)] = ((FC.STATE,), d.astype(FC.DTYPE))
+            idata["data_vars"][self.var(v)] = (
+                (FC.STATE,),
+                d.astype(config.dtype_double),
+            )
         self._solo = list(self._solo.keys())
 
         return idata

foxes/input/states/one_point_flow.py

@@ -4,6 +4,7 @@ from scipy.interpolate import interpn
 from foxes.core import States
 from foxes.utils import uv2wd
 from foxes.models.wake_frames.timelines import Timelines
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -65,7 +66,7 @@ class OnePointFlowStates(States):
 
         """
         super().__init__()
-        self.ref_xy = np.array(ref_xy, dtype=FC.DTYPE)
+        self.ref_xy = np.array(ref_xy, dtype=config.dtype_double)
         self.heights = tl_heights
         self.base_states = base_states
         self.dt_min = dt_min
@@ -268,9 +269,9 @@ class OnePointFlowStates(States):
 
         i0 = mdata.states_i0(counter=True)
         trace_p = points[:, :, :2] - ref_xy[:, :, :2]
-        trace_si = np.zeros((n_states, n_points), dtype=FC.ITYPE)
+        trace_si = np.zeros((n_states, n_points), dtype=config.dtype_int)
         trace_si[:] = i0 + np.arange(n_states)[:, None]
-        coeffs = np.full((n_states, n_points), np.nan, dtype=FC.DTYPE)
+        coeffs = np.full((n_states, n_points), np.nan, dtype=config.dtype_double)
 
         # flake8: noqa: F821
         def _eval_trace(sel, hdxy=None, hdxy0=None, trs=None):
@@ -396,7 +397,7 @@ class OnePointFlowStates(States):
             sts = trace_si[hi]
             cfs = coeffs[hi]
             data = self.timelines_data[v].to_numpy()[hi]
-            out = np.zeros(sts.shape, dtype=FC.DTYPE)
+            out = np.zeros(sts.shape, dtype=config.dtype_double)
 
             sel_low = sts < 0
             if np.any(sel_low):
@@ -436,7 +437,7 @@ class OnePointFlowStates(States):
             vres = list(data.keys())
             data = np.stack(list(data.values()), axis=-1)
 
-            eval = np.zeros((n_states, n_points, 3), dtype=FC.DTYPE)
+            eval = np.zeros((n_states, n_points, 3), dtype=config.dtype_double)
             eval[:, :, 0] = points[:, :, 2]
             eval[:, :, 1] = ar_states[:, None]
             eval[:, :, 2] = ar_points[None, :]

foxes/input/states/{scan_ws.py → scan.py}

@@ -1,50 +1,40 @@
 import numpy as np
 
 from foxes.core import States
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
 
-class ScanWS(States):
+class ScanStates(States):
     """
-    A given list of wind speeds, all other variables are fixed.
+    Scan over selected variables
 
     Parameters
     ----------
-    wd: float
-        The wind direction
-    ti: float
-        The TI value
-    rho: float
-        The air density
+    scans: dict
+        The scans, key: variable name,
+        value: scan values
 
     :group: input.states
 
     """
 
-    def __init__(self, ws_list, wd, ti=None, rho=None):
+    def __init__(self, scans, **kwargs):
         """
         Constructor.
 
         Parameters
         ----------
-        ws_list: array_like
-            The wind speed values
-        wd: float
-            The wind direction
-        ti: float, optional
-            The TI value
-        rho: float, optional
-            The air density
+        scans: dict
+            The scans, key: variable name,
+            value: scan values
+        kwargs: dict, optional
+            Parameters for the base class
 
         """
-        super().__init__()
-
-        self.__wsl = np.array(ws_list)
-        self.N = len(ws_list)
-        self.wd = wd
-        self.ti = ti
-        self.rho = rho
+        super().__init__(**kwargs)
+        self.scans = {v: np.asarray(d) for v, d in scans.items()}
 
     def load_data(self, algo, verbosity=0):
         """
@@ -69,10 +59,24 @@ class ScanWS(States):
             and `coords`, a dict with entries `dim_name_str -> dim_array`
 
         """
-        self.WS = self.var(FV.WS)
+        n_v = len(self.scans)
+        shp = [len(v) for v in self.scans.values()]
+        self._N = np.prod(shp)
+        self._vars = list(self.scans.keys())
+
+        data = np.zeros(shp + [n_v], dtype=config.dtype_double)
+        for i, d in enumerate(self.scans.values()):
+            s = [None] * n_v
+            s[i] = np.s_[:]
+            s = tuple(s)
+            data[..., i] = d[s]
+        data = data.reshape(self._N, n_v)
 
+        self.VARS = self.var("vars")
+        self.DATA = self.var("data")
         idata = super().load_data(algo, verbosity)
-        idata["data_vars"][self.WS] = ((FC.STATE,), self.__wsl)
+        idata["coords"][self.VARS] = self._vars
+        idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data)
 
         return idata
 
@@ -108,12 +112,8 @@ class ScanWS(States):
         """
         super().set_running(algo, data_stash, sel, isel, verbosity)
 
-        data_stash[self.name].update(
-            dict(
-                wsl=self.__wsl,
-            )
-        )
-        del self.__wsl
+        data_stash[self.name].update(dict(scans=self.scans))
+        del self.scans
 
     def unset_running(
         self,
@@ -145,7 +145,7 @@ class ScanWS(States):
         super().unset_running(algo, data_stash, sel, isel, verbosity)
 
         data = data_stash[self.name]
-        self.__wsl = data.pop("wsl")
+        self.scans = data.pop("scans")
 
     def size(self):
         """
@@ -157,7 +157,7 @@ class ScanWS(States):
             The total number of states
 
         """
-        return self.N
+        return self._N
 
     def output_point_vars(self, algo):
         """
@@ -174,14 +174,7 @@ class ScanWS(States):
             The output variable names
 
         """
-        pvars = [FV.WS]
-        if self.wd is not None:
-            pvars.append(FV.WD)
-        if self.ti is not None:
-            pvars.append(FV.TI)
-        if self.rho is not None:
-            pvars.append(FV.RHO)
-        return pvars
+        return self._vars
 
     def weights(self, algo):
         """
@@ -198,7 +191,9 @@ class ScanWS(States):
             The weights, shape: (n_states, n_turbines)
 
         """
-        return np.full((self.N, algo.n_turbines), 1.0 / self.N, dtype=FC.DTYPE)
+        return np.full(
+            (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
+        )
 
     def calculate(self, algo, mdata, fdata, tdata):
         """
@@ -226,14 +221,9 @@ class ScanWS(States):
             (n_states, n_targets, n_tpoints)
 
         """
-        tdata[FV.WS] = np.zeros_like(tdata[FC.TARGETS][..., 0])
-        tdata[FV.WS][:] = mdata[self.WS][:, None, None]
-
-        if self.wd is not None:
-            tdata[FV.WD] = np.full_like(tdata[FV.WS], self.wd)
-        if self.ti is not None:
-            tdata[FV.TI] = np.full_like(tdata[FV.WS], self.ti)
-        if self.rho is not None:
-            tdata[FV.RHO] = np.full_like(tdata[FV.WS], self.rho)
+        for i, v in enumerate(self._vars):
+            if v not in tdata:
+                tdata[v] = np.zeros_like(tdata[FC.TARGETS][..., 0])
+            tdata[v][:] = mdata[self.DATA][:, None, None, i]
 
         return {v: tdata[v] for v in self.output_point_vars(algo)}

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 read_dict, run_dict, run_outputs
+from .yaml import foxes_yaml
+from .windio.windio import read_windio, foxes_windio