foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/core/model.py

@@ -1,10 +1,8 @@
 import numpy as np
 from abc import ABC
 from itertools import count
-from copy import deepcopy
 
 import foxes.constants as FC
-from .data import Data
 
 
 class Model(ABC):
@@ -35,8 +33,8 @@ class Model(ABC):
         if self._id > 0:
             self.name += f"_instance{self._id}"
 
-        self._store = {}
         self.__initialized = False
+        self.__running = False
 
     def __repr__(self):
         return f"{type(self).__name__}()"
@@ -119,6 +117,10 @@ class Model(ABC):
             and `coords`, a dict with entries `dim_name_str -> dim_array`
 
         """
+        if self.initialized:
+            raise ValueError(
+                f"Model '{self.name}': Cannot call load_data after initialization"
+            )
         return {"coords": {}, "data_vars": {}}
 
     def initialize(self, algo, verbosity=0, force=False):
@@ -135,6 +137,8 @@ class Model(ABC):
             Overwrite existing data
 
         """
+        if self.running:
+            raise ValueError(f"Model '{self.name}': Cannot initialize while running")
         if not self.initialized:
             pr = False
             for m in self.sub_models():
@@ -152,6 +156,103 @@ class Model(ABC):
 
             self.__initialized = True
 
+    @property
+    def running(self):
+        """
+        Flag for currently running models
+
+        Returns
+        -------
+        flag: bool
+            True if currently running
+
+        """
+        return self.__running
+
+    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
+
+        """
+        if self.running:
+            raise ValueError(
+                f"Model '{self.name}': Cannot call set_running while running"
+            )
+        for m in self.sub_models():
+            if not m.running:
+                m.set_running(algo, data_stash, sel, isel, verbosity=verbosity)
+
+        if verbosity > 0:
+            print(f"Model '{self.name}': running")
+        if self.name not in data_stash:
+            data_stash[self.name] = {}
+
+        self.__running = True
+
+    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
+
+        """
+        if not self.running:
+            raise ValueError(
+                f"Model '{self.name}': Cannot call unset_running when not running"
+            )
+        for m in self.sub_models():
+            if m.running:
+                m.unset_running(algo, data_stash, sel, isel, verbosity=verbosity)
+
+        if verbosity > 0:
+            print(f"Model '{self.name}': not running")
+        self.__running = False
+
     def finalize(self, algo, verbosity=0):
         """
         Finalizes the model.
@@ -164,6 +265,8 @@ class Model(ABC):
             The verbosity level, 0 = silent
 
         """
+        if self.running:
+            raise ValueError(f"Model '{self.name}': Cannot finalize while running")
         if self.initialized:
             pr = False
             for m in self.sub_models():
@@ -178,7 +281,6 @@ class Model(ABC):
                 print(f"Finalizing model '{self.name}'")
             algo.del_model_data(self)
 
-            self._store = {}
             self.__initialized = False
 
     def get_data(
@@ -194,6 +296,7 @@ class Model(ABC):
         accept_nan=True,
         algo=None,
         upcast=False,
+        selection=None,
     ):
         """
         Getter for a data entry in the model object
@@ -233,6 +336,9 @@ class Model(ABC):
         upcast: bool
             Flag for ensuring targets dimension,
             otherwise dimension 1 is entered
+        selection: numpy.ndarray, optional
+            Apply this selection to the result,
+            state-turbine, state-target, or state-target-tpoint
 
         """
 
@@ -241,7 +347,7 @@ class Model(ABC):
             for s in sources:
                 try:
                     if a == "states_i0":
-                        out = s.states_i0(counter=True, algo=algo)
+                        out = s.states_i0(counter=True)
                         if out is not None:
                             return out
                     else:
@@ -256,6 +362,10 @@ class Model(ABC):
 
         n_states = _geta("n_states")
         if target == FC.STATE_TURBINE:
+            if downwind_index is not None:
+                raise ValueError(
+                    f"Target '{target}' is incompatible with downwind_index (here {downwind_index})"
+                )
             n_turbines = _geta("n_turbines")
             dims = (FC.STATE, FC.TURBINE)
             shp = (n_states, n_turbines)
@@ -273,42 +383,49 @@ class Model(ABC):
                 f"Model '{self.name}': Wrong parameter 'target = {target}'. Choices: {FC.STATE_TURBINE}, {FC.STATE_TARGET}, {FC.STATE_TARGET_TPOINT}"
             )
 
