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

foxes/core/turbine_type.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
+from foxes.utils import new_instance
 import foxes.constants as FC
-from foxes.utils import all_subclasses
 
 from .turbine_model import TurbineModel
 
@@ -127,20 +127,4 @@ class TurbineType(TurbineModel):
             Additional parameters for constructor
 
         """
-
-        if ttype_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = ttype_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == ttype_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = "Turbine type class '{}' is not defined, available types are \n {}".format(
-                ttype_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, ttype_type, *args, **kwargs)

foxes/core/vertical_profile.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 
 from .model import Model
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 
 
 class VerticalProfile(Model):
@@ -48,30 +48,18 @@ class VerticalProfile(Model):
         pass
 
     @classmethod
-    def new(cls, profile_type, **kwargs):
+    def new(cls, profile_type, *args, **kwargs):
         """
-        Run-time profile factory.
+        Run-time vertical profile factory.
 
         Parameters
         ----------
         profile_type: str
             The selected derived class name
+        args: tuple, optional
+            Additional parameters for the constructor
+        kwargs: dict, optional
+            Additional parameters for the constructor
 
         """
-
-        if profile_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = profile_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == profile_type:
-                    return scls(**kwargs)
-
-        else:
-            estr = "Vertical profile type '{}' is not defined, available types are \n {}".format(
-                profile_type, sorted([i.__name__ for i in allc])
-            )
-            raise KeyError(estr)
+        return new_instance(cls, profile_type, *args, **kwargs)

foxes/core/wake_frame.py

@@ -2,9 +2,10 @@ from abc import abstractmethod
 import numpy as np
 from scipy.interpolate import interpn
 
-from foxes.utils import all_subclasses
-import foxes.constants as FC
+from foxes.utils import new_instance
+from foxes.config import config
 import foxes.variables as FV
+import foxes.constants as FC
 
 from .data import TData
 from .model import Model
@@ -243,7 +244,7 @@ class WakeFrame(Model):
             n_steps += 1
         n_ix = n_steps + 1
         xs = np.arange(xmin, xmin + n_ix * dx, dx)
-        xpts = np.zeros((n_states, n_steps), dtype=FC.DTYPE)
+        xpts = np.zeros((n_states, n_steps), dtype=config.dtype_double)
         xpts[:] = xs[None, 1:]
         pts = self.get_centreline_points(algo, mdata, fdata, downwind_index, xpts)
 
@@ -251,7 +252,8 @@ class WakeFrame(Model):
         tdata = TData.from_points(
             pts,
             data={
-                v: np.full((n_states, n_steps, 1), np.nan, dtype=FC.DTYPE) for v in vrs
+                v: np.full((n_states, n_steps, 1), np.nan, dtype=config.dtype_double)
+                for v in vrs
             },
             dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in vrs},
         )
@@ -280,13 +282,13 @@ class WakeFrame(Model):
             del wcalc, res
 
         # collect integration results:
-        iresults = np.zeros((n_states, n_ix, n_vars), dtype=FC.DTYPE)
+        iresults = np.zeros((n_states, n_ix, n_vars), dtype=config.dtype_double)
         for vi, v in enumerate(variables):
             for i in range(n_steps):
                 iresults[:, i + 1, vi] = iresults[:, i, vi] + tdata[v][:, i, 0] * dx
 
         # interpolate to x of interest:
-        qts = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)
+        qts = np.zeros((n_states, n_points, 2), dtype=config.dtype_double)
         qts[:, :, 0] = np.arange(n_states)[:, None]
         qts[:, :, 1] = x
         qts = qts.reshape(n_states * n_points, 2)
@@ -316,22 +318,4 @@ class WakeFrame(Model):
             Additional parameters for constructor
 
         """
-
-        if wframe_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = wframe_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == wframe_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = (
-                "Wake frame type '{}' is not defined, available types are \n {}".format(
-                    wframe_type, sorted([i.__name__ for i in allc])
-                )
-            )
-            raise KeyError(estr)
+        return new_instance(cls, wframe_type, *args, **kwargs)

foxes/core/wake_model.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 import numpy as np
 
-from foxes.utils import all_subclasses, Factory
+from foxes.utils import new_instance
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -141,25 +141,7 @@ class WakeModel(Model):
             Additional parameters for constructor
 
         """
-
-        if wmodel_type is None:
-            return None
-
-        allc = all_subclasses(cls)
-        found = wmodel_type in [scls.__name__ for scls in allc]
-
-        if found:
-            for scls in allc:
-                if scls.__name__ == wmodel_type:
-                    return scls(*args, **kwargs)
-
-        else:
-            estr = (
-                "Wake model type '{}' is not defined, available types are \n {}".format(
-                    wmodel_type, sorted([i.__name__ for i in allc])
-                )
-            )
-            raise KeyError(estr)
+        return new_instance(cls, wmodel_type, *args, **kwargs)
 
 
 class TurbineInductionModel(WakeModel):
@@ -184,6 +166,23 @@ class TurbineInductionModel(WakeModel):
         """
         return False
 
