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

foxes/input/states/states_table.py

@@ -98,7 +98,7 @@ class StatesTable(States):
         self._N = None
         self._tvars = None
         self._profiles = None
-        self._data_source = data_source
+        self._data = data_source
 
     @property
     def data_source(self):
@@ -115,7 +115,7 @@ class StatesTable(States):
             raise ValueError(
                 f"States '{self.name}': Cannot access data_source while running"
             )
-        return self._data_source
+        return self._data
 
     def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
         """
@@ -210,13 +210,13 @@ class StatesTable(States):
         if isinstance(self.data_source, pd.DataFrame):
             data = self.data_source
         else:
-            self._data_source = get_input_path(self.data_source)
+            self._data = get_input_path(self.data_source)
             if not self.data_source.is_file():
                 if verbosity > 0:
                     print(
                         f"States '{self.name}': Reading static data '{self.data_source}' from context '{STATES}'"
                     )
-                self._data_source = algo.dbook.get_file_path(
+                self._data = algo.dbook.get_file_path(
                     STATES, self.data_source.name, check_raw=False
                 )
                 if verbosity > 0:
@@ -343,10 +343,10 @@ class StatesTable(States):
         super().set_running(algo, data_stash, sel, isel, verbosity)
 
         data_stash[self.name] = dict(
-            data_source=self._data_source,
+            data_source=self._data,
             inds=self.__inds,
         )
-        del self._data_source, self.__inds
+        del self._data, self.__inds
 
     def unset_running(
         self,
@@ -378,7 +378,7 @@ class StatesTable(States):
         super().unset_running(algo, data_stash, sel, isel, verbosity)
 
         data = data_stash[self.name]
-        self._data_source = data.pop("data_source")
+        self._data = data.pop("data_source")
         self.__inds = data.pop("inds")
 
     def calculate(self, algo, mdata, fdata, tdata):
@@ -407,23 +407,13 @@ class StatesTable(States):
             (n_states, n_targets, n_tpoints)
 
         """
+        self.ensure_output_vars(algo, tdata)
+
         for i, v in enumerate(self._tvars):
-            if v in tdata:
-                tdata[v][:] = mdata[self.DATA][:, i, None, None]
-            else:
-                tdata[v] = np.zeros(
-                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
-                    dtype=config.dtype_double,
-                )
-                tdata[v][:] = mdata[self.DATA][:, i, None, None]
-                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
+            tdata[v][:] = mdata[self.DATA][:, i, None, None]
 
         for v, f in self.fixed_vars.items():
-            tdata[v] = np.full(
-                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
-                f,
-                dtype=config.dtype_double,
-            )
+            tdata[v][:] = f
 
         z = tdata[FC.TARGETS][..., 2]
         for v, p in self._profiles.items():
@@ -572,7 +562,7 @@ class TabStates(StatesTable):
 
             sel = weights > 0
 
-            self._data_source = pd.DataFrame(
+            self._data = pd.DataFrame(
                 index=np.arange(np.sum(sel)),
                 data={
                     FV.WS: ws[sel],
@@ -580,7 +570,7 @@ class TabStates(StatesTable):
                     FV.WEIGHT: weights[sel],
                 },
             )
-            self._data_source.index.name = FC.STATE
+            self._data.index.name = FC.STATE
 
         return super().load_data(algo, verbosity)
 

foxes/input/states/weibull_sectors.py

@@ -29,6 +29,8 @@ class WeibullSectors(StatesTable):
         Subset selection via xr.Dataset.sel()
     isel: dict
         Subset selection via xr.Dataset.isel()
+    rpars: dict
+        Additional parameters for reading the file
     RDICT: dict
         Default xarray file reading parameters
 
@@ -46,6 +48,7 @@ class WeibullSectors(StatesTable):
         var2ncvar={},
         sel=None,
         isel=None,
+        read_pars={},
         **kwargs,
     ):
         """
@@ -67,6 +70,8 @@ class WeibullSectors(StatesTable):
             Subset selection via xr.Dataset.sel()
         isel: dict, optional
             Subset selection via xr.Dataset.isel()
+        read_pars: dict
+            Additional parameters for reading the file
         kwargs: dict, optional
             Additional arguments for the base class
 
@@ -76,6 +81,7 @@ class WeibullSectors(StatesTable):
         self.var2ncvar = var2ncvar
         self.sel = sel if sel is not None else {}
         self.isel = isel if isel is not None else {}
+        self.rpars = read_pars
 
         if FV.WS not in self.ovars:
             raise ValueError(
@@ -87,39 +93,37 @@ class WeibullSectors(StatesTable):
                     f"States '{self.name}': Cannot have '{v}' as output variable"
                 )
 
-        self._original_data_source = None
+        self._original_data = None
 
     def __repr__(self):
-        return f"{type(self).__name__}(ws_bins={self._n_ws})"
+        return f"{type(self).__name__}(n_wd={self._n_wd}, n_ws={self._n_ws})"
 
-    def load_data(self, algo, verbosity=0):
+    def _read_data(self, algo, point_coord=None, 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.
+        Extracts data from file or Dataset.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
+        point_coord: str, optional
+            The coordinate name representing the point index
         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`
+        data: xarray.Dataset
+            The input data
 
         """