+        def _match_shape(a):
+            out = np.asarray(a)
+            if len(out.shape) < len(shp):
+                for i, s in enumerate(shp):
+                    if i >= len(out.shape):
+                        out = out[..., None]
+                    elif a.shape[i] not in (1, s):
+                        raise ValueError(
+                            f"Shape mismatch for '{variable}': Got {out.shape}, expecting {shp}"
+                        )
+            elif len(out.shape) > len(shp):
+                raise ValueError(
+                    f"Shape mismatch for '{variable}': Got {out.shape}, expecting {shp}"
+                )
+            return out
+
+        def _filter_dims(source):
+            a = source[variable]
+            a_dims = tuple(source.dims[variable])
+            if downwind_index is None or FC.TURBINE not in a_dims:
+                d = a_dims
+            else:
+                slc = tuple(
+                    [downwind_index if dd == FC.TURBINE else np.s_[:] for dd in a_dims]
+                )
+                a = a[slc]
+                d = tuple([dd for dd in a_dims if dd != FC.TURBINE])
+            return a, d
+
         out = None
-        out_dims = None
         for s in lookup:
             # lookup self:
             if s == "s" and hasattr(self, variable):
                 a = getattr(self, variable)
                 if a is not None:
-                    if not upcast:
-                        out = a
-                        out_dims = None
-                    elif target == FC.STATE_TURBINE:
-                        out = np.full((n_states, n_turbines), np.nan, dtype=FC.DTYPE)
-                        out[:] = a
-                        out_dims = (FC.STATE, FC.TURBINE)
-                    elif target == FC.STATE_TARGET:
-                        out = np.full((n_states, n_targets), np.nan, dtype=FC.DTYPE)
-                        out[:] = a
-                        out_dims = (FC.STATE, FC.TARGET)
-                    elif target == FC.STATE_TARGET_TPOINT:
-                        out = np.full(
-                            (n_states, n_targets, n_tpoints), np.nan, dtype=FC.DTYPE
-                        )
-                        out[:] = a
-                        out_dims = (FC.STATE, FC.TARGET, FC.TPOINT)
-                    else:
-                        raise NotImplementedError
+                    out = _match_shape(a)
 
             # lookup mdata:
-            elif (
-                s == "m"
-                and mdata is not None
-                and variable in mdata
-                and tuple(mdata.dims[variable]) == dims
-            ):
-                out = mdata[variable]
-                out_dims = dims
+            elif s == "m" and mdata is not None and variable in mdata:
+                a, d = _filter_dims(mdata)
+                l = len(d)
+                if l <= len(dims) and d == dims[:l]:
+                    out = _match_shape(mdata[variable])
 
             # lookup fdata:
             elif (
@@ -317,18 +434,22 @@ class Model(ABC):
                 and variable in fdata
                 and tuple(fdata.dims[variable]) == (FC.STATE, FC.TURBINE)
             ):
-                out = fdata[variable]
-                out_dims = (FC.STATE, FC.TURBINE)
+                if target == FC.STATE_TURBINE:
+                    out = fdata[variable]
+                elif downwind_index is not None:
+                    out = _match_shape(fdata[variable][:, downwind_index])
 
             # lookup pdata:
             elif (
                 s == "t"
+                and target != FC.STATE_TURBINE
                 and tdata is not None
                 and variable in tdata
-                and tuple(tdata.dims[variable]) == (FC.STATE, FC.TARGET, FC.TPOINT)
             ):
-                out = tdata[variable]
-                out_dims = (FC.STATE, FC.TARGET, FC.TPOINT)
+                a, d = _filter_dims(tdata)
+                l = len(d)
+                if l <= len(dims) and d == dims[:l]:
+                    out = _match_shape(tdata[variable])
 
             # lookup wake modelling data:
             elif (
@@ -340,78 +461,27 @@ class Model(ABC):
                 and downwind_index is not None
                 and algo is not None
             ):