+    @classmethod
+    def new(cls, induction_type, *args, **kwargs):
+        """
+        Run-time turbine induction model factory.
+
+        Parameters
+        ----------
+        induction_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+        return new_instance(cls, induction_type, *args, **kwargs)
+
 
 class WakeK(Model):
     """
@@ -259,6 +258,11 @@ class WakeK(Model):
             s = f"k_var={self.k_var}"
         return s
 
+    @property
+    def is_kTI(self):
+        """Flag for ka != 0"""
+        return self._ka is not None and self._ka != 0
+
     @property
     def all_none(self):
         """Flag for k=ka=kb=None"""

foxes/core/wake_superposition.py

@@ -1,5 +1,7 @@
 from abc import abstractmethod
 
+from foxes.utils import new_instance
+
 from .model import Model
 
 
@@ -106,3 +108,20 @@ class WakeSuperposition(Model):
 
         """
         pass
+
+    @classmethod
+    def new(cls, superp_type, *args, **kwargs):
+        """
+        Run-time wake superposition model factory.
+
+        Parameters
+        ----------
+        superp_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+        return new_instance(cls, superp_type, *args, **kwargs)

foxes/data/__init__.py

@@ -3,4 +3,4 @@ Static data collection.
 """
 
 from .parse import parse_Pct_file_name, parse_Pct_two_files
-from .static_data import FARM, STATES, PCTCURVE, WINDIO, StaticData
+from .static_data import FARM, STATES, PCTCURVE, StaticData

foxes/data/static_data.py

@@ -3,7 +3,6 @@ from foxes.utils import DataBook
 from . import farms
 from . import states
 from . import power_ct_curves
-from . import windio
 
 FARM = "farm"
 """ Static wind farm data identifier
@@ -20,11 +19,6 @@ PCTCURVE = "power_ct_curve"
 :group: data
 """
 
-WINDIO = "windio"
-""" Static windio data identifier
-:group: data
-"""
-
 
 class StaticData(DataBook):
     """
@@ -41,4 +35,3 @@ class StaticData(DataBook):
         self.add_data_package(FARM, farms, ".csv")
         self.add_data_package(STATES, states, [".csv", ".csv.gz", ".nc", ".tab"])
         self.add_data_package(PCTCURVE, power_ct_curves, ".csv")
-        self.add_data_package(WINDIO, windio, ".yaml")

foxes/engines/dask.py

@@ -5,6 +5,7 @@ from tqdm import tqdm
 
 from foxes.core import Engine, MData, FData, TData
 from foxes.utils import import_module
