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

foxes/input/states/multi_height.py

@@ -91,7 +91,7 @@ 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.var2col = var2col
@@ -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
 
 
@@ -658,30 +638,25 @@ class MultiHeightNCStates(MultiHeightStates):
             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 +680,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 +693,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,),

foxes/input/states/one_point_flow.py

@@ -101,9 +101,13 @@ class OnePointFlowStates(States):
         """
         return [self.base_states]
 
-    def initialize(self, algo, verbosity=0):
+    def load_data(self, algo, verbosity=0):
         """
-        Initializes the model.
+        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
         ----------
@@ -112,8 +116,14 @@ class OnePointFlowStates(States):
         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`
+
         """
-        super().initialize(algo, verbosity)
 
         # find heights:
         if self.heights is None:
@@ -127,10 +137,14 @@ class OnePointFlowStates(States):
                 )
 
         # pre-calc data:
-        Timelines._precalc_data(
+        self.WEIGHT = self.var(FV.WEIGHT)
+        idata = super().load_data(algo, verbosity)
+        idata["data_vars"][self.WEIGHT] = Timelines._precalc_data(
             self, algo, self.base_states, self.heights, verbosity, needs_res=True
         )
 
+        return idata
+
     def size(self):
         """
         The total number of states.
@@ -172,23 +186,6 @@ class OnePointFlowStates(States):
         """
         return self.base_states.output_point_vars(algo)
 
-    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)
-
-        """
-        return self.base_states.weights(algo)
-
     def set_running(
         self,
         algo,
@@ -488,6 +485,10 @@ class OnePointFlowStates(States):
                     results = {FV.WD: uv2wd(uv), FV.WS: np.linalg.norm(uv, axis=-1)}
                     del uv
 
+        # set weights:
+        tdata[FV.WEIGHT] = mdata[self.WEIGHT][:, None, None]
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {
             v: d.reshape(n_states, n_targets, n_tpoints) for v, d in results.items()
         }

foxes/input/states/scan.py

@@ -176,25 +176,6 @@ class ScanStates(States):
         """
         return self._vars
 
-    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)
-
-        """
-        return np.full(
-            (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
-        )
-
     def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -226,4 +207,10 @@ class ScanStates(States):
                 tdata[v] = np.zeros_like(tdata[FC.TARGETS][..., 0])
             tdata[v][:] = mdata[self.DATA][:, None, None, i]
 
+        # add weights:
+        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: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/single.py

@@ -157,23 +157,6 @@ class SingleStateStates(States):
 
         return list(out)
 
-    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)
-
-        """
-        return np.ones((1, algo.n_turbines), dtype=config.dtype_double)
-
     def calculate(self, algo, mdata, fdata, tdata):
         """
         The main model calculation.
@@ -233,4 +216,9 @@ class SingleStateStates(States):
                 pres = p.calculate(tdata, z)
                 tdata[v] = pres
 
+        tdata[FV.WEIGHT] = np.full(
+            (mdata.n_states, 1, 1), 1.0, dtype=config.dtype_double
+        )
+        tdata.dims[FV.WEIGHT] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
         return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/input/states/states_table.py

@@ -82,7 +82,7 @@ class StatesTable(States):
         """
         super().__init__()
 
-        self.ovars = output_vars
+        self.ovars = list(output_vars)
         self.rpars = pd_read_pars
         self.var2col = var2col
         self.fixed_vars = fixed_vars
@@ -98,9 +98,7 @@ class StatesTable(States):
         self._N = None
         self._tvars = None
         self._profiles = None
-
         self._data_source = data_source
-        self.__weights = None
 
     @property
     def data_source(self):
@@ -210,10 +208,10 @@ class StatesTable(States):
         """
         self.VARS = self.var("vars")
         self.DATA = self.var("data")
+        self.WEIGHT = self.var(FV.WEIGHT)
 
         if isinstance(self.data_source, pd.DataFrame):
             data = self.data_source
-            isorg = True
         else:
             self._data_source = get_input_path(self.data_source)
             if not self.data_source.is_file():
@@ -230,7 +228,6 @@ class StatesTable(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
 
         if self.states_sel is not None:
             data = data.iloc[self.states_sel]
@@ -240,18 +237,13 @@ class StatesTable(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]
 
         tcols = []
         for v in self._tvars:
@@ -267,6 +259,8 @@ class StatesTable(States):
         idata = super().load_data(algo, verbosity)
         idata["coords"][self.VARS] = self._tvars
         idata["data_vars"][self.DATA] = ((FC.STATE, self.VARS), data.to_numpy())
+        if weights is not None:
+            idata["data_vars"][self.WEIGHT] = (FC.STATE, weights)
 
         return idata
 
@@ -313,27 +307,6 @@ class StatesTable(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 set_running(
         self,
         algo,
@@ -368,10 +341,9 @@ class StatesTable(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,
@@ -404,7 +376,6 @@ class StatesTable(States):
 
         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):
@@ -455,6 +426,14 @@ class StatesTable(States):
         for v, p in self._profiles.items():
             tdata[v] = p.calculate(tdata, z)
 
+        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 {v: tdata[v] for v in self.output_point_vars(algo)}
 
     def finalize(self, algo, verbosity=0):
@@ -469,7 +448,6 @@ class StatesTable(States):
             The verbosity level
 
         """
-        self.__weights = None
         self._N = None
         self._tvars = None