foxes 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

foxes/core/partial_wakes_model.py

@@ -23,6 +23,25 @@ class PartialWakesModel(Model):
 
     """
 
+    def check_wmodel(self, wmodel, error=True):
+        """
+        Checks the wake model type
+
+        Parameters
+        ----------
+        wmodel: foxes.core.WakeModel
+            The wake model to be tested
+        error: bool
+            Flag for raising TypeError
+
+        Returns
+        -------
+        chk: bool
+            True if wake model is compatible
+
+        """
+        return True
+
     @abstractmethod
     def get_wake_points(self, algo, mdata, fdata):
         """
@@ -66,9 +85,6 @@ class PartialWakesModel(Model):
             The target point data
         wmodel: foxes.core.WakeModel
             The wake model
-        wpoints: numpy.ndarray
-            The wake evaluation points,
-            shape: (n_states, n_turbines, n_tpoints, 3)
 
         Returns
         -------

foxes/core/states.py

@@ -1,6 +1,7 @@
 from abc import abstractmethod
 
 from .point_data_model import PointDataModel, PointDataModelList
+from foxes.utils import all_subclasses
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -131,6 +132,38 @@ class States(PointDataModel):
         else:
             return ExtendedStates(self, [s])
 
+    @classmethod
+    def new(cls, states_type, *args, **kwargs):
+        """
+        Run-time states factory.
+
+        Parameters
+        ----------
+        states_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+
+        if states_type is None:
+            return None
+
+        allc = all_subclasses(cls)
+        found = states_type in [scls.__name__ for scls in allc]
+
+        if found:
+            for scls in allc:
+                if scls.__name__ == states_type:
+                    return scls(*args, **kwargs)
+        else:
+            estr = "States type '{}' is not defined, available types are \n {}".format(
+                states_type, sorted([i.__name__ for i in allc])
+            )
+            raise KeyError(estr)
+
 
 class ExtendedStates(States):
     """

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 all_subclasses, Factory
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -49,7 +49,7 @@ class WakeModel(Model):
         -------
         wake_deltas: dict
             Key: variable name, value: The zero filled
-            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
+            wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
 
         """
         return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
@@ -183,3 +183,139 @@ class TurbineInductionModel(WakeModel):
 
         """
         return False