-                out, out_dims = algo.wake_frame.get_wake_modelling_data(
-                    algo,
-                    variable,
-                    downwind_index,
-                    fdata,
-                    tdata=tdata,
-                    target=target,
-                    upcast=upcast,
+                out = _match_shape(
+                    algo.wake_frame.get_wake_modelling_data(
+                        algo,
+                        variable,
+                        downwind_index,
+                        fdata,
+                        tdata=tdata,
+                        target=target,
+                    )
                 )
 
             if out is not None:
                 break
 
-        # cast dimensions:
-        if out_dims != dims:
-            if out_dims is None:
-                if upcast:
-                    out0 = out
-                    out = np.zeros(shp, dtype=FC.DTYPE)
-                    out[:] = out0
-                    out_dims = dims
-                    del out0
-                else:
-                    out_dims = tuple([1 for _ in dims])
-
-            elif out_dims == (FC.STATE, FC.TURBINE):
-                if downwind_index is None:
-                    raise KeyError(
-                        f"Require downwind_index for target {target} and out dims {out_dims}"
-                    )
-                out0 = out[:, downwind_index, None]
-                if len(dims) == 3:
-                    out0 = out0[:, :, None]
-                if upcast:
-                    out = np.zeros(shp, dtype=FC.DTYPE)
-                    out[:] = out0
-                    out_dims = dims
-                else:
-                    out = out0
-                    out_dims = (FC.STATE, 1) if len(dims) == 2 else (FC.STATE, 1, 1)
-                del out0
-
-            elif out_dims == (FC.STATE, 1):
-                out0 = out
-                if len(dims) == 3:
-                    out0 = out0[:, :, None]
-                    out_dims = (FC.STATE, 1, 1)
-                if upcast:
-                    out = np.zeros(shp, dtype=FC.DTYPE)
-                    out[:] = out0
-                    out_dims = dims
-                else:
-                    out = out0
-                del out0
-
-            elif out_dims == (FC.STATE, 1, 1):
-                out0 = out
-                if len(dims) == 2:
-                    out0 = out0[:, :, 0]
-                    out_dims = (FC.STATE, 1)
-                if upcast:
-                    out = np.zeros(shp, dtype=FC.DTYPE)
-                    out[:] = out0
-                    out_dims = dims
-                else:
-                    out = out0
-                del out0
-
-            else:
-                raise NotImplementedError(
-                    f"No casting implemented for target {target} and out dims {out_dims} fo upcast {upcast}"
+        # check for None:
+        if out is None:
+            if not accept_none:
+                raise ValueError(
+                    f"Model '{self.name}': Variable '{variable}' is requested but not found."
                 )
+            return out
 
         # data from other chunks, only with iterations:
         if (
@@ -421,10 +491,14 @@ class Model(ABC):
             and tdata is not None
             and FC.STATES_SEL in tdata
         ):
-            if out_dims != dims:
-                raise ValueError(
-                    f"Model '{self.name}': Iteration data found for variable '{variable}', but missing upcast: out_dims = {out_dims}, expecting {dims}"
-                )
+            if out.shape != shp:
+                # upcast to dims:
+                tmp = np.zeros(shp, dtype=out.dtype)
+                tmp[:] = out
+                out = tmp
+                del tmp
+            else:
+                out = out.copy()
             if downwind_index is None:
                 raise KeyError(
                     f"Model '{self.name}': Require downwind_index for obtaining results from previous iteration"
@@ -438,7 +512,12 @@ class Model(ABC):
                     f"Model '{self.name}': Iteration data found for variable '{variable}', requiring algo"
                 )
 
-            i0 = _geta("states_i0")
+            from foxes.algorithms.sequential import Sequential
+
+            if isinstance(algo, Sequential):
+                i0 = algo.states.counter
+            else:
+                i0 = _geta("states_i0")
             sts = tdata[FC.STATES_SEL]
             if target == FC.STATE_TARGET and tdata.n_tpoints != 1:
                 # find the mean index and round it to nearest integer:
@@ -446,27 +525,31 @@ class Model(ABC):
                 sts = (sts + 0.5).astype(FC.ITYPE)
             sel = sts < i0
             if np.any(sel):
-                if not hasattr(algo, "prev_farm_results"):
+                if not hasattr(algo, "farm_results_downwind"):
                     raise KeyError(
                         f"Model '{self.name}': Iteration data found for variable '{variable}', requiring iterative algorithm"
                     )
-                prev_fres = getattr(algo, "prev_farm_results")
+                prev_fres = getattr(algo, "farm_results_downwind")
                 if prev_fres is not None:
                     prev_data = prev_fres[variable].to_numpy()[sts[sel], downwind_index]
                     if target == FC.STATE_TARGET:
                         out[sel[:, :, 0]] = prev_data
                     else:
                         out[sel] = prev_data
-                    del prev_fres, prev_data
-
-        # check for None:
-        if not accept_none and out is None:
-            raise ValueError(
-                f"Model '{self.name}': Variable '{variable}' is requested but not found."
-            )
+                    del prev_data
+                del prev_fres
+            if np.any(~sel):
+                sts = sts[~sel] - i0
+                sel_data = fdata[variable][sts, downwind_index]
+                if target == FC.STATE_TARGET:
+                    out[~sel[:, :, 0]] = sel_data
+                else:
+                    out[~sel] = sel_data
+                del sel_data
+            del sel, sts
 
         # check for nan:
-        elif not accept_nan:
+        if not accept_nan:
             try:
                 if np.all(np.isnan(np.atleast_1d(out))):
                     raise ValueError(
@@ -475,68 +558,52 @@ class Model(ABC):
             except TypeError:
                 pass
 
-        return out
-
-    def data_to_store(self, name, algo, data):
-        """
-        Adds data from mdata to the local store, intended
-        for iterative runs.
-
-        Parameters
-        ----------
-        name: str
-            The data name
-        algo: foxes.core.Algorithm
-            The algorithm
-        data: foxes.utils.Data
-            The mdata, fdata or pdata object
-
-        """
-        i0 = data.states_i0(counter=True, algo=algo)
-        if i0 not in self._store:
-            self._store[i0] = Data(
-                data={}, dims={}, loop_dims=data.loop_dims, name=f"{self.name}_{i0}"
-            )
-
-        self._store[i0][name] = deepcopy(data[name])
-        self._store[i0].dims[name] = (
-            deepcopy(data.dims[name]) if name in data.dims else None
-        )
-
-    def from_data_or_store(self, name, algo, data, ret_dims=False, safe=False):
-        """
-        Get data from mdata or local store
-
-        Parameters
-        ----------
-        name: str
-            The data name
-        algo: foxes.core.Algorithm
-            The algorithm
-        data: foxes.utils.Data
-            The mdata, fdata or pdata object
-        ret_dims: bool
-            Return dimensions
-        safe: bool
-            Return None instead of error if
-            not found
-
-        Returns
-        -------
-        data: numpy.ndarray
-            The data
-        dims: tuple of dims, optional
-            The data dimensions
+        # apply selection:
+        if selection is not None:
+
+            def _upcast_sel(sel_shape):
+                chp = []
+                for i, s in enumerate(out.shape):
+                    if i < len(sel_shape) and sel_shape[i] > 1:
+                        if sel_shape[i] != shp[i]:
+                            raise ValueError(
+                                f"Incompatible selection shape {sel_shape} for output shape {shp[i]}"
+                            )
+                        chp.append(shp[i])
+                    else:
+                        chp.append(s)
+                chp = tuple(chp)
+                eshp = list(shp[len(sel_shape) :])
+                if chp != out.shape:
+                    nout = np.zeros(chp, dtype=out.dtype)
+                    nout[:] = out
+                    return nout, eshp
+                return out, eshp
+
+            if isinstance(selection, np.ndarray) and selection.dtype == bool:
+                if len(selection.shape) > len(out.shape):
+                    raise ValueError(
+                        f"Expecting selection of shape {out.shape}, got {selection.shape}"
+                    )
+                out, eshp = _upcast_sel(selection.shape)
+            elif isinstance(selection, (tuple, list)):
+                if len(selection) > len(out.shape):
+                    raise ValueError(
+                        f"Selection is tuple/list of length {len(selection)}, expecting <= {len(out.shape)} "
+                    )
+                out, eshp = _upcast_sel(shp[: len(selection)])
+            else:
+                raise TypeError(
+                    f"Expecting selection of type np.ndarray (bool), or tuple, or list. Got {type(selection).__name__}"
+                )
+            out = out[selection]
+            shp = tuple([len(out)] + list(eshp))
 
-        """
-        if name in data:
-            return (data[name], data.dims[name]) if ret_dims else data[name]
+        # apply upcast:
+        if upcast and out.shape != shp:
+            tmp = np.zeros(shp, dtype=out.dtype)
+            tmp[:] = out
+            out = tmp
+            del tmp
 
-        i0 = data.states_i0(counter=True, algo=algo)
-        if not safe or (i0 in self._store and name in self._store[i0]):
-            if ret_dims:
-                return self._store[i0][name], self._store[i0].dims[name]
-            else:
-                return self._store[i0][name]
-        else:
-            return (None, None) if ret_dims else None
+        return out

foxes/core/partial_wakes_model.py

@@ -121,7 +121,7 @@ class PartialWakesModel(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_deltas: dict
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape

foxes/core/point_data_model.py

@@ -27,6 +27,18 @@ class PointDataModel(DataCalcModel):
         """
         return []
 
+    def output_coords(self):
+        """
+        Gets the coordinates of all output arrays
+
+        Returns
+        -------
+        dims: tuple of str
+            The coordinates of all output arrays
+
+        """
+        return (FC.STATE, FC.TARGET, FC.TPOINT)
+
     def ensure_variables(self, algo, mdata, fdata, tdata):
         """
         Add variables to tdata, initialized with NaN
@@ -54,7 +66,7 @@ class PointDataModel(DataCalcModel):
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -158,6 +170,9 @@ class PointDataModelList(PointDataModel):
         super().__init__()
         self.models = models
 
+    def __repr__(self):
+        return f"{type(self).__name__}({[m.name for m in self.models]})"
+
     def append(self, model):
         """
         Add a model to the list
@@ -203,7 +218,7 @@ class PointDataModelList(PointDataModel):
         return list(dict.fromkeys(ovars))
 
     def calculate(self, algo, mdata, fdata, tdata, parameters=None):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,