+from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -212,7 +213,7 @@ def _run_as_ufunc(
     odims = {v: tuple(out_coords) for v in out_vars}
     odata = {
         v: (
-            np.full(oshape, np.nan, dtype=FC.DTYPE)
+            np.full(oshape, np.nan, dtype=config.dtype_double)
             if v not in init_vars
             else prev[init_vars.index(v)].copy()
         )
@@ -264,7 +265,7 @@ def _run_as_ufunc(
 
     # create output:
     n_vars = len(out_vars)
-    data = np.zeros(oshape + [n_vars], dtype=FC.DTYPE)
+    data = np.zeros(oshape + [n_vars], dtype=config.dtype_double)
     for v in out_vars:
         data[..., out_vars.index(v)] = results[v]
 
@@ -449,7 +450,7 @@ class XArrayEngine(DaskBaseEngine):
             *ldata,
             input_core_dims=[[]] + iidims + icdims,
             output_core_dims=[out_core_vars],
-            output_dtypes=[FC.DTYPE],
+            output_dtypes=[config.dtype_double],
             dask="parallelized",
             dask_gufunc_kwargs=dargs,
             kwargs=wargs,

foxes/engines/single.py

@@ -1,7 +1,7 @@
 from xarray import Dataset
 
-import foxes.constants as FC
 from foxes.core import Engine
+import foxes.constants as FC
 
 
 class SingleChunkEngine(Engine):

foxes/input/__init__.py

@@ -4,4 +4,4 @@ Functions and classes for input data definition.
 
 from . import farm_layout
 from . import states
-from . import windio
+from . import yaml

foxes/input/farm_layout/from_csv.py

@@ -1,6 +1,7 @@
 import pandas as pd
 
 from foxes.core import Turbine
+from foxes.config import get_path
 
 
 def add_from_csv(
@@ -75,7 +76,8 @@ def add_from_csv(
     else:
         if verbosity:
             print("Reading file", data_source)
-        data = pd.read_csv(data_source, index_col=col_index)
+        pth = get_path(data_source)
+        data = pd.read_csv(pth, index_col=col_index)
 
     tmodels = turbine_parameters.pop("turbine_models", [])
     H = turbine_parameters.pop("H", None)

foxes/input/farm_layout/from_file.py

@@ -1,6 +1,6 @@
-from pathlib import Path
-
 from foxes.data import FARM, StaticData
+from foxes.config import get_path
+
 from .from_json import add_from_json
 from .from_csv import add_from_csv
 
@@ -31,24 +31,24 @@ def add_from_file(farm, file_path, *args, verbosity=1, dbook=None, **kwargs):
 
     """
 
-    fpath = Path(file_path)
+    fpath = get_path(file_path)
     dbook = StaticData() if dbook is None else dbook
 
     if not fpath.is_file():
         if verbosity:
             print(f"Reading static data '{fpath.name}' from context '{FARM}'")
-        fpath = dbook.get_file_path(FARM, fpath.name, check_raw=False)
+        file_path = dbook.get_file_path(FARM, fpath.name, check_raw=False)
 
     if fpath.suffix == ".json":
-        add_from_json(farm, fpath, *args, **kwargs)
+        add_from_json(farm, file_path, *args, **kwargs)
     elif (
         fpath.suffix == ".csv"
-        or (len(fpath) > 7 and fpath[-7:] == ".csv.gz")
-        or (len(fpath) > 8 and fpath[-8:] == ".csv.bz2")
-        or (len(fpath) > 8 and fpath[-8:] == ".csv.zip")
+        or (len(file_path) > 7 and file_path[-7:] == ".csv.gz")
+        or (len(file_path) > 8 and file_path[-8:] == ".csv.bz2")
+        or (len(file_path) > 8 and file_path[-8:] == ".csv.zip")
     ):
-        add_from_csv(farm, fpath, *args, verbosity=verbosity, **kwargs)
+        add_from_csv(farm, file_path, *args, verbosity=verbosity, **kwargs)
     else:
         raise KeyError(
-            f"Unsupported file suffix: '{fpath}'. Please provide any of: json, csv, csv.gz, csv.bz2, csv.zip"
+            f"Unsupported file suffix: '{file_path}'. Please provide any of: json, csv, csv.gz, csv.bz2, csv.zip"
         )

foxes/input/farm_layout/from_json.py

@@ -3,6 +3,7 @@ import numpy as np
 from copy import deepcopy
 
 from foxes.core import Turbine
+from foxes.config import get_path
 
 
 def add_from_json(
@@ -27,10 +28,10 @@ def add_from_json(
     :group: input.farm_layout
 
     """
-
+    fpath = get_path(file_path)
     if verbosity:
-        print("Reading file", file_path)
-    with open(file_path) as f:
+        print("Reading file", fpath)
+    with open(fpath) as f:
         dict = json.load(f)
 
     keys = list(dict.keys())

foxes/input/farm_layout/grid.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from foxes.core import Turbine
-import foxes.constants as FC
+from foxes.config import config
 
 
 def add_grid(
@@ -44,8 +44,8 @@ def add_grid(
     inds = list(np.ndindex(*steps))
     n_turbines = len(inds)
 
-    xy_base = np.array(xy_base, dtype=FC.DTYPE)
-    step_vectors = np.array(step_vectors, dtype=FC.DTYPE)
+    xy_base = np.array(xy_base, dtype=config.dtype_double)
+    step_vectors = np.array(step_vectors, dtype=config.dtype_double)
 
     for i in range(n_turbines):
         xi, yi = inds[i]

foxes/input/states/__init__.py

@@ -3,7 +3,7 @@ Atmospheric input states.
 """
 
 from .single import SingleStateStates
-from .scan_ws import ScanWS
+from .scan import ScanStates
 from .states_table import StatesTable, Timeseries, TabStates
 from .field_data_nc import FieldDataNC
 from .slice_data_nc import SliceDataNC

foxes/input/states/create/random_abl_states.py

@@ -1,6 +1,7 @@
 import pandas as pd
 import numpy as np
 
+from foxes.config import config, get_path
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -41,7 +42,7 @@ def create_random_abl_states(
 
     for v, mm in cols_minmax.items():
         data[v] = np.random.uniform(low=mm[0], high=mm[1], size=(n_states,)).astype(
-            FC.DTYPE
+            config.dtype_double
         )
 
     cmol = var2col.get(FV.MOL, FV.MOL)
@@ -98,8 +99,9 @@ def write_random_abl_states(
 
     """
 
+    fpath = get_path(file_path)
     if verbosity:
-        print("Writing file", file_path)
+        print("Writing file", fpath)
 
     data = create_random_abl_states(
         n_states, cols_minmax, var2col, mol_abs_range, normalize
@@ -130,4 +132,4 @@ def write_random_abl_states(
             if d is not None:
                 data[v] = data[v].round(d)
 
-    data.to_csv(file_path, **kwargs)
+    data.to_csv(fpath, **kwargs)

foxes/input/states/field_data_nc.py

@@ -2,13 +2,13 @@ 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
 import foxes.variables as FV
 import foxes.constants as FC
+from foxes.config import config, get_path
 
 
 class FieldDataNC(States):
@@ -150,9 +150,11 @@ class FieldDataNC(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(
@@ -164,13 +166,14 @@ class FieldDataNC(States):
                     )
 
             def _read_ds():
-                if Path(self.data_source).is_file():
-                    return xr.open_dataset(self.data_source)
+                fpath = get_path(self.data_source)
+                if fpath.is_file():
+                    return xr.open_dataset(fpath)
                 else:
                     # try to read multiple files, needs dask:
                     try:
                         return xr.open_mfdataset(
-                            str(self.data_source),
+                            str(fpath),
                             parallel=False,
                             concat_dim=self.states_coord,
                             combine="nested",
@@ -182,8 +185,7 @@ class FieldDataNC(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)
@@ -258,30 +260,45 @@ class FieldDataNC(States):
 
         cor_shxy = (self.states_coord, self.h_coord, self.x_coord, self.y_coord)
         cor_shyx = (self.states_coord, self.h_coord, self.y_coord, self.x_coord)
+        cor_sxy = (self.states_coord, self.x_coord, self.y_coord)
+        cor_syx = (self.states_coord, self.y_coord, self.x_coord)
         cor_sh = (self.states_coord, self.h_coord)
         cor_s = (self.states_coord,)
         vars_shyx = []
+        vars_syx = []
         vars_sh = []
         vars_s = []
         for v, ncv in self.var2ncvar.items():
             if ds[ncv].dims == cor_shyx or ds[ncv].dims == cor_shxy:
                 vars_shyx.append(v)
+            elif ds[ncv].dims == cor_syx or ds[ncv].dims == cor_sxy:
+                vars_syx.append(v)
             elif ds[ncv].dims == cor_sh:
                 vars_sh.append(v)
             elif ds[ncv].dims == cor_s:
                 vars_s.append(v)
             else:
                 raise ValueError(
-                    f"States '{self.name}': Wrong coordinate order for variable '{ncv}': Found {ds[ncv].dims}, expecting {cor_shxy}, {cor_shyx}, {cor_sh} or {cor_s}"
+                    f"States '{self.name}': Wrong coordinate order for variable '{ncv}': Found {ds[ncv].dims}, expecting {cor_shxy}, {cor_shyx}, {cor_sxy}, {cor_syx}, {cor_sh} or {cor_s}"
                 )
 
-        data = np.zeros((n_sts, n_h, n_y, n_x, len(self.var2ncvar)), dtype=FC.DTYPE)
+        data = np.zeros(
+            (n_sts, n_h, n_y, n_x, len(self.var2ncvar)), dtype=config.dtype_double
+        )
         for v in vars_shyx:
             ncv = self.var2ncvar[v]
             if ds[ncv].dims == cor_shyx:
                 data[..., self._dkys[v]] = ds[ncv][:]
             else:
                 data[..., self._dkys[v]] = np.swapaxes(ds[ncv].to_numpy(), 2, 3)
+        for v in vars_syx:
+            ncv = self.var2ncvar[v]
+            if ds[ncv].dims == cor_syx:
+                data[..., self._dkys[v]] = ds[ncv].to_numpy()[:, None]
+            else:
+                data[..., self._dkys[v]] = np.swapaxes(ds[ncv].to_numpy(), 1, 2)[
+                    :, None
+                ]
         for v in vars_sh:
             ncv = self.var2ncvar[v]
             data[..., self._dkys[v]] = ds[ncv].to_numpy()[:, :, None, None]
@@ -290,7 +307,9 @@ class FieldDataNC(States):
             data[..., self._dkys[v]] = ds[ncv].to_numpy()[:, None, None, None]
         if FV.WD in self.fixed_vars:
             data[..., self._dkys[FV.WD]] = np.full(
-                (n_sts, n_h, n_y, n_x), self.fixed_vars[FV.WD], dtype=FC.DTYPE
+                (n_sts, n_h, n_y, n_x),
+                self.fixed_vars[FV.WD],
+                dtype=config.dtype_double,
             )
 
         if verbosity > 1:
@@ -365,7 +384,7 @@ class FieldDataNC(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)
@@ -608,7 +627,9 @@ class FieldDataNC(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, 4)
         pts = np.flip(pts, axis=1)
@@ -697,7 +718,7 @@ class FieldDataNC(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()}