foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/core/data.py

@@ -7,10 +7,8 @@ import foxes.constants as FC
 
 class Data(Dict):
     """
-    Container for data and meta data.
-
-    Used during the calculation of single chunks,
-    usually for numpy data (not xarray data).
+    Container for numpy array data and
+    the associated meta data.
 
     Attributes
     ----------
@@ -53,9 +51,9 @@ class Data(Dict):
 
         self.sizes = {}
         for v, d in data.items():
-            self.__run_entry_checks(v, d, dims[v])
+            self._run_entry_checks(v, d, dims[v])
 
-        self.__auto_update()
+        self._auto_update()
 
     @property
     def n_states(self):
@@ -83,19 +81,6 @@ class Data(Dict):
         """
         return self.sizes[FC.TURBINE] if FC.TURBINE in self.sizes else None
 
-    @property
-    def n_points(self):
-        """
-        The number of points
-
-        Returns
-        -------
-        int:
-            The number of points
-
-        """
-        return self.sizes[FC.POINT] if FC.POINT in self.sizes else None
-
     def states_i0(self, counter=False, algo=None):
         """
         Get the state counter for first state in chunk
@@ -123,7 +108,8 @@ class Data(Dict):
         else:
             return self[FC.STATE][0]
 
-    def __auto_update(self):
+    def _auto_update(self):
+        """Checks and operations after data changes"""
         data = self
         dims = self.dims
 
@@ -132,25 +118,19 @@ class Data(Dict):
             and FV.X in data
             and FV.Y in data
             and FV.H in data
-            and dims[FV.X] == (FC.STATE, FC.TURBINE)
-            and dims[FV.Y] == (FC.STATE, FC.TURBINE)
-            and dims[FV.H] == (FC.STATE, FC.TURBINE)
+            and dims[FV.X] == dims[FV.Y]
+            and dims[FV.X] == dims[FV.H]
         ):
-            self[FV.TXYH] = np.zeros(
-                (self.n_states, self.n_turbines, 3), dtype=FC.DTYPE
-            )
+            self[FV.TXYH] = np.stack([self[FV.X], self[FV.Y], self[FV.H]], axis=-1)
 
-            self[FV.TXYH][:, :, 0] = self[FV.X]
-            self[FV.TXYH][:, :, 1] = self[FV.Y]
-            self[FV.TXYH][:, :, 2] = self[FV.H]
+            self[FV.X] = self[FV.TXYH][..., 0]
+            self[FV.Y] = self[FV.TXYH][..., 1]
+            self[FV.H] = self[FV.TXYH][..., 2]
 
-            self[FV.X] = self[FV.TXYH][:, :, 0]
-            self[FV.Y] = self[FV.TXYH][:, :, 1]
-            self[FV.H] = self[FV.TXYH][:, :, 2]
+            self.dims[FV.TXYH] = tuple(list(dims[FV.X]) + [FC.XYH])
 
-            self.dims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
-
-    def __run_entry_checks(self, name, data, dims):
+    def _run_entry_checks(self, name, data, dims):
+        """Run entry checks on new data"""
         # remove axes of size 1, added by dask for extra loop dimensions:
         if dims is not None:
             if len(dims) != len(data.shape):
@@ -182,8 +162,270 @@ class Data(Dict):
         """
         self[name] = data
         self.dims[name] = dims
-        self.__run_entry_checks(name, data, dims)
-        self.__auto_update()
+        self._run_entry_checks(name, data, dims)
+        self._auto_update()
+
+    def get_slice(self, s, dim_map={}, name=None, keep=True):
+        """
+        Get a slice of data.
+
+        Parameters
+        ----------
+        s: slice
+            The slice
+        dim_map: dict
+            Mapping from original to new dimensions.
+            If not found, same dimensions are assumed.
+        name: str, optional
+            The name of the data object
+        keep: bool
+            Keep non-matching fields as they are, else
+            throw them out
+
+        Returns
+        -------
+        data: Data
+            The new data object, containing slices
+
+        """
+        data = {}
+        dims = {}
+        for v in self.keys():
+            try:
+                d = self.dims[v]
+                data[v] = self[v][s]
+                dims[v] = dim_map.get(d, d)
+            except IndexError:
+                if keep:
+                    data[v] = self[v]
+                    dims[v] = self.dims[v]
+        if name is None:
+            name = self.name
+        return type(self)(data, dims, loop_dims=self.loop_dims, name=name)
+
+
+class MData(Data):
+    """
+    Container for foxes model data.
+
+    :group: core
+
+    """
+
+    def __init__(self, *args, name="mdata", **kwargs):
+        """
+        Constructor
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Arguments for the base class
+        name: str
+            The data name
+        kwargs: dict, optional
+            Arguments for the base class
+
+        """
+        super().__init__(*args, name=name, **kwargs)
+
+
+class FData(Data):
+    """
+    Container for foxes farm data.
+
+    Each farm data entry has (n_states, n_turbines) shape,
+    except the dimensions.
+
+    :group: core
+
+    """
+
+    def __init__(self, *args, name="fdata", **kwargs):
+        """
+        Constructor
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Arguments for the base class
+        name: str
+            The data name
+        kwargs: dict, optional
+            Arguments for the base class
+
+        """
+        super().__init__(*args, name=name, **kwargs)
+
+    def _run_entry_checks(self, name, data, dims):
+        """Run entry checks on new data"""
+        super()._run_entry_checks(name, data, dims)
+        data = self[name]
+        dims = self.dims[name]
+
+        if name not in self.sizes and name not in FC.TNAME:
+            dms = (FC.STATE, FC.TURBINE)
+            shp = (self.n_states, self.n_turbines)
+            if len(data.shape) < 2:
+                raise ValueError(
+                    f"FData '{self.name}': Invalid shape for '{name}', expecting {shp}, got {data.shape}"
+                )
+            if len(dims) < 2 or dims[:2] != dms:
+                raise ValueError(
+                    f"FData '{self.name}': Invalid dims for '{name}', expecting {dms}, got {dims}"
+                )
+
+    def _auto_update(self):
+        """Checks and operations after data changes"""
+        super()._auto_update()
+        if len(self):
+            for x in [FC.STATE, FC.TURBINE]:
+                if x not in self.sizes:
+                    raise KeyError(
+                        f"FData '{self.name}': Missing '{x}' in sizes, got {sorted(list(self.sizes.keys()))}"
+                    )
+
+
+class TData(Data):
+    """
+    Container for foxes target data.
+
+    Each target consists of a fixed number of
+    target points.
+
+    :group: core
+
+    """
+
+    def __init__(self, *args, name="tdata", **kwargs):
+        """
+        Constructor
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Arguments for the base class
+        name: str
+            The data name
+        kwargs: dict, optional
+            Arguments for the base class
+
+        """
+        super().__init__(*args, name=name, **kwargs)
+
+    def _run_entry_checks(self, name, data, dims):
+        """Run entry checks on new data"""
+        super()._run_entry_checks(name, data, dims)
+        data = self[name]
+        dims = self.dims[name]
+
+        if name == FC.TARGETS:
+            dms = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
+            shp = (self.n_states, self.n_targets, self.n_tpoints, 3)
+            if dims != dms:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid dims of {FC.TARGETS}, expecting {dms}, got {dims}"
+                )
+            if data.shape != shp:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid shape of {FC.TARGETS}, expecting {shp}, got {data.shape}"
+                )
+
+        elif name == FC.TWEIGHTS:
+            dms = (FC.TPOINT,)
+            shp = (self.n_tpoints,)
+            if dims != dms:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid dims of {FC.TWEIGHTS}, expecting {dms}, got {dims}"
+                )
+            if data.shape != shp:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid shape of {FC.TWEIGHTS}, expecting {shp}, got {data.shape}"
+                )
+
+        elif FC.TARGETS not in self:
+            raise KeyError(
+                f"TData '{self.name}': Missing '{FC.TARGETS}' before adding '{name}'"
+            )
+
+        elif FC.TWEIGHTS not in self:
+            raise KeyError(
+                f"TData '{self.name}': Missing '{FC.TWEIGHTS}' before adding '{name}'"
+            )
+
+        elif name not in self.sizes:
+            dms = (FC.STATE, FC.TARGET, FC.TPOINT)
+            shp = (self.n_states, self.n_targets, self.n_tpoints)
+            if len(data.shape) < 3:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid shape for '{name}', expecting {shp}, got {data.shape}"
+                )
+            if len(dims) < 3 or dims[:3] != dms:
+                raise ValueError(
+                    f"TData '{self.name}': Invalid dims for '{name}', expecting {dms}, got {dims}"
+                )
+
+    def _auto_update(self):
+        """Checks and operations after data changes"""
+        super()._auto_update()
+        if len(self):
+            for x in [FC.TARGETS, FC.TWEIGHTS]:
+                if x not in self:
+                    raise KeyError(
+                        f"TData '{self.name}': Missing '{x}' in data, got {sorted(list(self.keys()))}"
+                    )
+                if x not in self.dims:
+                    raise KeyError(
+                        f"TData '{self.name}': Missing '{x}' in dims, got {sorted(list(self.dims.keys()))}"
+                    )
+            for x in [FC.STATE, FC.TARGET, FC.TPOINT]:
+                if x not in self.sizes:
+                    raise KeyError(
+                        f"TData '{self.name}': Missing '{x}' in sizes, got {sorted(list(self.sizes.keys()))}"
+                    )
+
+    @property
+    def n_targets(self):
+        """
+        The number of targets
+
+        Returns
+        -------
+        int:
+            The number of targets
+
+        """
+        return self.sizes[FC.TARGET]
+
+    @property
+    def n_tpoints(self):
+        """
+        The number of points per target
+
+        Returns
+        -------
+        int:
+            The number of points per target
+
+        """
+        return self.sizes[FC.TPOINT]
+
+    def tpoint_mean(self, variable):
+        """
+        Take the mean over target points
+
+        Parameters
+        ----------
+        variable: str
+            The variable name
+
+        Returns
+        -------
+        data: numpy.ndarray
+            The reduced array, shape:
+            (n_states, n_targets, ...)
+
+        """
+        return np.einsum("stp...,p->st...", self[variable], self[FC.TWEIGHTS])
 
     @classmethod
     def from_points(
@@ -191,7 +433,8 @@ class Data(Dict):
         points,
         data={},
         dims={},
-        name="pdata",
+        name="tdata",
+        **kwargs,
     ):
         """
         Create from points
@@ -207,6 +450,8 @@ class Data(Dict):
             of data keys
         name: str
             The data container name
+        kwargs: dict, optional
+            Additional parameters for the constructor
 
         Returns
         -------
@@ -218,6 +463,55 @@ class Data(Dict):
             raise ValueError(
                 f"Expecting points shape (n_states, n_points, 3), got {points.shape}"
             )
-        data[FC.POINTS] = points
-        dims[FC.POINTS] = (FC.STATE, FC.POINT, FC.XYH)
-        return Data(data, dims, [FC.STATE, FC.POINT], name)
+        data[FC.TARGETS] = points[:, :, None, :]
+        dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
+        data[FC.TWEIGHTS] = np.array([1], dtype=FC.DTYPE)
+        dims[FC.TWEIGHTS] = (FC.TPOINT,)
+        return cls(data, dims, [FC.STATE, FC.TARGET], name=name, **kwargs)
+
+    @classmethod
+    def from_tpoints(
+        cls,
+        tpoints,
+        tweights,
+        data={},
+        dims={},
+        name="tdata",
+        **kwargs,
+    ):
+        """
+        Create from points at targets
+
+        Parameters
+        ----------
+        tpoints: np.ndarray
+            The points at targets, shape:
+            (n_states, n_targets, n_tpoints, 3)
+        tweights: np.ndarray, optional
+            The target point weights, shape:
+            (n_tpoints,)
+        data: dict
+            The initial data to be stored
+        dims: dict
+            The dimensions tuples, same or subset
+            of data keys
+        name: str
+            The data container name
+        kwargs: dict, optional
+            Additional parameters for the constructor
+
+        Returns
+        -------
+        pdata: Data
+            The data object
+
+        """
+        if len(tpoints.shape) != 4 or tpoints.shape[3] != 3:
+            raise ValueError(
+                f"Expecting tpoints shape (n_states, n_targets, n_tpoints, 3), got {tpoints.shape}"
+            )
+        data[FC.TARGETS] = tpoints
+        dims[FC.TARGETS] = (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH)
+        data[FC.TWEIGHTS] = tweights
+        dims[FC.TWEIGHTS] = (FC.TPOINT,)
+        return cls(data, dims, [FC.STATE], name=name, **kwargs)

foxes/core/data_calc_model.py

@@ -5,7 +5,7 @@ from dask.distributed import progress
 from dask.diagnostics import ProgressBar
 
 from .model import Model
-from .data import Data
+from .data import MData, FData, TData
 from foxes.utils.runners import DaskRunner
 import foxes.constants as FC
 import foxes.variables as FV
@@ -73,7 +73,6 @@ class DataCalcModel(Model):
         """
         Wrapper that mitigates between apply_ufunc and `calculate`.
         """
-
         n_prev = len(init_vars)
         if n_prev:
             prev = ldata[:n_prev]
@@ -81,13 +80,23 @@ class DataCalcModel(Model):
 
         # reconstruct original data:
         data = []
-        for hvars in dvars:
+        for i, hvars in enumerate(dvars):
             v2l = {v: lvars.index(v) for v in hvars if v in lvars}
             v2e = {v: evars.index(v) for v in hvars if v in evars}
 
             hdata = {v: ldata[v2l[v]] if v in v2l else edata[v2e[v]] for v in hvars}
             hdims = {v: ldims[v2l[v]] if v in v2l else edims[v2e[v]] for v in hvars}
-            data.append(Data(hdata, hdims, loop_dims))
+
+            if i == 0:
+                data.append(MData(data=hdata, dims=hdims, loop_dims=loop_dims))
+            elif i == 1:
+                data.append(FData(data=hdata, dims=hdims, loop_dims=loop_dims))
+            elif i == 2:
+                data.append(TData(data=hdata, dims=hdims, loop_dims=loop_dims))
+            else:
+                raise NotImplementedError(
+                    f"Not more than 3 data sets implemented, found {len(dvars)}"
+                )
 
             del hdata, hdims, v2l, v2e
 
@@ -102,7 +111,7 @@ class DataCalcModel(Model):
                 raise ValueError(f"Model '{self.name}': Failed to find loop dimension")
 
         # add zero output data arrays:
-        odims = {v: out_dims for v in out_vars}
+        odims = {v: tuple(out_dims) for v in out_vars}
         odata = {
             v: (
                 np.full(oshape, np.nan, dtype=FC.DTYPE)
@@ -112,35 +121,30 @@ class DataCalcModel(Model):
             for v in out_vars
             if v not in data[-1]
         }
-        if (
-            n_prev
-            and FV.TXYH not in odata
-            and FV.X in odata
-            and FV.X in odata
-            and FV.Y in odata
-            and FV.H in odata
-        ):
-            txyh = np.zeros((data[0].n_states, data[0].n_turbines, 3), dtype=FC.DTYPE)
-            txyh[..., 0] = odata[FV.X]
-            txyh[..., 1] = odata[FV.Y]
-            txyh[..., 2] = odata[FV.H]
-            odata[FV.TXYH] = txyh
-            odims[FV.TXYH] = (FC.STATE, FC.TURBINE, FC.XYH)
-            del txyh
+
         if len(data) == 1:
-            data.append(Data(odata, odims, loop_dims))
+            data.append(FData(odata, odims, loop_dims))
         else:
             odata.update(data[-1])
             odims.update(data[-1].dims)
-            data[-1] = Data(odata, odims, loop_dims)
+            if len(data) == 2:
+                data[-1] = FData(odata, odims, loop_dims)
+            else:
+                data[-1] = TData(odata, odims, loop_dims)
         del odims, odata
 
-        # link chunk state indices from mdata to fdata and pdata:
+        # link chunk state indices from mdata to fdata and tdata:
         if FC.STATE in data[0]:
             for d in data[1:]:
                 d[FC.STATE] = data[0][FC.STATE]
 
+        # link weights from mdata to fdata:
+        if FV.WEIGHT in data[0]:
+            data[1][FV.WEIGHT] = data[0][FV.WEIGHT]
+            data[1].dims[FV.WEIGHT] = data[0].dims[FV.WEIGHT]
+
         # run model calculation:
+        self.ensure_variables(algo, *data)
         results = self.calculate(algo, *data, **calc_pars)
 
         # replace missing results by first input data with matching shape:

foxes/core/farm_controller.py

@@ -16,9 +16,6 @@ class FarmController(FarmDataModel):
         The turbine type of each turbine
     turbine_model_names: list of str
         Names of all turbine models found in the farm
-    turbine_model_sels: numpy.ndarray of bool
-        Selection flags for all turbine models,
-        shape: (n_states, n_turbines, n_models)
     pre_rotor_models: foxes.core.FarmDataModelList
         The turbine models with pre-rotor flag
     post_rotor_models: foxes.core.FarmDataModelList
@@ -46,7 +43,6 @@ class FarmController(FarmDataModel):
 
         self.turbine_types = None
         self.turbine_model_names = None
-        self.turbine_model_sels = None
         self.pre_rotor_models = None
         self.post_rotor_models = None
 
@@ -223,29 +219,32 @@ class FarmController(FarmDataModel):
             algo, pre_rotor=False, models=postr_models
         )
         tmsels = tmsels_pre + tmsels_post
+        self._tmall = [np.all(t) for t in tmsels]
         self.turbine_model_names = mnames_pre + mnames_post
         if len(self.turbine_model_names):
-            self.turbine_model_sels = np.stack(tmsels, axis=2)
+            self._tmsels = np.stack(tmsels, axis=2)
         else:
             raise ValueError(f"Controller '{self.name}': No turbine model found.")
 
-    def __get_pars(self, algo, models, ptype, mdata=None, st_sel=None, from_data=True):
+    def __get_pars(self, algo, models, ptype, mdata=None, downwind_index=None):
         """
         Private helper function for gathering model parameters.
         """
-        if from_data:
-            s = mdata[FC.TMODEL_SELS]
-        else:
-            s = self.turbine_model_sels
-        if st_sel is not None:
-            s = s & st_sel[:, :, None]
-
-        pars = [
-            {"st_sel": s[:, :, self.turbine_model_names.index(m.name)]} for m in models
-        ]
-        for mi, m in enumerate(models):
+        pars = []
+        for m in models:
+            mi = self.turbine_model_names.index(m.name)
+            if self._tmall[mi]:
+                s = np.s_[:, :] if downwind_index is None else np.s_[:, downwind_index]
+            else:
+                if downwind_index is None:
+                    s = mdata[FC.TMODEL_SELS][:, :, mi]
+                else:
+                    s = np.s_[
+                        mdata[FC.TMODEL_SELS][:, downwind_index, mi], downwind_index
+                    ]
+            pars.append({"st_sel": s})
             if m.name in self.pars:
-                pars[mi].update(self.pars[m.name][ptype])
+                pars[-1].update(self.pars[m.name][ptype])
 
         return pars
 
@@ -288,11 +287,14 @@ class FarmController(FarmDataModel):
 
         """
         idata = super().load_data(algo, verbosity)
+
         idata["coords"][FC.TMODELS] = self.turbine_model_names
         idata["data_vars"][FC.TMODEL_SELS] = (
             (FC.STATE, FC.TURBINE, FC.TMODELS),
-            self.turbine_model_sels,
+            self._tmsels,
         )
+        self._tmsels = None
+
         return idata
 
     def output_farm_vars(self, algo):
@@ -317,7 +319,7 @@ class FarmController(FarmDataModel):
             )
         )
 
-    def calculate(self, algo, mdata, fdata, pre_rotor, st_sel=None):
+    def calculate(self, algo, mdata, fdata, pre_rotor, downwind_index=None):
         """ "
         The main model calculation.
 
@@ -328,16 +330,15 @@ class FarmController(FarmDataModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
         pre_rotor: bool
             Flag for running pre-rotor or post-rotor
             models
-        st_sel: numpy.ndarray of bool, optional
-            Selection of states and turbines, shape:
-            (n_states, n_turbines). None for all.
+        downwind_index: int, optional
+            The index in the downwind order
 
         Returns
         -------
@@ -347,9 +348,8 @@ class FarmController(FarmDataModel):
 
         """
         s = self.pre_rotor_models if pre_rotor else self.post_rotor_models
-        pars = self.__get_pars(algo, s.models, "calc", mdata, st_sel, from_data=True)
+        pars = self.__get_pars(algo, s.models, "calc", mdata, downwind_index)
         res = s.calculate(algo, mdata, fdata, parameters=pars)
-        self.turbine_model_sels = mdata[FC.TMODEL_SELS]
         return res
 
     def finalize(self, algo, verbosity=0):
@@ -366,4 +366,3 @@ class FarmController(FarmDataModel):
         """
         super().finalize(algo, verbosity)
         self.turbine_model_names = None
-        self.turbine_model_sels = None