+
+
+class WakeK(Model):
+    """
+    Handler for the wake growth parameter k
+
+    Attributes
+    ----------
+    k_var: str
+        The name of the k variable
+    ti_var: str
+        The name of the TI variable
+
+    :group: core
+
+    """
+
+    def __init__(
+        self,
+        k=None,
+        ka=None,
+        kb=None,
+        k_var=FV.K,
+        ti_var=FV.TI,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        k: float, optional
+            The k value
+        ka: float, optional
+            The ka value in k = ka * TI + kb
+        kb: float, optional
+            The kb value in k = ka * TI + kb
+        k_var: str
+            The name of the k variable
+        ti_var: str
+            The name of the TI variable
+
+        """
+        super().__init__()
+        self._k = k
+        self._ka = ka
+        self._kb = kb
+        self.k_var = k_var
+        self.ti_var = ti_var
+
+        if k is not None and (ka is not None or kb is not None):
+            raise ValueError("Got 'k' and also ('ka' or 'kb') as non-None parameters")
+        elif k is None and kb is not None and (ka is None or ka == 0):
+            raise ValueError(f"Got k={k}, ka={ka}, kb={kb}, use k={kb} instead")
+
+        setattr(self, self.k_var, None)
+
+    def repr(self):
+        """
+        Provides the representative string
+
+        Returns
+        -------
+        s: str
+            The representative string
+
+        """
+        if self._k is not None:
+            s = f"{self.k_var}={self._k}"
+        elif self._ka is not None or self._kb is not None:
+            s = f"{self.k_var}={self._ka}*{self.ti_var}"
+            if self._kb is not None and self._kb > 0:
+                s += f"+{self._kb}"
+        else:
+            s = f"k_var={self.k_var}"
+        return s
+
+    @property
+    def all_none(self):
+        """Flag for k=ka=kb=None"""
+        return self._k is None and self._ka is None and self._kb is None
+
+    @property
+    def use_amb_ti(self):
+        """Flag for using ambient ti"""
+        return self.ti_var in FV.amb2var
+
+    def __call__(
+        self,
+        *args,
+        lookup_ti="w",
+        lookup_k="sw",
+        ti=None,
+        amb_ti=None,
+        **kwargs,
+    ):
+        """
+        Gets the k value
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Arguments for get_data
+        lookup_ti: str
+            The ti lookup order for get_data
+        lookup_k: str
+            The k lookup order for get_data
+        ti: numpy.ndarray, optional
+            ti data in the requested target shape,
+            if known
+        amb_ti: numpy.ndarray, optional
+            Ambient ti data in the requested target shape,
+            if known
+        kwargs: dict, optional
+            Arguments for get_data
+
+        Returns
+        -------
+        k: numpy.ndarray
+            The k array as returned by get_data
+
+        """
+        if self._k is not None:
+            setattr(self, self.k_var, self._k)
+        elif self._ka is not None or self._kb is not None:
+            if self.ti_var == FV.TI and ti is not None:
+                pass
+            elif self.ti_var == FV.AMB_TI and amb_ti is not None:
+                ti = amb_ti
+            else:
+                ti = self.get_data(self.ti_var, *args, lookup=lookup_ti, **kwargs)
+            kb = 0 if self._kb is None else self._kb
+            setattr(self, self.k_var, self._ka * ti + kb)
+
+        k = self.get_data(self.k_var, *args, lookup=lookup_k, **kwargs)
+        setattr(self, self.k_var, None)
+        return k

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, StaticData
+from .static_data import FARM, STATES, PCTCURVE, WINDIO, StaticData

foxes/data/static_data.py

@@ -3,6 +3,7 @@ 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
@@ -19,6 +20,11 @@ PCTCURVE = "power_ct_curve"
 :group: data
 """
 
+WINDIO = "windio"
+""" Static windio data identifier
+:group: data
+"""
+
 
 class StaticData(DataBook):
     """
@@ -35,3 +41,4 @@ 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/data/windio/DTU_10MW_turbine.yaml

@@ -0,0 +1,10 @@
+name: DTU 10MW Offshore Reference Turbine
+performance:
+  power_curve:
+    power_values: [263388., 751154., 1440738., 2355734., 3506858., 4993092., 6849310., 9116402., 10000754., 10009590., 10000942., 10042678., 10003480., 10001600., 10001506., 10013632., 10007428., 10005360., 10002728., 10001130., 10004984., 9997558.]
+    power_wind_speeds: [4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.]
+  Ct_curve:
+    Ct_values: [0.923,0.919,0.904,0.858,0.814,0.814,0.814,0.814,0.577,0.419,0.323,0.259,0.211,0.175,0.148,0.126,0.109,0.095,0.084,0.074,0.066,0.059]
+    Ct_wind_speeds: [4.,5.,6.,7.,8.,9.,10.,11.,12.,13.,14.,15.,16.,17.,18.,19.,20.,21.,22.,23.,24.,25.]
+hub_height: 119.0
+rotor_diameter: 178.3

foxes/data/windio/windio_5turbines_timeseries.yaml

@@ -0,0 +1,63 @@
+name: 5 turbines and a wind timeseries
+
+site:
+  name: Site with wind timeseries data
+  boundaries:
+      polygons: [
+          x: [-10, -10, 1610, 1610],
+          y: [-10, 10, 10, -10]
+      ]
+  energy_resource:
+    name: NetCDF timeseries with 5000 states
+    wind_resource: !include ../states/windio_timeseries_5000.nc
+
+wind_farm: 
+  name: One row with 5 turbines
+  layouts:
+      initial_layout:
+          coordinates:
+              x: [0, 0, 0, 0, 0]
+              y: [0, 600, 1150, 1730, 2400]
+  turbines: !include DTU_10MW_turbine.yaml
+
+attributes:
+  flow_model:
+    name: foxes
+
+  analysis:
+
+    wind_deficit_model:
+      name: Bastankhah2014
+      wake_expansion_coefficient: # k = ka*ti + kb
+        k_a: 0.04 
+        k_b: 0.0
+        free_stream_ti: false
+      ceps: 0.2
+      use_effective_ws: true
+
+    axial_induction_model: Madsen
+
+    deflection_model:
+      name: None
+    
+    turbulence_model:
+      name: CrespoHernandez
+    
+    superposition_model:
+      ws_superposition: Linear
+      ti_superposition: Quadratic
+
+    rotor_averaging:
+      grid: grid
+      n_x_grid_points: 4
+      n_y_grid_points: 4
+      background_averaging: grid
+      wake_averaging: axiwake9
+      wind_speed_exponent_for_power: 3
+      wind_speed_exponent_for_ct: 2
+
+    blockage_model:
+      name: None
+
+
+

foxes/input/states/__init__.py

@@ -7,5 +7,6 @@ from .scan_ws import ScanWS
 from .states_table import StatesTable, Timeseries, TabStates
 from .field_data_nc import FieldDataNC
 from .multi_height import MultiHeightStates, MultiHeightTimeseries
+from .multi_height import MultiHeightNCStates, MultiHeightNCTimeseries
 
 from . import create

foxes/input/states/multi_height.py

@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+from xarray import Dataset, open_dataset
 from pathlib import Path
 from scipy.interpolate import interp1d
 
@@ -100,7 +101,6 @@ class MultiHeightStates(States):
         self.states_sel = states_sel
         self.states_loc = states_loc
 
-        self._cmap = None
         self._solo = None
         self._weights = None
         self._N = None
@@ -217,14 +217,14 @@ class MultiHeightStates(States):
             data[col_w] = self._weights[:, 0]
 
         cols = []
-        self._cmap = {}
+        cmap = {}
         self._solo = {}
         for v in self.ovars:
             vcols = self._find_cols(v, data.columns)
             if len(vcols) == 1:
                 self._solo[v] = data[vcols[0]].to_numpy()
             elif len(vcols) > 1:
-                self._cmap[v] = (len(cols), len(cols) + len(vcols))
+                cmap[v] = (len(cols), len(cols) + len(vcols))
                 cols += vcols
         data = data[cols]
 
@@ -235,7 +235,7 @@ class MultiHeightStates(States):
         idata = super().load_data(algo, verbosity)
 
         idata["coords"][self.H] = self.heights
-        idata["coords"][self.VARS] = list(self._cmap.keys())
+        idata["coords"][self.VARS] = list(cmap.keys())
 
         n_hts = len(self.heights)
         n_vrs = int(len(data.columns) / n_hts)
@@ -247,6 +247,7 @@ class MultiHeightStates(States):
 
         for v, d in self._solo.items():
             idata["data_vars"][self.var(v)] = ((FC.STATE,), d)
+        self._solo = list(self._solo.keys())
 
         return idata
 
@@ -387,7 +388,7 @@ class MultiHeightStates(States):
             elif v in self.fixed_vars:
                 results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
                 results[v][:] = self.fixed_vars[v]
-            elif v in self._solo.keys():
+            elif v in self._solo:
                 results[v] = np.zeros((n_states, n_targets, n_tpoints), dtype=FC.DTYPE)
                 results[v][:] = mdata[self.var(v)][:, None, None]
             else:
@@ -408,12 +409,200 @@ class MultiHeightStates(States):
 
         """
         super().finalize(algo, verbosity)
-        self._cmap = None
         self._solo = None
         self._weights = None
         self._N = None
 
 
+class MultiHeightNCStates(MultiHeightStates):
+    """
+    Multi-height states from xarray Dataset.
+
+    Attributes
+    ----------
+    data_source: str or xarray.Dataset
+        Either path to a file or data
+    state_coord: str
+        Name of the state coordinate
+    h_coord: str
+        Name of the height coordinate
+    xr_read_pars: dict
+        Parameters for xarray.open_dataset
+
+    :group: input.states
+
+    """
+
+    def __init__(
+        self,
+        data_source,
+        *args,
+        state_coord=FC.STATE,
+        h_coord=FV.H,
+        heights=None,
+        format_times_func="default",
+        xr_read_pars={},
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        data_source: str or pandas.DataFrame
+            Either path to a file or data
+        args: tuple, optional
+            Parameters for the base class
+        state_coord: str
+            Name of the state coordinate
+        h_coord: str
+            Name of the height coordinate
+        output_vars: list of str
+            The output variables
+        heights: list of float, optional
+            The heights at which to search data
+        format_times_func: Function or 'default', optional
+            The function that maps state_coord values
+            to datetime dtype format
+        xr_read_pars: dict, optional
+            Parameters for xarray.open_dataset
+        kwargs: dict, optional
+            Parameters for the base class
+
+        """
+        super().__init__(
+            data_source,
+            *args,
+            heights=[],
+            pd_read_pars=None,
+            **kwargs,
+        )
+        self.state_coord = state_coord
+        self.heights = heights
+        self.h_coord = h_coord
+        self.xr_read_pars = xr_read_pars
+
+        if format_times_func == "default":
+            self.format_times_func = lambda t: t.astype("datetime64[ns]")
+        else:
+            self.format_times_func = format_times_func
+
+    def load_data(self, algo, verbosity=0):
+        """
+        Load and/or create all model data that is subject to chunking.
+
+        Such data should not be stored under self, for memory reasons. The
+        data returned here will automatically be chunked and then provided
+        as part of the mdata object during calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        Returns
+        -------
+        idata: dict
+            The dict has exactly two entries: `data_vars`,
+            a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
+            and `coords`, a dict with entries `dim_name_str -> dim_array`
+
+        """
+        if not isinstance(self.data_source, Dataset):
+            if not Path(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
+                )
+                if verbosity:
+                    print(f"Path: {self.data_source}")
+            elif verbosity:
+                print(f"States '{self.name}': Reading file {self.data_source}")
+            data = open_dataset(self.data_source, **self.xr_read_pars)
+        else:
+            data = self.data_source
+
+        if self.states_sel is not None:
+            data = data.isel({self.state_coord: self.states_sel})
+        if self.states_loc is not None:
+            data = data.sel({self.state_coord: self.states_loc})
+
+        self._N = data.sizes[self.state_coord]
+        self._inds = data.coords[self.state_coord].to_numpy()
+        if self.format_times_func is not None:
+            self._inds = self.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)
+        if w_name in data.data_vars:
+            if data[w_name].dims != (self.state_coord,):
+                raise ValueError(
+                    f"Weights data '{w_name}': Expecting dims ({self.state_coord},), got {data[w_name]}"
+                )
+            self._weights[:] = data.data_vars[w_name].to_numpy()[:, None]
+        elif FV.WEIGHT in self.var2col:
+            raise KeyError(
+                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[:] = 1.0 / self._N
+
+        cols = {}
+        self._solo = {}
+        for v in self.ovars:
+            c = self.var2col.get(v, v)
+            if c in self.fixed_vars:
+                pass
+            elif c in data.attrs:
+                self._solo[v] = np.full(self._N, data.attrs)
+            elif c in data.data_vars:
+                if data[c].dims == (self.state_coord,):
+                    self._solo[v] = data.data_vars[c].to_numpy()
+                elif data[c].dims == (self.state_coord, self.h_coord):
+                    cols[v] = c
+                else:
+                    raise ValueError(
+                        f"Variable '{c}': Expecting dims {(self.state_coord, self.h_coord)}, got {data[c].dims}"
+                    )
+            else:
+                raise KeyError(
+                    f"Missing variable '{c}', found data_vars {sorted(list(data.data_vars.keys()))} and attrs {sorted(list(data.attrs.keys()))}"
+                )
+
+        if self.heights is not None:
+            data = data.sel({self.h_coord: self.heights})
+        else:
+            self.heights = data[self.h_coord].to_numpy()
+
+        self.H = self.var(FV.H)
+        self.VARS = self.var("vars")
+        self.DATA = self.var("data")
+
+        idata = States.load_data(self, algo, verbosity)
+        idata["coords"][self.H] = self.heights
+        idata["coords"][self.VARS] = list(cols.keys())
+
+        dims = (FC.STATE, self.VARS, self.H)
+        idata["data_vars"][self.DATA] = (
+            dims,
+            np.stack(
+                [data.data_vars[c].to_numpy() for c in cols.values()], axis=1
+            ).astype(FC.DTYPE),
+        )
+
+        for v, d in self._solo.items():
+            idata["data_vars"][self.var(v)] = ((FC.STATE,), d.astype(FC.DTYPE))
+        self._solo = list(self._solo.keys())
+
+        return idata
+
+
 class MultiHeightTimeseries(MultiHeightStates):
     """
     Multi-height timeseries states data.
@@ -423,3 +612,33 @@ class MultiHeightTimeseries(MultiHeightStates):
     """
 
     RDICT = {"index_col": 0, "parse_dates": [0]}
+
+
+class MultiHeightNCTimeseries(MultiHeightNCStates):
+    """
+    Multi-height timeseries from xarray Dataset.
+
+    :group: input.states
+
+    """
+
+    def __init__(
+        self,
+        *args,
+        time_coord=FC.TIME,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Parameters for the base class
+        time_coord: str
+            Name of the state coordinate
+        kwargs: dict, optional
+            Parameters for the base class
+
+        """
+        super().__init__(*args, state_coord=time_coord, **kwargs)

foxes/input/windio/__init__.py

@@ -2,4 +2,9 @@
 Functions for usingin windIO yaml files as input.
 """
 
-from .windio import read_case
+from .windio import read_windio
+from .read_fields import wio2foxes, foxes2wio
+from .get_states import get_states
+from .read_farm import read_turbine_type, read_layout
+from .read_attributes import read_attributes
+from .runner import WindioRunner