foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/input/states/states_table.py

@@ -81,7 +81,6 @@ class StatesTable(States):
         """
         super().__init__()
 
-        self.data_source = data_source
         self.ovars = output_vars
         self.rpars = pd_read_pars
         self.var2col = var2col
@@ -95,11 +94,30 @@ class StatesTable(States):
                 f"States '{self.name}': Cannot handle both 'states_sel' and 'states_loc', please pick one"
             )
 
-        self._weights = None
         self._N = None
         self._tvars = None
         self._profiles = None
 
+        self._data_source = data_source
+        self.__weights = None
+
+    @property
+    def data_source(self):
+        """
+        The data source
+
+        Returns
+        -------
+        s: object
+            The data source
+
+        """
+        if self.running:
+            raise ValueError(
+                f"States '{self.name}': Cannot access data_source while running"
+            )
+        return self._data_source
+
     def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
         """
         Reset the states, optionally select states
@@ -164,7 +182,6 @@ class StatesTable(States):
             Names of all sub models
 
         """
-
         return list(self._profiles.values())
 
     def load_data(self, algo, verbosity=0):
@@ -202,7 +219,7 @@ class StatesTable(States):
                     print(
                         f"States '{self.name}': Reading static data '{self.data_source}' from context '{STATES}'"
                     )
-                self.data_source = algo.dbook.get_file_path(
+                self._data_source = algo.dbook.get_file_path(
                     STATES, self.data_source, check_raw=False
                 )
                 if verbosity:
@@ -218,21 +235,21 @@ class StatesTable(States):
         elif self.states_loc is not None:
             data = data.loc[self.states_loc]
         self._N = len(data.index)
-        self._inds = data.index.to_numpy()
+        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=FC.DTYPE)
+        self.__weights = np.zeros((self._N, algo.n_turbines), dtype=FC.DTYPE)
         if col_w in data:
-            self._weights[:] = data[col_w].to_numpy()[:, None]
+            self.__weights[:] = data[col_w].to_numpy()[:, None]
         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
+            self.__weights[:] = 1.0 / self._N
             if isorg:
                 data = data.copy()
-            data[col_w] = self._weights[:, 0]
+            data[col_w] = self.__weights[:, 0]
 
         tcols = []
         for v in self._tvars:
@@ -273,7 +290,9 @@ class StatesTable(States):
             The index labels of states, or None for default integers
 
         """
-        return self._inds
+        if self.running:
+            raise ValueError(f"States '{self.name}': Cannot access index while running")
+        return self.__inds
 
     def output_point_vars(self, algo):
         """
@@ -307,10 +326,87 @@ class StatesTable(States):
             The weights, shape: (n_states, n_turbines)
 
         """
-        return self._weights
+        if self.running:
+            raise ValueError(
+                f"States '{self.name}': Cannot access weights while running"
+            )
+        return self.__weights
+
+    def set_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to running, and moves
+        all large data to stash.
+
+        The stashed data will be returned by the
+        unset_running() function after running calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().set_running(algo, data_stash, sel, isel, verbosity)
+
+        data_stash[self.name] = dict(
+            data_source=self._data_source,
+            weights=self.__weights,
+            inds=self.__inds,
+        )
+        del self._data_source, self.__weights, self.__inds
+
+    def unset_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to not running, recovering large data
+        from stash
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().unset_running(algo, data_stash, sel, isel, verbosity)
+
+        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):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -368,7 +464,7 @@ class StatesTable(States):
             The verbosity level
 
         """
-        self._weights = None
+        self.__weights = None
         self._N = None
         self._tvars = None
 
@@ -412,11 +508,11 @@ class TabStates(StatesTable):
         """
         self._normalize = normalize
         if isinstance(data_source, Dataset):
-            self._tab_source = None
-            self._tab_data = data_source
+            self.__tab_source = None
+            self.__tab_data = data_source
         elif isinstance(data_source, (str, Path)):