+        # store original data
+        if self._original_data is not None:
+            self._data = self._original_data
+            self._original_data = None
 
-        if self._original_data_source is not None:
-            self._data_source = self._original_data_source
-            self._original_data_source = None
-
+        # read file or grab data
+        cwd = self.var2ncvar.get(FV.WD, FV.WD)
         if isinstance(self.data_source, (str, PathLike)):
             fpath = get_input_path(self.data_source)
             if not fpath.is_file():
@@ -130,96 +134,197 @@ class WeibullSectors(StatesTable):
                 fpath = algo.dbook.get_file_path(STATES, fpath.name, check_raw=False)
                 if verbosity > 0:
                     print(f"Path: {fpath}")
-            elif verbosity:
+            elif verbosity > 0:
                 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
+                data = PandasFileHelper().read_file(fpath, **rpars)
+                data.index.name = cwd
+                data = data.to_xarray()
+            self._original_data = data
 
         elif isinstance(self.data_source, Dataset):
             data = self.data_source
 
         elif isinstance(self.data_source, pd.DataFrame):
-            data = self.data_source.to_xarray()
+            data = self.data_source
+            data.index.name = cwd
+            data = data.to_xarray()
 
+        # optionally select a subset
         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)
+        # remove wd 360 from the end, if wd 0 is given:
+        wd = data[cwd].to_numpy()
+        if wd[0] == 0.0 and wd[-1] == 360.0:
+            data = data.isel({cwd: np.s_[:-1]})
+
+        # construct wind speed bins and bin deltas
+        cws = 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()
+            wss = 0.5 * (wsb[:-1] + wsb[1:])
+        elif cws in data:
+            wss = data[cws].to_numpy()
+            wsb = np.zeros((len(wss) + 1,), dtype=config.dtype_double)
+            wsb[1:-1] = 0.5 * (wss[1:] + wss[:-1])
+            wsb[0] = wss[0] - 0.5 * wsb[1]
+            wsb[-1] = wss[-1] + 0.5 * wsb[-2]
+            self.ws_bins = wsb
         else:
             raise ValueError(
-                f"States '{self.name}': Expecting ws_bins argument, since '{wsn}' not found in data"
+                f"States '{self.name}': Expecting ws_bins argument, since '{cws}' 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 = {}
+        # prepare data binning
+        if self._original_data is None:
+            self._original_data = self.data_source
+        cpt = (
+            self.var2ncvar.get(FC.POINT, FC.POINT) if point_coord is not None else None
+        )
+        n_wd = data.sizes[cwd]
+        self.BIN_WD = self.var("bin_wd")
+        self.BIN_WS = self.var("bin_ws")
+        self.POINT = self.var("point")
+        if cpt is None:
+            n_pt = 0
+            shp = (n_wd, n_ws)
+            dms = (self.BIN_WD, self.BIN_WS)
+        else:
+            n_pt = data.sizes[cpt]
+            shp = (n_wd, n_ws, n_pt)
+            dms = (self.BIN_WD, self.BIN_WS, self.POINT)
+
+        # create binned data
+        self._data = {
+            FV.WD: np.zeros(shp, dtype=config.dtype_double),
+            FV.WS: np.zeros(shp, dtype=config.dtype_double),
+        }
+        if cpt is None:
+            self._data[FV.WD][:] = data[cwd].to_numpy()[:, None]
+            self._data[FV.WS][:] = wss[None, :]
+        else:
+            self._data[FV.WD][:] = data[cwd].to_numpy()[:, None, None]
+            self._data[FV.WS][:] = wss[None, :, None]
         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:
+            if v not in [FV.WS, FV.WD] and v not in self.fixed_vars:
+                w = self.var2ncvar.get(v, v)
+                if w 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}"
+                        f"States '{self.name}': Missing variable '{w}' in data, found {list(data.data_vars.keys())}"
                     )
