foxes 0.8.1__py3-none-any.whl → 1.0__py3-none-any.whl

foxes/input/states/multi_height.py

@@ -61,7 +61,7 @@ class MultiHeightStates(States):
         pd_read_pars={},
         states_sel=None,
         states_loc=None,
-        ipars={},
+        **ipars,
     ):
         """
         Constructor.
@@ -91,7 +91,6 @@ class MultiHeightStates(States):
         """
         super().__init__()
 
-        self.data_source = data_source
         self.ovars = output_vars
         self.heights = np.array(heights, dtype=FC.DTYPE)
         self.rpars = pd_read_pars
@@ -101,10 +100,34 @@ class MultiHeightStates(States):
         self.states_sel = states_sel
         self.states_loc = states_loc
 
+        self._data_source = data_source
         self._solo = None
         self._weights = None
+        self._inds = None
         self._N = None
 
+    def __repr__(self):
+        berr = self.ipars.get("bounds_error", False)
+        ssel = "" if self.states_sel is None else f"n_states={len(self.states_sel)}, "
+        return f"{type(self).__name__}({ssel}bounds_error={berr})"
+
+    @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
@@ -180,7 +203,7 @@ class MultiHeightStates(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:
@@ -251,6 +274,79 @@ class MultiHeightStates(States):
 
         return idata
 
+    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 size(self):
         """
         The total number of states.
@@ -273,6 +369,8 @@ class MultiHeightStates(States):
             The index labels of states, or None for default integers
 
         """
+        if self.running:
+            raise ValueError(f"States '{self.name}': Cannot acces index while running")
         return self._inds
 
     def output_point_vars(self, algo):
@@ -307,6 +405,10 @@ class MultiHeightStates(States):
             The weights, shape: (n_states, n_turbines)
 
         """
+        if self.running:
+            raise ValueError(
+                f"States '{self.name}': Cannot acces weights while running"
+            )
         return self._weights
 
     def calculate(self, algo, mdata, fdata, tdata):
@@ -346,10 +448,21 @@ class MultiHeightStates(States):
 
         coeffs = np.zeros((n_h, n_h), dtype=FC.DTYPE)
         np.fill_diagonal(coeffs, 1.0)
-        ipars = dict(assume_sorted=True, bounds_error=True)
+        ipars = dict(
+            assume_sorted=True,
+            bounds_error=True,
+            fill_value=(coeffs[0], coeffs[-1]),
+        )
         ipars.update(self.ipars)
         intp = interp1d(h, coeffs, axis=0, **ipars)
-        ires = intp(z)
+        try:
+            ires = intp(z)
+        except ValueError as e:
+            if ipars["bounds_error"]:
+                print(
+                    f"{self.name}: Interpolation height out of bounds. Select 'bounds_error=False' for replacement by lowest or largest height"
+                )
+            raise e
         del coeffs, intp
 
         has_wd = FV.WD in vrs
@@ -481,11 +594,7 @@ class MultiHeightNCStates(MultiHeightStates):
         self.heights = heights
         self.h_coord = h_coord
         self.xr_read_pars = xr_read_pars
-
-        if format_times_func == "default":
-            self.format_times_func = lambda t: t.astype("datetime64[ns]")
-        else:
-            self.format_times_func = format_times_func
+        self._format_times_func = format_times_func
 
     def load_data(self, algo, verbosity=0):
         """
@@ -516,7 +625,7 @@ class MultiHeightNCStates(MultiHeightStates):
                     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:
@@ -534,8 +643,13 @@ class MultiHeightNCStates(MultiHeightStates):
 
         self._N = data.sizes[self.state_coord]
         self._inds = data.coords[self.state_coord].to_numpy()
-        if self.format_times_func is not None:
-            self._inds = self.format_times_func(self._inds)
+
+        if self._format_times_func == "default":
+            format_times_func = lambda t: 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=FC.DTYPE)