foxes 1.2.5__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/input/states/one_point_flow.py

@@ -101,9 +101,13 @@ class OnePointFlowStates(States):
         """
         return [self.base_states]
 
-    def initialize(self, algo, verbosity=0):
+    def load_data(self, algo, verbosity=0):
         """
-        Initializes the model.
+        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
         ----------
@@ -112,8 +116,14 @@ class OnePointFlowStates(States):
         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`
+
         """
-        super().initialize(algo, verbosity)
 
         # find heights:
         if self.heights is None:
@@ -127,10 +137,14 @@ class OnePointFlowStates(States):
                 )
 
         # pre-calc data:
-        Timelines._precalc_data(
+        self.WEIGHT = self.var(FV.WEIGHT)
+        idata = super().load_data(algo, verbosity)
+        idata["data_vars"][self.WEIGHT] = Timelines._precalc_data(
             self, algo, self.base_states, self.heights, verbosity, needs_res=True
         )
 
+        return idata
+
     def size(self):
         """
         The total number of states.
@@ -172,23 +186,6 @@ class OnePointFlowStates(States):
         """
         return self.base_states.output_point_vars(algo)
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return self.base_states.weights(algo)
-
     def set_running(
         self,
         algo,
@@ -263,7 +260,6 @@ class OnePointFlowStates(States):
             self.timelines_data = data.pop("data")
 
     def calc_states_indices(self, algo, mdata, points, hi, ref_xy):
-
         n_states, n_points = points.shape[:2]
         dxy = self.timelines_data["dxy"].to_numpy()[hi]
 
@@ -304,7 +300,6 @@ class OnePointFlowStates(States):
         sel = np.isnan(coeffs)
         tshift = 0
         while np.any(sel):
-
             trs = trace_si[sel]
             hdxy = -dxy[trs]
             trace_p[sel] += hdxy
@@ -329,7 +324,6 @@ class OnePointFlowStates(States):
             sel &= trace_si < algo.n_states
             tshift = 1
             while np.any(sel):
-
                 trs = trace_si[sel]
                 hdxy = dxy[trs]
                 trace_p[sel] += hdxy
@@ -423,7 +417,6 @@ class OnePointFlowStates(States):
 
         # interpolate to heights:
         if n_heights > 1:
-
             ar_states = np.arange(n_states)
             ar_points = np.arange(n_points)
 
@@ -488,6 +481,10 @@ class OnePointFlowStates(States):
                     results = {FV.WD: uv2wd(uv), FV.WS: np.linalg.norm(uv, axis=-1)}
                     del uv
 
+        # set weights:
+        tdata[FV.WEIGHT] = mdata[self.WEIGHT][:, None, None]
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {
             v: d.reshape(n_states, n_targets, n_tpoints) for v, d in results.items()
         }

foxes/input/states/scan.py

@@ -176,25 +176,6 @@ class ScanStates(States):
         """
         return self._vars
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return np.full(
-            (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
-        )
-
     def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -226,4 +207,10 @@ class ScanStates(States):
                 tdata[v] = np.zeros_like(tdata[FC.TARGETS][..., 0])
             tdata[v][:] = mdata[self.DATA][:, None, None, i]
 
+        # add weights:
+        tdata[FV.WEIGHT] = np.full(
+            (mdata.n_states, 1, 1), 1 / self._N, dtype=config.dtype_double
+        )
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/single.py

@@ -75,7 +75,7 @@ class SingleStateStates(States):
             and not len(profiles)
         ):
             raise KeyError(
-                f"Expecting at least one parameter: ws, wd, ti, rho, profiles"
+                "Expecting at least one parameter: ws, wd, ti, rho, profiles"
             )
 
     def sub_models(self):
@@ -157,23 +157,6 @@ class SingleStateStates(States):
 
         return list(out)
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return np.ones((1, algo.n_turbines), dtype=config.dtype_double)
-
     def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -233,4 +216,9 @@ class SingleStateStates(States):
                 pres = p.calculate(tdata, z)
                 tdata[v] = pres
 
+        tdata[FV.WEIGHT] = np.full(
+            (mdata.n_states, 1, 1), 1.0, dtype=config.dtype_double
+        )
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/states_table.py

@@ -51,7 +51,7 @@ class StatesTable(States):
         var2col={},
         fixed_vars={},
         profiles={},
-        pd_read_pars={},
+        read_pars={},
         states_sel=None,
         states_loc=None,
     ):
@@ -72,7 +72,7 @@ class StatesTable(States):
         profiles: dict
             Key: output variable name str, Value: str or dict
             or `foxes.core.VerticalProfile`
-        pd_read_pars: dict
+        read_pars: dict
             pandas file reading parameters
         states_sel: slice or range or list of int, optional
             States subset selection
@@ -82,8 +82,8 @@ class StatesTable(States):
         """
         super().__init__()
 
-        self.ovars = output_vars
-        self.rpars = pd_read_pars
+        self.ovars = list(output_vars)
+        self.rpars = read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
         self.profdicts = profiles
@@ -98,9 +98,7 @@ class StatesTable(States):
         self._N = None
         self._tvars = None
         self._profiles = None
-
         self._data_source = data_source
-        self.__weights = None
 
     @property
     def data_source(self):
@@ -155,7 +153,6 @@ class StatesTable(States):
 
         """
         self._profiles = {}
-        self._tvars = set(self.ovars)
         for v, d in self.profdicts.items():
             if isinstance(d, str):
                 self._profiles[v] = VerticalProfile.new(d)
@@ -168,9 +165,7 @@ class StatesTable(States):
                 raise TypeError(
                     f"States '{self.name}': Wrong profile type '{type(d).__name__}' for variable '{v}'. Expecting VerticalProfile, str or dict"
                 )
-            self._tvars.update(self._profiles[v].input_vars())
-        self._tvars -= set(self.fixed_vars.keys())
-        self._tvars = list(self._tvars)
+
         super().initialize(algo, verbosity)
 
     def sub_models(self):
@@ -210,10 +205,10 @@ class StatesTable(States):
         """
         self.VARS = self.var("vars")
         self.DATA = self.var("data")
+        self.WEIGHT = self.var(FV.WEIGHT)
 
         if isinstance(self.data_source, pd.DataFrame):
             data = self.data_source
-            isorg = True
         else:
             self._data_source = get_input_path(self.data_source)
             if not self.data_source.is_file():
@@ -230,7 +225,6 @@ class StatesTable(States):
                 print(f"States '{self.name}': Reading file {self.data_source}")
             rpars = dict(self.RDICT, **self.rpars)
             data = PandasFileHelper().read_file(self.data_source, **rpars)
-            isorg = False
 
         if self.states_sel is not None:
             data = data.iloc[self.states_sel]
@@ -240,18 +234,19 @@ 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=config.dtype_double)
+        weights = None
         if col_w in data:
-            self.__weights[:] = data[col_w].to_numpy()[:, None]
+            weights = data[col_w].to_numpy()
         elif FV.WEIGHT in self.var2col:
             raise KeyError(
                 f"Weight variable '{col_w}' defined in var2col, but not found in states table columns {data.columns}"
             )
-        else:
-            self.__weights[:] = 1.0 / self._N
-            if isorg:
-                data = data.copy()
-            data[col_w] = self.__weights[:, 0]
+
+        self._tvars = set(self.ovars)
+        for v in self.profdicts.keys():
+            self._tvars.update(self._profiles[v].input_vars())
+        self._tvars -= set(self.fixed_vars.keys())
+        self._tvars = list(self._tvars)
 
         tcols = []
         for v in self._tvars:
@@ -267,6 +262,8 @@ class StatesTable(States):
         idata = super().load_data(algo, verbosity)
         idata["coords"][self.VARS] = self._tvars
         idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data.to_numpy())
+        if weights is not None:
+            idata["data_vars"][self.WEIGHT] = (FC.STATE, weights)
 
         return idata
 
@@ -313,27 +310,6 @@ class StatesTable(States):
         """
         return self.ovars
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        if self.running:
-            raise ValueError(
-                f"States '{self.name}': Cannot access weights while running"
-            )
-        return self.__weights
-
     def set_running(
         self,
         algo,
@@ -368,10 +344,9 @@ class StatesTable(States):
 
         data_stash[self.name] = dict(
             data_source=self._data_source,
-            weights=self.__weights,
             inds=self.__inds,
         )
-        del self._data_source, self.__weights, self.__inds
+        del self._data_source, self.__inds
 
     def unset_running(
         self,
@@ -404,7 +379,6 @@ class StatesTable(States):
 
         data = data_stash[self.name]
         self._data_source = data.pop("data_source")
-        self.__weights = data.pop("weights")
         self.__inds = data.pop("inds")
 
     def calculate(self, algo, mdata, fdata, tdata):
@@ -455,6 +429,14 @@ class StatesTable(States):
         for v, p in self._profiles.items():
             tdata[v] = p.calculate(tdata, z)
 
+        if self.WEIGHT in mdata:
+            tdata[FV.WEIGHT] = mdata[self.WEIGHT][:, None, None]
+        else:
+            tdata[FV.WEIGHT] = np.full(
+                (mdata.n_states, 1, 1), 1 / self._N, dtype=config.dtype_double
+            )
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {v: tdata[v] for v in self.output_point_vars(algo)}
 
     def finalize(self, algo, verbosity=0):
@@ -469,7 +451,6 @@ class StatesTable(States):
             The verbosity level
 
         """
-        self.__weights = None
         self._N = None
         self._tvars = None
 

foxes/input/states/weibull_sectors.py

@@ -0,0 +1,225 @@
+import numpy as np
+import pandas as pd
+from os import PathLike
+from xarray import Dataset, open_dataset
+
+from foxes.data import STATES
+from foxes.utils import PandasFileHelper, weibull_weights
+from foxes.config import config, get_input_path
+import foxes.variables as FV
+import foxes.constants as FC
+
+from .states_table import StatesTable
+
+
+class WeibullSectors(StatesTable):
+    """
+    States with wind speed from Weibull parameters
+    from a NetCDF file
+
+    Attributes
+    ----------
+    ws_bins: numpy.ndarray
+        The wind speed bins, including
+        lower and upper bounds, shape: (n_ws_bins+1,)
+    var2ncvar: dict
+        Mapping from variable names to variable names
+        in the nc file
+    sel: dict
+        Subset selection via xr.Dataset.sel()
+    isel: dict
+        Subset selection via xr.Dataset.isel()
+    RDICT: dict
+        Default xarray file reading parameters
+
+    :group: input.states
+
+    """
+
+    RDICT = {}
+
+    def __init__(
+        self,
+        data_source,
+        output_vars,
+        ws_bins=None,
+        var2ncvar={},
+        sel=None,
+        isel=None,
+        **kwargs,
+    ):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        data_source: str or xarray.Dataset or pandas.DataFrame
+            Either path to NetCDF or csv file or data
+        output_vars: list of str
+            The output variables
+        ws_bins: list of float, optional
+            The wind speed bins, including
+            lower and upper bounds
+        var2ncvar: dict
+            Mapping from variable names to variable names
+            in the nc file
+        sel: dict, optional
+            Subset selection via xr.Dataset.sel()
+        isel: dict, optional
+            Subset selection via xr.Dataset.isel()
+        kwargs: dict, optional
+            Additional arguments for the base class
+
+        """
+        super().__init__(data_source, output_vars, var2col={}, **kwargs)
+        self.ws_bins = None if ws_bins is None else np.asarray(ws_bins)
+        self.var2ncvar = var2ncvar
+        self.sel = sel if sel is not None else {}
+        self.isel = isel if isel is not None else {}
+
+        if FV.WS not in self.ovars:
+            raise ValueError(
+                f"States '{self.name}': Expecting output variable '{FV.WS}', got {self.ovars}"
+            )
+        for v in [FV.WEIBULL_A, FV.WEIBULL_k, FV.WEIGHT]:
+            if v in self.ovars:
+                raise ValueError(
+                    f"States '{self.name}': Cannot have '{v}' as output variable"
+                )
+
+        self._original_data_source = None
+
+    def __repr__(self):
+        return f"{type(self).__name__}(ws_bins={self._n_ws})"
+
+    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 self._original_data_source is not None:
+            self._data_source = self._original_data_source
+            self._original_data_source = None
+
+        if isinstance(self.data_source, (str, PathLike)):
+            fpath = get_input_path(self.data_source)
+            if not fpath.is_file():
+                if verbosity > 0:
+                    print(
+                        f"States '{self.name}': Reading static data '{fpath}' from context '{STATES}'"
+                    )
+                fpath = algo.dbook.get_file_path(STATES, fpath.name, check_raw=False)
+                if verbosity > 0:
+                    print(f"Path: {fpath}")
+            elif verbosity:
+                print(f"States '{self.name}': Reading file {fpath}")
+            rpars = dict(self.RDICT, **self.rpars)
+            if fpath.suffix == ".nc":
+                data = open_dataset(fpath, engine=config.nc_engine, **rpars)
+            else:
+                data = PandasFileHelper().read_file(fpath, **rpars).to_xarray()
+            self._original_data_source = data
+
+        elif isinstance(self.data_source, Dataset):
+            data = self.data_source
+
+        elif isinstance(self.data_source, pd.DataFrame):
+            data = self.data_source.to_xarray()
+
+        if self.isel is not None and len(self.isel):
+            data = data.isel(**self.isel)
+        if self.sel is not None and len(self.sel):
+            data = data.sel(**self.sel)
+
+        wsn = self.var2ncvar.get(FV.WS, FV.WS)
+        if self.ws_bins is not None:
+            wsb = self.ws_bins
+        elif wsn in data:
+            wsb = data[wsn].to_numpy()
+        else:
+            raise ValueError(
+                f"States '{self.name}': Expecting ws_bins argument, since '{wsn}' not found in data"
+            )
+        wss = 0.5 * (wsb[:-1] + wsb[1:])
+        wsd = wsb[1:] - wsb[:-1]
+        n_ws = len(wss)
+        self._n_ws = n_ws
+        del wsb
+
+        secn = None
+        n_secs = None
+        if self._original_data_source is None:
+            self._original_data_source = self.data_source
+        self._data_source = {}
+        for v in [FV.WEIBULL_A, FV.WEIBULL_k, FV.WEIGHT] + self.ovars:
+            if v != FV.WS and v not in self.fixed_vars:
+                c = self.var2ncvar.get(v, v)
+                if c not in data:
+                    raise KeyError(
+                        f"States '{self.name}': Missing variable '{c}' in data, found {list(data.data_vars.keys())}"
+                    )
+                d = data[c]
+                if len(d.dims) == 0:
+                    self.fixed_vars[v] = float(d.to_numpy())
+                    continue
+                elif len(d.dims) != 1:
+                    raise ValueError(
+                        f"States '{self.name}': Expecting single dimension for variable '{c}', got {d.dims}"
+                    )
+                elif secn is None:
+                    secn = d.dims[0]
+                    n_secs = data.sizes[secn]
+                elif d.dims[0] != secn:
+                    raise ValueError(
+                        f"States '{self.name}': Expecting dimension '{secn}' for variable '{c}', got {d.dims}"
+                    )
+                self._data_source[v] = np.zeros(
+                    (n_secs, n_ws), dtype=config.dtype_double
+                )
+                self._data_source[v][:] = d.to_numpy()[:, None]
+        self._data_source[FV.WS] = np.zeros((n_secs, n_ws), dtype=config.dtype_double)
+        self._data_source[FV.WS][:] = wss[None, :]
+        del wss
+
+        self._data_source[FV.WEIGHT] *= weibull_weights(
+            ws=self._data_source[FV.WS],
+            ws_deltas=wsd[None, :],
+            A=self._data_source.pop(FV.WEIBULL_A),
+            k=self._data_source.pop(FV.WEIBULL_k),
+        )
+
+        # remove wd 360 from the end, if wd 0 is given:
+        if FV.WD in self._data_source:
+            if np.all(self._data_source[FV.WD][0] == 0.0) and np.all(
+                self._data_source[FV.WD][-1] == 360.0
+            ):
+                for v in self._data_source.keys():
+                    self._data_source[v] = self._data_source[v][:-1]
+                n_secs -= 1
+
+        N = n_secs * n_ws
+        for v in self._data_source.keys():
+            self._data_source[v] = self._data_source[v].reshape(N)
+        self._data_source = pd.DataFrame(data=self._data_source, index=np.arange(N))
+        self._data_source.index.name = FC.STATE
+
+        return super().load_data(algo, verbosity)