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

foxes/core/turbine_model.py

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

foxes/core/turbine_type.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 import foxes.constants as FC
 
 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,7 +2,7 @@ from abc import abstractmethod
 import numpy as np
 from scipy.interpolate import interpn
 
-from foxes.utils import all_subclasses
+from foxes.utils import new_instance
 from foxes.config import config
 import foxes.variables as FV
 import foxes.constants as FC
@@ -318,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
+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):
     """

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/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/field_data_nc.py

@@ -260,21 +260,26 @@ 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(
@@ -286,6 +291,14 @@ class FieldDataNC(States):
                 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]

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

@@ -6,46 +6,35 @@ 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):
         """
@@ -70,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
 
@@ -109,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,
@@ -146,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):
         """
@@ -158,7 +157,7 @@ class ScanWS(States):
             The total number of states
 
         """
-        return self.N
+        return self._N
 
     def output_point_vars(self, algo):
         """
@@ -175,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):
         """
@@ -200,7 +192,7 @@ class ScanWS(States):
 
         """
         return np.full(
-            (self.N, algo.n_turbines), 1.0 / self.N, dtype=config.dtype_double
+            (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
         )
 
     def calculate(self, algo, mdata, fdata, tdata):
@@ -229,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/yaml/__init__.py

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