foxes 0.8.1__py3-none-any.whl → 1.0__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 acces 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 acces 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 acces 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

@@ -5,7 +5,7 @@ Functions for usingin 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:

foxes/input/windio/read_attributes.py

@@ -5,7 +5,9 @@ import foxes.variables as FV
 from .read_outputs import read_outputs
 
 
-def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbosity):
+def _read_wind_deficit(
+    wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
+):
     """Reads the wind deficit wake model"""
 
     wind_def_map = Dict(
@@ -32,11 +34,11 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
         },
         name="ws_sup_dict",
     )
-    
+
     wname = wind_deficit.pop("name")
     eff_ws = wind_deficit.pop("use_effective_ws", True)
     if verbosity > 2:
-        print("    Reading wind_deficit_model")
+        print("    Reading", wake_model_key)
         print("      Name    :", wname)
         print("      Eff ws  :", eff_ws)
         print("      Contents:", [k for k in wind_deficit.keys()])
@@ -73,6 +75,7 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
 
     return ka, kb, amb_ti
 
+
 def _read_turbulence(
     turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
 ):
@@ -99,7 +102,7 @@ def _read_turbulence(
         print("    Reading turbulence_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in turbulence_model.keys()])
-    if wname != "None":
+    if wname not in ["None", "none"]:
         tiwake_dict = dict(wmodel_type=twake_def_map[wname], induction=induction)
         if wname == "IEC-TI-2019":
             tiwake_dict["opening_angle"] = None
@@ -129,6 +132,7 @@ def _read_turbulence(
             print("       ", algo_dict["mbook"].wake_models[wname])
         algo_dict["wake_models"].append(wname)
 
+
 def _read_blockage(blockage_model, induction, algo_dict, verbosity):
     """Reads the blockage model"""
     indc_def_map = Dict(
@@ -146,7 +150,7 @@ def _read_blockage(blockage_model, induction, algo_dict, verbosity):
         print("    Reading blockage_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in blockage_model.keys()])
-    if wname != "None":
+    if wname not in ["None", "none"]:
         indc_dict = Dict(wmodel_type=indc_def_map[wname], induction=induction)
         algo_dict["mbook"].wake_models[wname] = WakeModel.new(**indc_dict)
         if verbosity > 2:
@@ -155,6 +159,7 @@ def _read_blockage(blockage_model, induction, algo_dict, verbosity):
         algo_dict["wake_models"].append(wname)
         algo_dict["algo_type"] = "Iterative"
 
+
 def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     """Reads the rotor averaging"""
     if verbosity > 2:
@@ -177,16 +182,20 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
         print("        wake_averaging      :", wake_averaging)
         print("        ws exponent power   :", wse_P)
         print("        ws exponent ct      :", wse_ct)
+
     if background_averaging in ["center", "centre"]:
         algo_dict["rotor_model"] = "centre"
+    elif background_averaging in ["none", "None", None]:
+        algo_dict["rotor_model"] = None
     elif background_averaging == "grid":
         algo_dict["rotor_model"] = f"grid{nx*ny}"
     else:
-        raise KeyError(
-            f"Expecting background_averaging 'center' or 'grid', got '{background_averaging}'"
-        )
+        algo_dict["rotor_model"] = background_averaging
+
     if wake_averaging in ["centre", "center"]:
         algo_dict["partial_wakes"] = "centre"
+    elif wake_averaging in ["none", "None", "auto", None]:
+        algo_dict["partial_wakes"] = None
     elif wake_averaging == "grid":
         if background_averaging == "grid":
             algo_dict["partial_wakes"] = "rotor_points"
@@ -197,10 +206,12 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
                 algo_dict["partial_wakes"] = grid
     else:
         algo_dict["partial_wakes"] = wake_averaging
+
     if verbosity > 2:
         print("        --> rotor_model     :", algo_dict["rotor_model"])
         print("        --> partial_wakes   :", algo_dict["partial_wakes"])
 
+
 def _read_deflection(deflection, induction, algo_dict, verbosity):
     """Reads deflection model"""
     defl_def_map = Dict(
@@ -228,6 +239,7 @@ def _read_deflection(deflection, induction, algo_dict, verbosity):
         print("       ", algo_dict["mbook"].wake_frames[wname])
     algo_dict["wake_frame"] = wname
 
+
 def _read_analysis(wio_ana, algo_dict, verbosity):
     """Reads the windio analyses"""
     if verbosity > 2:
@@ -253,16 +265,26 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
         print("    axial induction model:", induction)
 
     # wind deficit model:
-    wind_deficit = Dict(wio_ana["wind_deficit_model"], name="wind_deficit_model")
+    wake_model_key = (
+        "wind_deficit_model" if "wind_deficit_model" in wio_ana else "wake_model"
+    )
+    wind_deficit = Dict(wio_ana[wake_model_key], name=wake_model_key)
     ka, kb, amb_ti = _read_wind_deficit(
-        wind_deficit, superposition, induction, algo_dict, verbosity
+        wake_model_key, wind_deficit, superposition, induction, algo_dict, verbosity
     )
 
     # turbulence model:
     if "turbulence_model" in wio_ana:
         turbulence_model = Dict(wio_ana["turbulence_model"], name="turbulence_model")
         _read_turbulence(
-            turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
+            turbulence_model,
+            superposition,
+            induction,
+            algo_dict,
+            ka,
+            kb,
+            amb_ti,
+            verbosity,
         )
     elif verbosity > 0:
         print("turbulence_model not found, not using a TI wake model")
@@ -273,21 +295,22 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
         _read_blockage(blockage_model, induction, algo_dict, verbosity)
     elif verbosity > 0:
         print("blockage_model not found, not using a turbine induction model")
-        
+
     # rotor_averaging:
     if "rotor_averaging" in wio_ana:
         rotor_averaging = Dict(wio_ana["rotor_averaging"], name="rotor_averaging")
         _read_rotor_averaging(rotor_averaging, algo_dict, verbosity)
     elif verbosity > 0:
         print("rotor_averaging not found, using default settings")
-        
+
     # deflection:
     if "deflection_model" in wio_ana:
         deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
         _read_deflection(deflection, induction, algo_dict, verbosity)
     elif verbosity > 0:
         print("deflection_model not found, using default settings")
-        
+
+
 def read_attributes(wio, algo_dict, verbosity):
     """
     Reads the attributes part of windio
@@ -305,6 +328,8 @@ def read_attributes(wio, algo_dict, verbosity):
     -------
     out_dicts: list of dict
         The output dictionaries
+    odir: pathlib.Path
+        Path to the output folder
 
     :group: input.windio
 
@@ -333,6 +358,6 @@ def read_attributes(wio, algo_dict, verbosity):
     out_dicts = []
     if "outputs" in wio_attrs:
         outputs = Dict(wio_attrs["outputs"], name="outputs")
-        out_dicts = read_outputs(outputs, algo_dict, verbosity)
+        out_dicts, odir = read_outputs(outputs, algo_dict, verbosity)
 
-    return out_dicts
+    return out_dicts, odir