-                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),
+                d = data[w]
+                iws = d.dims.index(cws) if cws in d.dims else -1
+                iwd = d.dims.index(cwd) if cwd in d.dims else -1
+                ipt = d.dims.index(cpt) if cpt is not None and cpt in d.dims else -1
+                d = d.to_numpy()
+                if v in [FV.WEIBULL_A, FV.WEIBULL_k, FV.WEIGHT]:
+                    if cws in data[w].dims:
+                        raise ValueError(
+                            f"States '{self.name}': Cannot have '{cws}' as dimension in variable '{v}', got {data[w].dims}"
+                        )
+                    if cwd not in data[w].dims:
+                        raise ValueError(
+                            f"States '{self.name}': Expecting '{cwd}' as dimension in variable '{v}', got {data[w].dims}"
+                        )
+                if iws < 0 and iwd < 0 and ipt < 0:
+                    self.fixed_vars[v] = d.to_numpy()
+                elif iws >= 0 and iwd >= 0 and ipt >= 0:
+                    self._data[v] = np.moveaxis(d, [iwd, iws, ipt], [0, 1, 2])
+                elif iws >= 0 and iwd >= 0 and ipt < 0:
+                    if cpt is None:
+                        self._data[v] = np.moveaxis(d, [iwd, iws], [0, 1])
+                    else:
+                        self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                        self._data[v][:] = np.moveaxis(d, [iwd, iws], [0, 1])[
+                            :, :, None
+                        ]
+                elif iws >= 0 and iwd < 0 and ipt >= 0:
+                    self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                    self._data[v][:] = np.moveaxis(d, [iws, ipt], [0, 1])[None, :, :]
+                elif iws < 0 and iwd >= 0 and ipt >= 0:
+                    self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                    self._data[v][:] = np.moveaxis(d, [iwd, ipt], [0, 1])[:, None, :]
+                elif iws >= 0 and iwd < 0 and ipt < 0:
+                    self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                    if cpt is None:
+                        self._data[v][:] = d[None, :]
+                    else:
+                        self._data[v][:] = d[None, :, None]
+                elif iws < 0 and iwd >= 0 and ipt < 0:
+                    self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                    if cpt is None:
+                        self._data[v][:] = d[:, None]
+                    else:
+                        self._data[v][:] = d[:, None, None]
+                elif iws < 0 and iwd < 0 and ipt >= 0:
+                    self._data[v] = np.zeros(shp, dtype=config.dtype_double)
+                    self._data[v][:] = d[None, None, :]
+
+        # compute Weibull weights
+        self._data[FV.WEIGHT] *= weibull_weights(
+            ws=wss[None, :, None] if cpt is not None else wss[None, :],
+            ws_deltas=wsd[None, :, None] if cpt is not None else wsd[None, :],
+            A=self._data.pop(FV.WEIBULL_A),
+            k=self._data.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
+        # translate binned data to states
+        self._n_pt = n_pt
+        self._n_wd = n_wd
+        self._n_ws = n_ws
+        self._N = n_wd * n_ws
+        self._data = Dataset(
+            data_vars={v: (dms, d) for v, d in self._data.items()},
+        )
+
+        return data
+
+    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`
+
+        """
+        self._read_data(algo, verbosity=0)
+
+        tmp = {}
+        for v, d in self._data.data_vars.items():
+            if self.POINT in d.dims:
+                raise TypeError(
+                    f"States '{self.name}': Variable '{v}' has unsupported dimension '{self.POINT}', dims = {d.dims}"
+                )
+            else:
+                tmp[v] = d.to_numpy().reshape(self._N)
+        self._data = tmp
+        del tmp
+
+        self._data = pd.DataFrame(data=self._data, index=np.arange(self._N))
+        self._data.index.name = FC.STATE
 
         return super().load_data(algo, verbosity)

foxes/input/states/wrg_states.py

@@ -229,8 +229,8 @@ class WRGStates(States):
             (n_states, n_targets, n_tpoints)
 
         """
-
         # prepare:
+        self.ensure_output_vars(algo, tdata)
         n_states = tdata.n_states
         n_targets = tdata.n_targets
         n_tpoints = tdata.n_tpoints

foxes/input/yaml/dict.py

@@ -110,7 +110,7 @@ def read_dict(
                     t = mbook.sources.get_item(s)
                     c = mbook.base_classes.get_item(s)
                     ms = [
-                        Dict(m, name=f"{mdict.name}.s{i}") for i, m in enumerate(mlst)
+                        Dict(m, _name=f"{mdict.name}.s.{i}") for i, m in enumerate(mlst)
                     ]
                     for m in ms:
                         mname = m.pop_item("name")
@@ -128,10 +128,7 @@ def read_dict(
         if algo is None:
             _print("Creating wind farm")
             fdict = idict.get_item("wind_farm")
-            lyts = [
-                Dict(lo, name=f"{fdict.name}.layout{i}")
-                for i, lo in enumerate(fdict.pop_item("layouts"))
-            ]
+            lyts = fdict.pop_item("layouts")
             farm = WindFarm(**fdict)
             for lyt in lyts:
                 add_fun = getattr(farm_layout, lyt.pop_item("function"))
@@ -251,6 +248,7 @@ def run_obj_function(
     fdict,
     algo,
     rlabels,
+    nofig=False,
     verbosity=None,
 ):
     """
@@ -266,6 +264,8 @@ def run_obj_function(
         The algorithm
     rlabels: dict
         Storage for result variables
+    nofig: bool
+        Do not show figures, overrules settings from fdict
     verbosity: int, optional
         The verbosity level, 0 = silent
 
@@ -310,9 +310,9 @@ def run_obj_function(
     results = f(*args, **fdict)
 
     # pyplot shortcuts:
-    if plt_show:
+    if not nofig and plt_show:
         plt.show()
-    if plt_close:
+    if not nofig and plt_close:
         results = None
         plt.close()
 
@@ -346,6 +346,7 @@ def run_outputs(
     point_results=None,
     extra_sig={},
     ret_rlabels=False,
+    nofig=False,
     verbosity=None,
 ):
     """
@@ -366,6 +367,8 @@ def run_outputs(
         arguments (key) with data (value)
     ret_rlabels: bool
         Flag for returning results variables
+    nofig: bool
+        Do not show figures, overrules settings from idict
     verbosity: int, optional
         The verbosity level, 0 = silent
 
@@ -387,24 +390,19 @@ def run_outputs(
             print(*args, **kwargs)
 
     out = []
-    rlabels = Dict(name="result_labels")
+    rlabels = Dict(_name="result_labels")
     if "outputs" in idict:
-        odicts = [
-            Dict(odict, name=f"{idict.name}.output{i}")
-            for i, odict in enumerate(idict["outputs"])
-        ]
+        odicts = idict["outputs"]
 
         for i, d in enumerate(odicts):
             if "output_type" in d:
+                d["nofig"] = nofig
                 ocls = d.pop_item("output_type")
                 _print(f"\nRunning output {i}: {ocls}")
                 d0 = dict(output_type=ocls)
                 d0.update(d)
 
-                flist = [
-                    Dict(f, name=f"{d.name}.function{j}")
-                    for j, f in enumerate(d.pop_item("functions"))
-                ]
+                flist = d.pop_item("functions")
 
                 o = get_output_obj(
                     ocls, d, algo, farm_results, point_results, extra_sig=extra_sig
@@ -419,10 +417,7 @@ def run_outputs(
                 o = _get_object(rlabels, ocls)
                 d0 = dict(object=ocls)
                 d0.update(d)
-                flist = [
-                    Dict(f, name=f"{d.name}.function{j}")
-                    for j, f in enumerate(d.pop_item("functions"))
-                ]
+                flist = d.pop_item("functions")
 
             else:
                 raise KeyError(
@@ -431,7 +426,7 @@ def run_outputs(
 
             fres = []
             for fdict in flist:
-                results = run_obj_function(o, fdict, algo, rlabels, verbosity)
+                results = run_obj_function(o, fdict, algo, rlabels, nofig, verbosity)
                 fres.append(results)
             out.append((d0, fres))
 
@@ -441,7 +436,7 @@ def run_outputs(
     return out if not ret_rlabels else out, rlabels
 
 
-def run_dict(idict, *args, verbosity=None, **kwargs):
+def run_dict(idict, *args, nofig=False, verbosity=None, **kwargs):
     """
     Runs foxes from dictionary input
 
@@ -451,6 +446,8 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         The input parameter dictionary
     args: tuple, optional
         Additional parameters for read_dict
+    nofig: bool
+        Do not show figures, overrules settings from idict
     verbosity: int, optional
         Force a verbosity level, 0 = silent, overrules
         settings from idict
@@ -480,7 +477,7 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
     algo, engine = read_dict(idict, *args, verbosity=verbosity, **kwargs)
 
     # run farm calculation:
-    rdict = idict.get_item("calc_farm", Dict(name=idict.name + ".calc_farm"))
+    rdict = idict.get_item("calc_farm", Dict(_name=idict.name + ".calc_farm"))
     if rdict.pop_item("run", True):
         _print("Running calc_farm")
         farm_results = algo.calc_farm(**rdict)
@@ -504,7 +501,11 @@ def run_dict(idict, *args, verbosity=None, **kwargs):
         out += (point_results,)
 
     # run outputs:
-    out += (run_outputs(idict, algo, farm_results, point_results, verbosity=verbosity),)
+    out += (
+        run_outputs(
+            idict, algo, farm_results, point_results, nofig=nofig, verbosity=verbosity
+        ),
+    )
 
     # shutdown engine, if created above:
     if engine is not None: