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

foxes/input/states/__init__.py

@@ -2,17 +2,28 @@
 Atmospheric input states.
 """
 
-from .single import SingleStateStates
-from .scan import ScanStates
-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 .single import SingleStateStates as SingleStateStates
+from .scan import ScanStates as ScanStates
+from .field_data_nc import FieldDataNC as FieldDataNC
+from .wrg_states import WRGStates as WRGStates
+from .weibull_sectors import WeibullSectors as WeibullSectors
+
+from .states_table import StatesTable as StatesTable
+from .states_table import Timeseries as Timeseries
+from .states_table import TabStates as TabStates
+
+from .multi_height import MultiHeightStates as MultiHeightStates
+from .multi_height import MultiHeightTimeseries as MultiHeightTimeseries
+from .multi_height import MultiHeightNCStates as MultiHeightNCStates
+from .multi_height import MultiHeightNCTimeseries as MultiHeightNCTimeseries
+
+from .one_point_flow import OnePointFlowStates as OnePointFlowStates
+from .one_point_flow import OnePointFlowTimeseries as OnePointFlowTimeseries
+from .one_point_flow import (
+    OnePointFlowMultiHeightTimeseries as OnePointFlowMultiHeightTimeseries,
+)
 from .one_point_flow import (
-    OnePointFlowStates,
-    OnePointFlowTimeseries,
-    OnePointFlowMultiHeightTimeseries,
-    OnePointFlowMultiHeightNCTimeseries,
+    OnePointFlowMultiHeightNCTimeseries as OnePointFlowMultiHeightNCTimeseries,
 )
 
-from . import create
+from . import create as create

foxes/input/states/create/__init__.py

@@ -1,2 +1,3 @@
-from .random_abl_states import create_random_abl_states, write_random_abl_states
-from .random_timeseries import random_timseries_data
+from .random_abl_states import create_random_abl_states as create_random_abl_states
+from .random_abl_states import write_random_abl_states as write_random_abl_states
+from .random_timeseries import random_timseries_data as random_timseries_data

foxes/input/states/field_data_nc.py

@@ -16,7 +16,6 @@ def _read_nc_file(
     fpath,
     coords,
     vars,
-    weight_var,
     nc_engine,
     sel,
     isel,
@@ -30,18 +29,7 @@ def _read_nc_file(
                 f"Missing coordinate '{c}' in file {fpath}, got: {list(data.coords.keys())}"
             )
     if minimal:
-        weights = None
-        if weight_var is not None:
-            if weight_var not in data.data_vars:
-                raise KeyError(
-                    f"Missing weight var '{weight_var}' in file {fpath}, found: {list(data.data_vars.keys())}"
-                )
-            if data[weight_var].dims != (coords[0],):
-                raise ValueError(
-                    f"Wrong dimensions for variable '{weight_var}' in file {fpath}. Expecting {(coords[0],)}, got {data[weight_var].dims}"
-                )
-            weights = data[weight_var].to_numpy()
-        return data[coords[0]].to_numpy(), weights
+        return data[coords[0]].to_numpy()
     else:
         data = data[vars]
         data.attrs = {}
@@ -175,7 +163,7 @@ class FieldDataNC(States):
         super().__init__()
 
         self.states_coord = states_coord
-        self.ovars = output_vars
+        self.ovars = list(output_vars)
         self.fixed_vars = fixed_vars
         self.x_coord = x_coord
         self.y_coord = y_coord
@@ -196,7 +184,6 @@ class FieldDataNC(States):
         self._N = None
 
         self.__data_source = data_source
-        self.__weights = None
         self.__inds = None
 
     @property
@@ -298,16 +285,28 @@ class FieldDataNC(States):
                 dtype=config.dtype_double,
             )
 
+        weights = None
+        if self.weight_ncvar is not None:
+            if self.weight_ncvar not in ds.data_vars:
+                raise KeyError(
+                    f"States '{self.name}': Missing weights variable '{self.weight_ncvar}' in data, found {sorted(list(ds.data_vars.keys()))}"
+                )
+            if ds[self.weight_ncvar].dims != (self.states_coord,):
+                raise ValueError(
+                    f"States '{self.name}': Weights variable '{self.weight_ncvar}' has wrong dimensions. Expecting {(self.states_coord,)}, got {ds[self.weight_ncvar].dims}"
+                )
+            weights = ds[self.weight_ncvar].to_numpy()
+
         if verbosity > 1:
             print(f"\n{self.name}: Data ranges")
             for v, i in self._dkys.items():
                 d = data[..., i]
                 nn = np.sum(np.isnan(d))
                 print(
-                    f"  {v}: {np.nanmin(d)} --> {np.nanmax(d)}, nans: {nn} ({100*nn/len(d.flat):.2f}%)"
+                    f"  {v}: {np.nanmin(d)} --> {np.nanmax(d)}, nans: {nn} ({100 * nn / len(d.flat):.2f}%)"
                 )
 
-        return sts, h, y, x, data
+        return sts, h, y, x, data, weights
 
     def output_point_vars(self, algo):
         """
@@ -353,10 +352,11 @@ class FieldDataNC(States):
         # pre-load file reading:
         coords = [self.states_coord, self.h_coord, self.y_coord, self.x_coord]
         if not isinstance(self.data_source, xr.Dataset):
-
             # check variables:
             for v in self.ovars:
-                if v not in self.var2ncvar and v not in self.fixed_vars:
+                if v == FV.WEIGHT and self.weight_ncvar is None:
+                    pass
+                elif v not in self.var2ncvar and v not in self.fixed_vars:
                     raise ValueError(
                         f"States '{self.name}': Variable '{v}' neither found in var2ncvar not in fixed_vars"
                     )
@@ -413,7 +413,6 @@ class FieldDataNC(States):
                 _read_nc_file,
                 files,
                 coords=coords,
-                weight_var=self.weight_ncvar,
                 vars=vars,
                 nc_engine=config.nc_engine,
                 isel=self.isel,
@@ -422,7 +421,6 @@ class FieldDataNC(States):
             )
 
             if self.load_mode in ["preload", "lazy"]:
-
                 if self.load_mode == "lazy":
                     try:
                         self.__data_source = [ds.chunk() for ds in self.__data_source]
@@ -440,23 +438,15 @@ class FieldDataNC(States):
                 )
                 if self.load_mode == "preload":
                     self.__data_source.load()
-                if self.weight_ncvar is not None:
-                    self.__weights = self.__data_source[self.weight_ncvar].to_numpy()
                 self.__inds = self.__data_source[self.states_coord].to_numpy()
                 self._N = len(self.__inds)
 
             elif self.load_mode == "fly":
-                self.__inds, weights = zip(*self.__data_source)
+                self.__inds = self.__data_source
                 self.__data_source = fpath
                 self._files_maxi = {f: len(inds) for f, inds in zip(files, self.__inds)}
                 self.__inds = np.concatenate(self.__inds, axis=0)
                 self._N = len(self.__inds)
-                if weights[0] is not None:
-                    self.__weights = np.zeros(
-                        (self._N, algo.n_turbines), dtype=config.dtype_double
-                    )
-                    self.__weights[:] = np.concatenate(weights, axis=0)[:, None]
-                    del weights
 
             else:
                 raise KeyError(
@@ -468,10 +458,10 @@ class FieldDataNC(States):
                     self.__inds, format=self.time_format
                 ).to_numpy()
 
-            if self.__weights is None:
-                self.__weights = np.full(
-                    (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
-                )
+        # given data is already Dataset:
+        else:
+            self.__inds = self.data_source[self.states_coord].to_numpy()
+            self._N = len(self.__inds)
 
         # ensure WD and WS get the first two slots of data:
         self._dkys = {}
@@ -492,8 +482,11 @@ class FieldDataNC(States):
             self.H = self.var(FV.H)
             self.VARS = self.var("vars")
             self.DATA = self.var("data")
+            self.WEIGHT = self.var(FV.WEIGHT)
 
-            __, h, y, x, data = self._get_data(self.data_source, coords, verbosity)
+            __, h, y, x, data, weights = self._get_data(
+                self.data_source, coords, verbosity
+            )
             self._prl_coords = coords
 
             coos = (FC.STATE, self.H, self.Y, self.X, self.VARS)
@@ -504,6 +497,8 @@ class FieldDataNC(States):
             idata["coords"][self.X] = x
             idata["coords"][self.VARS] = list(self._dkys.keys())
             idata["data_vars"][self.DATA] = data
+            if weights is not None:
+                idata["data_vars"][self.WEIGHT] = ((FC.STATE,), weights)
 
         return idata
 
@@ -540,10 +535,9 @@ class FieldDataNC(States):
         super().set_running(algo, data_stash, sel, isel, verbosity)
 
         data_stash[self.name] = dict(
-            weights=self.__weights,
             inds=self.__inds,
         )
-        del self.__weights, self.__inds
+        del self.__inds
 
         if self.load_mode == "preload":
             data_stash[self.name]["data_source"] = self.__data_source
@@ -579,7 +573,6 @@ class FieldDataNC(States):
         super().unset_running(algo, data_stash, sel, isel, verbosity)
 
         data = data_stash[self.name]
-        self.__weights = data.pop("weights")
         self.__inds = data.pop("inds")
 
         if self.load_mode == "preload":
@@ -611,44 +604,6 @@ class FieldDataNC(States):
             raise ValueError(f"States '{self.name}': Cannot access index while running")
         return self.__inds
 
-    def output_point_vars(self, algo):
-        """
-        The variables which are being modified by the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        output_vars: list of str
-            The output variable names
-
-        """
-        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 calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -690,6 +645,7 @@ class FieldDataNC(States):
             y = mdata[self.Y]
             h = mdata[self.H]
             data = mdata[self.DATA].copy()
+            weights = mdata.get(self.WEIGHT, None)
             coords = self._prl_coords
 
         # case lazy:
@@ -697,7 +653,7 @@ class FieldDataNC(States):
             i0 = mdata.states_i0(counter=True)
             s = slice(i0, i0 + n_states)
             ds = self.data_source.isel({self.states_coord: s}).load()
-            __, h, y, x, data = self._get_data(ds, coords, verbosity=0)
+            __, h, y, x, data, weights = self._get_data(ds, coords, verbosity=0)
             del ds
 
         # case fly:
@@ -725,7 +681,6 @@ class FieldDataNC(States):
                             _read_nc_file(
                                 fpath,
                                 coords=coords,
-                                weight_var=self.weight_ncvar,
                                 vars=vars,
                                 nc_engine=config.nc_engine,
                                 isel=isel,
@@ -737,12 +692,12 @@ class FieldDataNC(States):
                         i0 += b - a
                     j0 = j1
 
-            assert (
-                i0 == i1
-            ), f"States '{self.name}': Missing states for load_mode '{self.load_mode}': (i0, i1) = {(i0, i1)}"
+            assert i0 == i1, (
+                f"States '{self.name}': Missing states for load_mode '{self.load_mode}': (i0, i1) = {(i0, i1)}"
+            )
 
             data = xr.concat(data, dim=self.states_coord)
-            __, h, y, x, data = self._get_data(data, coords, verbosity=0)
+            __, h, y, x, data, weights = self._get_data(data, coords, verbosity=0)
 
         else:
             raise KeyError(
@@ -858,12 +813,21 @@ class FieldDataNC(States):
             out[FV.WD] = uv2wd(uv, axis=-1)
             del uv
         for v in self.ovars:
-            if v not in out:
+            if v != FV.WEIGHT and v not in out:
                 if v in self._dkys:
                     out[v] = data[..., self._dkys[v]]
-                else:
+                elif v in self.fixed_vars:
                     out[v] = np.full(
                         (n_states, n_pts), self.fixed_vars[v], dtype=config.dtype_double
                     )
 
+        # add weights:
+        if weights is not None:
+            tdata[FV.WEIGHT] = weights[:, 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: d.reshape(n_states, n_targets, n_tpoints) for v, d in out.items()}

foxes/input/states/multi_height.py

@@ -36,7 +36,7 @@ class MultiHeightStates(States):
     fixed_vars: dict, optional
         Fixed uniform variable values, instead of
         reading from data
-    pd_read_pars: dict, optional
+    read_pars: dict, optional
         pandas file reading parameters
     states_sel: slice or range or list of int
         States subset selection
@@ -58,7 +58,7 @@ class MultiHeightStates(States):
         heights,
         var2col={},
         fixed_vars={},
-        pd_read_pars={},
+        read_pars={},
         states_sel=None,
         states_loc=None,
         **ipars,
@@ -79,7 +79,7 @@ class MultiHeightStates(States):
         fixed_vars: dict, optional
             Fixed uniform variable values, instead of
             reading from data
-        pd_read_pars: dict, optional
+        read_pars: dict, optional
             pandas file reading parameters
         states_sel: slice or range or list of int, optional
             States subset selection
@@ -91,9 +91,9 @@ class MultiHeightStates(States):
         """
         super().__init__()
 
-        self.ovars = output_vars
+        self.ovars = list(output_vars)
         self.heights = np.array(heights, dtype=config.dtype_double)
-        self.rpars = pd_read_pars
+        self.rpars = read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
         self.ipars = ipars
@@ -102,7 +102,6 @@ class MultiHeightStates(States):
 
         self._data_source = data_source
         self._solo = None
-        self._weights = None
         self._inds = None
         self._N = None
 
@@ -213,9 +212,7 @@ class MultiHeightStates(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
         else:
-            isorg = True
             data = self.data_source
 
         if self.states_sel is not None:
@@ -227,34 +224,31 @@ 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=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]
 
         cols = []
         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:
-                cmap[v] = (len(cols), len(cols) + len(vcols))
-                cols += vcols
+            if v != FV.WEIGHT:
+                vcols = self._find_cols(v, data.columns)
+                if len(vcols) == 1:
+                    self._solo[v] = data[vcols[0]].to_numpy()
+                elif len(vcols) > 1:
+                    cmap[v] = (len(cols), len(cols) + len(vcols))
+                    cols += vcols
         data = data[cols]
 
         self.H = self.var(FV.H)
         self.VARS = self.var("vars")
         self.DATA = self.var("data")
+        self.WEIGHT = self.var(FV.WEIGHT)
 
         idata = super().load_data(algo, verbosity)
 
@@ -268,7 +262,8 @@ class MultiHeightStates(States):
             dims,
             data.to_numpy().reshape(self._N, n_vrs, n_hts),
         )
-
+        if weights is not None:
+            idata["data_vars"][self.WEIGHT] = ((FC.STATE,), weights)
         for v, d in self._solo.items():
             idata["data_vars"][self.var(v)] = ((FC.STATE,), d)
         self._solo = list(self._solo.keys())
@@ -309,10 +304,9 @@ class MultiHeightStates(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,
@@ -345,7 +339,6 @@ class MultiHeightStates(States):
 
         data = data_stash[self.name]
         self._data_source = data.pop("data_source")
-        self._weights = data.pop("weights")
         self._inds = data.pop("inds")
 
     def size(self):
@@ -391,27 +384,6 @@ class MultiHeightStates(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 calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -512,6 +484,15 @@ class MultiHeightStates(States):
             else:
                 results[v] = ires[vrs.index(v)]
 
+        # add weights:
+        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 results
 
     def finalize(self, algo, verbosity=0):
@@ -528,7 +509,6 @@ class MultiHeightStates(States):
         """
         super().finalize(algo, verbosity)
         self._solo = None
-        self._weights = None
         self._N = None
 
 
@@ -592,7 +572,7 @@ class MultiHeightNCStates(MultiHeightStates):
             data_source,
             *args,
             heights=[],
-            pd_read_pars=None,
+            read_pars=None,
             **kwargs,
         )
         self.state_coord = state_coord
@@ -651,37 +631,35 @@ class MultiHeightNCStates(MultiHeightStates):
         self._inds = data.coords[self.state_coord].to_numpy()
 
         if self._format_times_func == "default":
-            format_times_func = lambda t: t.astype("datetime64[ns]")
+
+            def format_times_func(t):
+                """little helper function to convert times to datetime64"""
+                return t.astype("datetime64[ns]")
         else:
             format_times_func = self._format_times_func
         if format_times_func is not None:
             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=config.dtype_double)
+        weights = None
         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]
+            weights = data.data_vars[w_name].to_numpy()
         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=config.dtype_double
-            )
-            self._weights[:] = 1.0 / self._N
 
         cols = {}
         self._solo = {}
         for v in self.ovars:
+            if v in self.fixed_vars or v == FV.WEIGHT:
+                continue
             c = self.var2col.get(v, v)
-            if c in self.fixed_vars:
-                pass
-            elif c in data.attrs:
+            if 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,):
@@ -705,6 +683,7 @@ class MultiHeightNCStates(MultiHeightStates):
         self.H = self.var(FV.H)
         self.VARS = self.var("vars")
         self.DATA = self.var("data")
+        self.WEIGHT = self.var(FV.WEIGHT)
 
         idata = States.load_data(self, algo, verbosity)
         idata["coords"][self.H] = self.heights
@@ -717,7 +696,8 @@ class MultiHeightNCStates(MultiHeightStates):
                 [data.data_vars[c].to_numpy() for c in cols.values()], axis=1
             ).astype(config.dtype_double),
         )
-
+        if weights is not None:
+            idata["data_vars"][self.WEIGHT] = ((FC.STATE,), weights)
         for v, d in self._solo.items():
             idata["data_vars"][self.var(v)] = (
                 (FC.STATE,),