-            self._tab_source = data_source
-            self._tab_data = None
+            self.__tab_source = data_source
+            self.__tab_data = None
         else:
             raise TypeError(
                 f"Expecting str, Path or xarray.Dataset as data_source, got {type(data_source)}"
@@ -448,47 +544,47 @@ class TabStates(StatesTable):
 
         """
         if self.data_source is None:
-            if self._tab_data is None:
-                if not Path(self._tab_source).is_file():
+            if self.__tab_data is None:
+                if not Path(self.__tab_source).is_file():
                     if verbosity:
                         print(
-                            f"States '{self.name}': Reading static data '{self._tab_source}' from context '{STATES}'"
+                            f"States '{self.name}': Reading static data '{self.__tab_source}' from context '{STATES}'"
                         )
-                    self._tab_source = algo.dbook.get_file_path(
-                        STATES, self._tab_source, check_raw=False
+                    self.__tab_source = algo.dbook.get_file_path(
+                        STATES, self.__tab_source, check_raw=False
                     )
                     if verbosity:
-                        print(f"Path: {self._tab_source}")
+                        print(f"Path: {self.__tab_source}")
                 elif verbosity:
-                    print(f"States '{self.name}': Reading file {self._tab_source}")
-                self._tab_data = read_tab_file(self._tab_source, self._normalize)
+                    print(f"States '{self.name}': Reading file {self.__tab_source}")
+                self.__tab_data = read_tab_file(self.__tab_source, self._normalize)
 
-            a = self._tab_data.attrs["factor_ws"]
-            b = self._tab_data.attrs["shift_wd"]
+            a = self.__tab_data.attrs["factor_ws"]
+            b = self.__tab_data.attrs["shift_wd"]
             if b != 0.0:
                 raise ValueError(
                     f"{self.name}: shift_wd = {b} is not supported, expecting zero"
                 )
 
-            wd0 = self._tab_data["wd"].to_numpy()
+            wd0 = self.__tab_data["wd"].to_numpy()
             ws0 = a * np.append(
-                np.array([0], dtype=FC.DTYPE), self._tab_data["ws"].to_numpy()
+                np.array([0], dtype=FC.DTYPE), self.__tab_data["ws"].to_numpy()
             )
             ws0 = 0.5 * (ws0[:-1] + ws0[1:])
 
-            n_ws = self._tab_data.sizes["ws"]
-            n_wd = self._tab_data.sizes["wd"]
+            n_ws = self.__tab_data.sizes["ws"]
+            n_wd = self.__tab_data.sizes["wd"]
             ws = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
             wd = np.zeros((n_ws, n_wd), dtype=FC.DTYPE)
             ws[:] = ws0[:, None]
             wd[:] = wd0[None, :]
 
-            wd_freq = self._tab_data["wd_freq"].to_numpy() / 100
-            weights = self._tab_data["ws_freq"].to_numpy() * wd_freq[None, :] / 1000
+            wd_freq = self.__tab_data["wd_freq"].to_numpy() / 100
+            weights = self.__tab_data["ws_freq"].to_numpy() * wd_freq[None, :] / 1000
 
             sel = weights > 0
 
-            self.data_source = pd.DataFrame(
+            self._data_source = pd.DataFrame(
                 index=np.arange(np.sum(sel)),
                 data={
                     FV.WS: ws[sel],
@@ -496,6 +592,79 @@ class TabStates(StatesTable):
                     FV.WEIGHT: weights[sel],
                 },
             )
-            self.data_source.index.name = FC.STATE
+            self._data_source.index.name = FC.STATE
 
         return super().load_data(algo, verbosity)
+
+    def set_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to running, and moves
+        all large data to stash.
+
+        The stashed data will be returned by the
+        unset_running() function after running calculations.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().set_running(algo, data_stash, sel, isel, verbosity)
+
+        data_stash[self.name].update(
+            dict(
+                tab_source=self.__tab_source,
+                tab_data=self.__tab_data,
+            )
+        )
+        del self.__tab_source, self.__tab_data
+
+    def unset_running(
+        self,
+        algo,
+        data_stash,
+        sel=None,
+        isel=None,
+        verbosity=0,
+    ):
+        """
+        Sets this model status to not running, recovering large data
+        from stash
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        data_stash: dict
+            Large data stash, this function adds data here.
+            Key: model name. Value: dict, large model data
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        super().unset_running(algo, data_stash, sel, isel, verbosity)
+
+        data = data_stash[self.name]
+        self.__tab_source = data.pop("tab_source")
+        self.__tab_data = data.pop("tab_data")

foxes/input/windio/__init__.py

@@ -1,11 +1,11 @@
 """
-Functions for usingin windIO yaml files as input.
+Functions for using windIO yaml files as input.
 """
 
 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_farm import read_turbine_types, read_layout
 from .read_attributes import read_attributes
 from .read_outputs import read_outputs
 from .runner import WindioRunner

foxes/input/windio/get_states.py

@@ -7,14 +7,18 @@ from foxes.core import States
 import foxes.constants as FC
 import foxes.variables as FV
 
+
 def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
     """Read ABL profiles information
     :group: input.windio
     """
     profiles = {}
     if FV.Z0 in fields:
-        if FV.H not in fields and verbosity > 0:
-            print(f"Ignoring '{FV.Z0}', since no reference_height found. No ABL profile activated.")
+        if FV.H not in fields:
+            if verbosity > 0:
+                print(
+                    f"Ignoring '{FV.Z0}', since no reference_height found. No ABL profile activated."
+                )
         elif FV.MOL in fields:
             ovars.append(FV.MOL)
             fixval[FV.H] = fields[FV.H]
@@ -23,14 +27,20 @@ def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
             fixval[FV.H] = fields[FV.H]
             profiles = {FV.WS: "ABLLogNeutralWsProfile"}
     elif FV.H in fields and verbosity > 0:
-        print(f"Ignoring '{FV.H}', since no '{FV.Z0}' data found. No ABL profile activated.")
+        print(
+            f"Ignoring '{FV.H}', since no '{FV.Z0}' data found. No ABL profile activated."
+        )
     if len(profiles) and verbosity > 2:
-        print(f"        Selecting ABL profile '{profiles[FV.WS]}', {FV.H} = {fields[FV.H]} m")
-            
+        print(
+            f"        Selecting ABL profile '{profiles[FV.WS]}', {FV.H} = {fields[FV.H]} m"
+        )
+
     return profiles
-    
-def _get_SingleStateStates(coords, fields, dims, states_dict, 
-                           ovars, fixval, profiles, verbosity):
+
+
+def _get_SingleStateStates(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
     """Try to generate single state parameters
     :group: input.windio
     """
@@ -66,8 +76,10 @@ def _get_SingleStateStates(coords, fields, dims, states_dict,
     )
     return True
 
-def _get_Timeseries(coords, fields, dims, states_dict, 
-                    ovars, fixval, profiles, verbosity):
+
+def _get_Timeseries(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
     """Try to generate time series parameters
     :group: input.windio
     """
@@ -100,24 +112,28 @@ def _get_Timeseries(coords, fields, dims, states_dict,
         return True
     return False
 
-def _get_MultiHeightNCTimeseries(coords, fields, dims, states_dict, 
-                    ovars, fixval, profiles, verbosity):
+
+def _get_MultiHeightNCTimeseries(
+    coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+):
     """Try to generate time series parameters
     :group: input.windio
     """
     if len(coords) == 2 and FC.TIME in coords and FV.H in coords:
         if verbosity > 2:
             print("        selecting class 'MultiHeightNCTimeseries'")
-            
+
         if len(profiles) and verbosity > 0:
-            print(f"Ignoring profile '{profiles[FV.WS]}' for states class 'MultiHeightNCTimeseries'")
+            print(
+                f"Ignoring profile '{profiles[FV.WS]}' for states class 'MultiHeightNCTimeseries'"
+            )
 
         data = {}
         fix = {}
         for v, d in fields.items():
             if dims[v] == (FC.TIME, FV.H):
                 data[v] = ((FC.TIME, FV.H), d)
-            if dims[v] == (FV.H, FC.TIME):
+            elif dims[v] == (FV.H, FC.TIME):
                 data[v] = ((FC.TIME, FV.H), np.swapaxes(d, 0, 1))
             elif len(dims[v]) == 0:
                 fix[v] = d
@@ -139,6 +155,7 @@ def _get_MultiHeightNCTimeseries(coords, fields, dims, states_dict,
         return True
     return False
 
+
 def get_states(coords, fields, dims, verbosity=1):
     """
     Reads states parameters from windio input
@@ -164,18 +181,22 @@ def get_states(coords, fields, dims, verbosity=1):
     """
     if verbosity > 2:
         print("      Preparing states")
-        
+
     ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
-    fixval = {FV.TI: 0.05, FV.RHO: 1.225}  
+    fixval = {FV.TI: 0.05, FV.RHO: 1.225}
     profiles = _get_profiles(coords, fields, dims, ovars, fixval, verbosity)
 
     states_dict = {}
-    if _get_SingleStateStates(
-        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
-    ) or _get_Timeseries(
-        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
-    ) or _get_MultiHeightNCTimeseries(
-        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+    if (
+        _get_SingleStateStates(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
+        or _get_Timeseries(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
+        or _get_MultiHeightNCTimeseries(
+            coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+        )
     ):
         return States.new(**states_dict)
     else: