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

foxes/core/rotor_model.py

@@ -60,6 +60,10 @@ class RotorModel(FarmDataModel):
         """
         if self.calc_vars is None:
             vrs = algo.states.output_point_vars(algo)
+            assert (
+                FV.WEIGHT not in vrs
+            ), f"Rotor '{self.name}': States '{algo.states.name}' output_point_vars contain '{FV.WEIGHT}', please remove"
+
             if FV.WS in vrs:
                 self.calc_vars = [FV.REWS] + [v for v in vrs if v != FV.WS]
             else:
@@ -72,6 +76,9 @@ class RotorModel(FarmDataModel):
 
             self.calc_vars = sorted(self.calc_vars)
 
+        if FV.WEIGHT not in self.calc_vars:
+            self.calc_vars.append(FV.WEIGHT)
+
         return self.calc_vars
 
     @abstractmethod
@@ -174,9 +181,7 @@ class RotorModel(FarmDataModel):
         elif res.shape[1] == 1:
             fdata[v][:, downwind_index] = res[:, 0]
         else:
-            raise ValueError(
-                f"Rotor model '{self.name}': downwind_index is not None, but results shape for '{v}' has more than one turbine, {res.shape}"
-            )
+            fdata[v, downwind_index] = res[:, downwind_index]
 
     def eval_rpoint_results(
         self,
@@ -184,7 +189,7 @@ class RotorModel(FarmDataModel):
         mdata,
         fdata,
         tdata,
-        weights,
+        rpoint_weights,
         downwind_index=None,
         copy_to_ambient=False,
     ):
@@ -207,7 +212,7 @@ class RotorModel(FarmDataModel):
             The farm data
         tdata: foxes.core.TData
             The target point data
-        weights: numpy.ndarray
+        rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rpoints,)
         downwind_index: int, optional
             The index in the downwind order
@@ -233,7 +238,7 @@ class RotorModel(FarmDataModel):
             wd = tdata[FV.WD]
             ws = tdata[FV.WS]
             uvp = wd2uv(wd, ws, axis=-1)
-            uv = np.einsum("stpd,p->std", uvp, weights)
+            uv = np.einsum("stpd,p->std", uvp, rpoint_weights)
 
         wd = None
         vdone = []
@@ -243,7 +248,6 @@ class RotorModel(FarmDataModel):
                     wd = uv2wd(uv, axis=-1)
                 self._set_res(fdata, v, wd, downwind_index)
                 vdone.append(v)
-
             elif v == FV.WS:
                 ws = np.linalg.norm(uv, axis=-1)
                 self._set_res(fdata, v, ws, downwind_index)
@@ -265,7 +269,7 @@ class RotorModel(FarmDataModel):
 
             for v in self.calc_vars:
                 if v == FV.REWS:
-                    rews = np.maximum(np.einsum("stp,p->st", wsp, weights), 0.0)
+                    rews = np.maximum(np.einsum("stp,p->st", wsp, rpoint_weights), 0.0)
                     self._set_res(fdata, v, rews, downwind_index)
                     del rews
                     vdone.append(v)
@@ -278,12 +282,14 @@ class RotorModel(FarmDataModel):
                     if uvp.shape[2] > 1:
                         rews2 = np.sqrt(
                             np.maximum(
-                                np.einsum("stp,p->st", np.sign(wsp) * wsp**2, weights),
+                                np.einsum(
+                                    "stp,p->st", np.sign(wsp) * wsp**2, rpoint_weights
+                                ),
                                 0.0,
                             )
                         )
                     else:
-                        rews2 = np.sqrt(np.einsum("stp,p->st", wsp**2, weights))
+                        rews2 = np.sqrt(np.einsum("stp,p->st", wsp**2, rpoint_weights))
                     self._set_res(fdata, v, rews2, downwind_index)
                     del rews2
                     vdone.append(v)
@@ -295,10 +301,12 @@ class RotorModel(FarmDataModel):
                     # turbine axis direction:
                     if uvp.shape[2] > 1:
                         rews3 = np.maximum(
-                            np.einsum("stp,p->st", wsp**3, weights), 0.0
+                            np.einsum("stp,p->st", wsp**3, rpoint_weights), 0.0
                         ) ** (1.0 / 3.0)
                     else:
-                        rews3 = (np.einsum("stp,p->st", wsp**3, weights)) ** (1.0 / 3.0)
+                        rews3 = (np.einsum("stp,p->st", wsp**3, rpoint_weights)) ** (
+                            1.0 / 3.0
+                        )
                     self._set_res(fdata, v, rews3, downwind_index)
                     del rews3
                     vdone.append(v)
@@ -307,8 +315,10 @@ class RotorModel(FarmDataModel):
         del uvp
 
         for v in self.calc_vars:
-            if v not in vdone:
-                res = np.einsum("stp,p->st", tdata[v], weights)
+            if v not in vdone and (
+                fdata[v].shape[1] > 1 or downwind_index is None or downwind_index == 0
+            ):
+                res = np.einsum("stp,p->st", tdata[v], rpoint_weights)
                 self._set_res(fdata, v, res, downwind_index)
             if copy_to_ambient and v in FV.var2amb:
                 fdata[FV.var2amb[v]] = fdata[v].copy()
@@ -319,10 +329,8 @@ class RotorModel(FarmDataModel):
         mdata,
         fdata,
         rpoints=None,
-        weights=None,
-        store_rpoints=False,
-        store_rweights=False,
-        store_amb_res=False,
+        rpoint_weights=None,
+        store=False,
         downwind_index=None,
     ):
         """
@@ -339,16 +347,11 @@ class RotorModel(FarmDataModel):
         rpoints: numpy.ndarray, optional
             The rotor points, or None for automatic for
             this rotor. Shape: (n_states, n_turbines, n_rpoints, 3)
-        weights: numpy.ndarray, optional
+        rpoint_weights: numpy.ndarray, optional
             The rotor point weights, or None for automatic
             for this rotor. Shape: (n_rpoints,)
-        store_rpoints: bool, optional
-            Switch for storing rotor points to mdata
-        store_rweights: bool, optional
-            Switch for storing rotor point weights to mdata
-        store_amb_res: bool, optional
-            Switch for storing ambient rotor point reults as they
-            come from the states to mdata
+        store: bool, optional
+            Flag for storing ambient rotor point results
         downwind_index: int, optional
             Only compute for index in the downwind order
 
@@ -364,18 +367,12 @@ class RotorModel(FarmDataModel):
             rpoints = mdata.get(
                 FC.ROTOR_POINTS, self.get_rotor_points(algo, mdata, fdata)
             )
-        if store_rpoints:
-            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
-
         if downwind_index is not None:
             rpoints = rpoints[:, downwind_index, None]
+        if rpoint_weights is None:
+            rpoint_weights = mdata.get_item(FC.TWEIGHTS, self.rotor_point_weights())
 
-        if weights is None:
-            weights = mdata.get(FC.TWEIGHTS, self.rotor_point_weights())
-        if store_rweights:
-            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, weights, mdata=mdata)
-
-        tdata = TData.from_tpoints(rpoints, weights)
+        tdata = TData.from_tpoints(rpoints, rpoint_weights)
         svars = algo.states.output_point_vars(algo)
         for v in svars:
             tdata.add(
@@ -386,16 +383,23 @@ class RotorModel(FarmDataModel):
 
         sres = algo.states.calculate(algo, mdata, fdata, tdata)
         tdata.update(sres)
+        if FV.WEIGHT not in tdata:
+            raise KeyError(
+                f"Rotor '{self.name}': States '{algo.states.name}' failed to provide '{FV.WEIGHT}' in tdata"
+            )
 
-        if store_amb_res:
-            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres.copy(), mdata=mdata)
+        if store:
+            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
+            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, rpoint_weights, mdata=mdata)
+            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres, mdata=mdata)
+            algo.add_to_chunk_store(FC.WEIGHT_RES, tdata[FV.WEIGHT], mdata=mdata)
 
         self.eval_rpoint_results(
             algo,
             mdata,
             fdata,
             tdata,
-            weights,
+            rpoint_weights,
             downwind_index,
             copy_to_ambient=True,
         )

foxes/core/states.py

@@ -43,24 +43,6 @@ class States(PointDataModel):
         """
         return list(range(self.size()))
 
-    @abstractmethod
-    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)
-
-        """
-        pass
-
     def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
         """
         Reset the states, optionally select states
@@ -106,19 +88,9 @@ class States(PointDataModel):
         if sinds is not None:
             idata["coords"][FC.STATE] = sinds
 
-        weights = self.weights(algo)
-        if len(weights.shape) != 2:
-            raise ValueError(
-                f"States '{self.name}': Wrong weights dimension, expecing ({FC.STATE}, {FC.TURBINE}), got shape {weights.shape}"
-            )
-        if weights.shape[1] != algo.n_turbines:
-            raise ValueError(
-                f"States '{self.name}': Wrong size of second axis dimension '{FC.TURBINE}': Expecting {algo.n_turbines}, got {weights.shape[1]}"
-            )
-        idata["data_vars"][FV.WEIGHT] = ((FC.STATE, FC.TURBINE), weights)
-
         return idata
 
+    @abstractmethod
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -134,7 +106,7 @@ class States(PointDataModel):
             The output variable names
 
         """
-        return [FV.WS, FV.WD, FV.TI, FV.RHO]
+        pass
 
     def __add__(self, s):
         if isinstance(s, list):
@@ -245,23 +217,6 @@ class ExtendedStates(States):
         """
         return self.states.index()
 
-    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.states.weights(algo)
-
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.

foxes/input/states/__init__.py

@@ -14,5 +14,6 @@ from .one_point_flow import (
     OnePointFlowMultiHeightTimeseries,
     OnePointFlowMultiHeightNCTimeseries,
 )
+from .wrg_states import WRGStates
 
 from . import create

foxes/input/states/field_data_nc.py

@@ -16,7 +16,6 @@ def _read_nc_file(
     fpath,
     coords,
     vars,
-    weight_var,
     nc_engine,
     sel,
     isel,
@@ -30,18 +29,7 @@ def _read_nc_file(
                 f"Missing coordinate '{c}' in file {fpath}, got: {list(data.coords.keys())}"
             )
     if minimal:
-        weights = None
-        if weight_var is not None:
-            if weight_var not in data.data_vars:
-                raise KeyError(
-                    f"Missing weight var '{weight_var}' in file {fpath}, found: {list(data.data_vars.keys())}"
-                )
-            if data[weight_var].dims != (coords[0],):
-                raise ValueError(
-                    f"Wrong dimensions for variable '{weight_var}' in file {fpath}. Expecting {(coords[0],)}, got {data[weight_var].dims}"
-                )
-            weights = data[weight_var].to_numpy()
-        return data[coords[0]].to_numpy(), weights
+        return data[coords[0]].to_numpy()
     else:
         data = data[vars]
         data.attrs = {}
@@ -175,7 +163,7 @@ class FieldDataNC(States):
         super().__init__()
 
         self.states_coord = states_coord
-        self.ovars = output_vars
+        self.ovars = list(output_vars)
         self.fixed_vars = fixed_vars
         self.x_coord = x_coord
         self.y_coord = y_coord
@@ -196,7 +184,6 @@ class FieldDataNC(States):
         self._N = None
 
         self.__data_source = data_source
-        self.__weights = None
         self.__inds = None
 
     @property
@@ -298,6 +285,18 @@ class FieldDataNC(States):
                 dtype=config.dtype_double,
             )
 
+        weights = None
+        if self.weight_ncvar is not None:
+            if self.weight_ncvar not in ds.data_vars:
+                raise KeyError(
+                    f"States '{self.name}': Missing weights variable '{self.weight_ncvar}' in data, found {sorted(list(ds.data_vars.keys()))}"
+                )
+            if ds[self.weight_ncvar].dims != (self.states_coord,):
+                raise ValueError(
+                    f"States '{self.name}': Weights variable '{self.weight_ncvar}' has wrong dimensions. Expecting {(self.states_coord,)}, got {ds[self.weight_ncvar].dims}"
+                )
+            weights = ds[self.weight_ncvar].to_numpy()
+
         if verbosity > 1:
             print(f"\n{self.name}: Data ranges")
             for v, i in self._dkys.items():
@@ -307,7 +306,7 @@ class FieldDataNC(States):
                     f"  {v}: {np.nanmin(d)} --> {np.nanmax(d)}, nans: {nn} ({100*nn/len(d.flat):.2f}%)"
                 )
 
-        return sts, h, y, x, data
+        return sts, h, y, x, data, weights
 
     def output_point_vars(self, algo):
         """
@@ -356,7 +355,9 @@ class FieldDataNC(States):
 
             # check variables:
             for v in self.ovars:
-                if v not in self.var2ncvar and v not in self.fixed_vars:
+                if v == FV.WEIGHT and self.weight_ncvar is None:
+                    pass
+                elif v not in self.var2ncvar and v not in self.fixed_vars:
                     raise ValueError(
                         f"States '{self.name}': Variable '{v}' neither found in var2ncvar not in fixed_vars"
                     )
@@ -413,7 +414,6 @@ class FieldDataNC(States):
                 _read_nc_file,
                 files,
                 coords=coords,
-                weight_var=self.weight_ncvar,
                 vars=vars,
                 nc_engine=config.nc_engine,
                 isel=self.isel,
@@ -440,23 +440,15 @@ class FieldDataNC(States):
                 )
                 if self.load_mode == "preload":
                     self.__data_source.load()
-                if self.weight_ncvar is not None:
-                    self.__weights = self.__data_source[self.weight_ncvar].to_numpy()
                 self.__inds = self.__data_source[self.states_coord].to_numpy()
                 self._N = len(self.__inds)
 
             elif self.load_mode == "fly":
-                self.__inds, weights = zip(*self.__data_source)
+                self.__inds = self.__data_source
                 self.__data_source = fpath
                 self._files_maxi = {f: len(inds) for f, inds in zip(files, self.__inds)}
                 self.__inds = np.concatenate(self.__inds, axis=0)
                 self._N = len(self.__inds)
-                if weights[0] is not None:
-                    self.__weights = np.zeros(
-                        (self._N, algo.n_turbines), dtype=config.dtype_double
-                    )
-                    self.__weights[:] = np.concatenate(weights, axis=0)[:, None]
-                    del weights
 
             else:
                 raise KeyError(
@@ -468,11 +460,6 @@ class FieldDataNC(States):
                     self.__inds, format=self.time_format
                 ).to_numpy()
 
-            if self.__weights is None:
-                self.__weights = np.full(
-                    (self._N, algo.n_turbines), 1.0 / self._N, dtype=config.dtype_double
-                )
-
         # ensure WD and WS get the first two slots of data:
         self._dkys = {}
         if FV.WS in self.ovars:
@@ -492,8 +479,11 @@ class FieldDataNC(States):
             self.H = self.var(FV.H)
             self.VARS = self.var("vars")
             self.DATA = self.var("data")
+            self.WEIGHT = self.var(FV.WEIGHT)
 
-            __, h, y, x, data = self._get_data(self.data_source, coords, verbosity)
+            __, h, y, x, data, weights = self._get_data(
+                self.data_source, coords, verbosity
+            )
             self._prl_coords = coords
 
             coos = (FC.STATE, self.H, self.Y, self.X, self.VARS)
@@ -504,6 +494,8 @@ class FieldDataNC(States):
             idata["coords"][self.X] = x
             idata["coords"][self.VARS] = list(self._dkys.keys())
             idata["data_vars"][self.DATA] = data
+            if weights is not None:
+                idata["data_vars"][self.WEIGHT] = ((FC.STATE,), weights)
 
         return idata
 
@@ -540,10 +532,9 @@ class FieldDataNC(States):
         super().set_running(algo, data_stash, sel, isel, verbosity)
 
         data_stash[self.name] = dict(
-            weights=self.__weights,
             inds=self.__inds,
         )
-        del self.__weights, self.__inds
+        del self.__inds
 
         if self.load_mode == "preload":
             data_stash[self.name]["data_source"] = self.__data_source
@@ -579,7 +570,6 @@ class FieldDataNC(States):
         super().unset_running(algo, data_stash, sel, isel, verbosity)
 
         data = data_stash[self.name]
-        self.__weights = data.pop("weights")
         self.__inds = data.pop("inds")
 
         if self.load_mode == "preload":
@@ -628,27 +618,6 @@ class FieldDataNC(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.
@@ -690,6 +659,7 @@ class FieldDataNC(States):
             y = mdata[self.Y]
             h = mdata[self.H]
             data = mdata[self.DATA].copy()
+            weights = mdata.get(self.WEIGHT, None)
             coords = self._prl_coords
 
         # case lazy:
@@ -697,7 +667,7 @@ class FieldDataNC(States):
             i0 = mdata.states_i0(counter=True)
             s = slice(i0, i0 + n_states)
             ds = self.data_source.isel({self.states_coord: s}).load()
-            __, h, y, x, data = self._get_data(ds, coords, verbosity=0)
+            __, h, y, x, data, weights = self._get_data(ds, coords, verbosity=0)
             del ds
 
         # case fly:
@@ -725,7 +695,6 @@ class FieldDataNC(States):
                             _read_nc_file(
                                 fpath,
                                 coords=coords,
-                                weight_var=self.weight_ncvar,
                                 vars=vars,
                                 nc_engine=config.nc_engine,
                                 isel=isel,
@@ -742,7 +711,7 @@ class FieldDataNC(States):
             ), f"States '{self.name}': Missing states for load_mode '{self.load_mode}': (i0, i1) = {(i0, i1)}"
 
             data = xr.concat(data, dim=self.states_coord)
-            __, h, y, x, data = self._get_data(data, coords, verbosity=0)
+            __, h, y, x, data, weights = self._get_data(data, coords, verbosity=0)
 
         else:
             raise KeyError(
@@ -858,7 +827,7 @@ class FieldDataNC(States):
             out[FV.WD] = uv2wd(uv, axis=-1)
             del uv
         for v in self.ovars:
-            if v not in out:
+            if v != FV.WEIGHT and v not in out:
                 if v in self._dkys:
                     out[v] = data[..., self._dkys[v]]
                 else:
@@ -866,4 +835,13 @@ class FieldDataNC(States):
                         (n_states, n_pts), self.fixed_vars[v], dtype=config.dtype_double
                     )
 
+        # add weights:
+        if weights is not None:
+            tdata[FV.WEIGHT] = weights[:, 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: d.reshape(n_states, n_targets, n_tpoints) for v, d in out.items()}