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

foxes/core/algorithm.py

@@ -1,11 +1,14 @@
 import numpy as np
 import xarray as xr
+from abc import abstractmethod
 
 from .model import Model
 from foxes.data import StaticData
 from foxes.utils import Dict, all_subclasses
 import foxes.constants as FC
 
+from .engine import Engine
+
 
 class Algorithm(Model):
     """
@@ -17,23 +20,22 @@ class Algorithm(Model):
 
     Attributes
     ----------
-    mbook: foxes.models.ModelBook
-        The model book
-    farm: foxes.WindFarm
-        The wind farm
-    chunks: dict
-        The chunks choice for running in parallel with dask,
-        e.g. `{"state": 1000}` for chunks of 1000 states
     verbosity: int
         The verbosity level, 0 means silent
-    dbook: foxes.DataBook
-        The data book, or None for default
 
     :group: core
 
     """
 
-    def __init__(self, mbook, farm, chunks, verbosity, dbook=None):
+    def __init__(
+        self,
+        mbook,
+        farm,
+        verbosity=1,
+        dbook=None,
+        engine=None,
+        **engine_pars,
+    ):
         """
         Constructor.
 
@@ -43,149 +45,84 @@ class Algorithm(Model):
             The model book
         farm: foxes.WindFarm
             The wind farm
-        chunks: dict
-            The chunks choice for running in parallel with dask,
-            e.g. `{"state": 1000}` for chunks of 1000 states
         verbosity: int
             The verbosity level, 0 means silent
         dbook: foxes.DataBook, optional
             The data book, or None for default
+        engine: str
+            The engine class name
+        engine_pars: dict, optional
+            Parameters for the engine constructor
 
         """
         super().__init__()
 
         self.name = type(self).__name__
-        self.mbook = mbook
-        self.farm = farm
-        self.chunks = chunks
         self.verbosity = verbosity
         self.n_states = None
         self.n_turbines = farm.n_turbines
-        self.dbook = StaticData() if dbook is None else dbook
-
-        if chunks is not None and FC.TARGET not in chunks:
-            self.chunks[FC.TARGET] = chunks.get(FC.POINT, None)
 
-        self._idata_mem = Dict()
+        self.__farm = farm
+        self.__mbook = mbook
+        self.__dbook = StaticData() if dbook is None else dbook
+        self.__idata_mem = Dict(name="idata_mem")
+        self.__chunk_store = Dict(name="chunk_store")
+
+        if engine is not None:
+            e = Engine.new(engine_type=engine, verbosity=verbosity, **engine_pars)
+            self.print(f"Algorithm '{self.name}': Selecting engine '{e}'")
+            e.initialize()
+        elif len(engine_pars):
+            self.print(
+                f"Algorithm '{self.name}': Parameter 'engine' is None; ignoring engine parameters {engine_pars}"
+            )
 
-    def print(self, *args, vlim=1, **kwargs):
+    @property
+    def farm(self):
         """
-        Print function, based on verbosity.
+        The wind farm
 
-        Parameters
-        ----------
-        args: tuple, optional
-            Arguments for the print function
-        kwargs: dict, optional
-            Keyword arguments for the print function
-        vlim: int
-            The verbosity limit
+        Returns
+        -------
+        mb: foxes.core.WindFarm
+            The wind farm
 
         """
-        if self.verbosity >= vlim:
-            print(*args, **kwargs)
+        return self.__farm
 
-    def __get_sizes(self, idata, mtype):
-        """
-        Private helper function
+    @property
+    def mbook(self):
         """
+        The model book
 
-        sizes = {}
-        for v, t in idata["data_vars"].items():
-            if not isinstance(t, tuple) or len(t) != 2:
-                raise ValueError(
-                    f"Input {mtype} data entry '{v}': Not a tuple of size 2, got '{t}'"
-                )
-            if not isinstance(t[0], tuple):
-                raise ValueError(
-                    f"Input {mtype} data entry '{v}': First tuple entry not a dimensions tuple, got '{t[0]}'"
-                )
-            for c in t[0]:
-                if not isinstance(c, str):
-                    raise ValueError(
-                        f"Input {mtype} data entry '{v}': First tuple entry not a dimensions tuple, got '{t[0]}'"
-                    )
-            if not isinstance(t[1], np.ndarray):
-                raise ValueError(
-                    f"Input {mtype} data entry '{v}': Second entry is not a numpy array, got: {type(t[1]).__name__}"
-                )
-            if len(t[1].shape) != len(t[0]):
-                raise ValueError(
-                    f"Input {mtype} data entry '{v}': Wrong data shape, expecting {len(t[0])} dimensions, got {t[1].shape}"
-                )
-            if FC.STATE in t[0]:
-                if t[0][0] != FC.STATE:
-                    raise ValueError(
-                        f"Input {mtype} data entry '{v}': Dimension '{FC.STATE}' not at first position, got {t[0]}"
-                    )
-                if FC.TURBINE in t[0]:
-                    if t[0][1] != FC.TURBINE:
-                        raise ValueError(
-                            f"Input {mtype} data entry '{v}': Dimension '{FC.TURBINE}' not at second position, got {t[0]}"
-                        )
-                if FC.TARGET in t[0]:
-                    if t[0][1] != FC.TARGET:
-                        raise ValueError(
-                            f"Input {mtype} data entry '{v}': Dimension '{FC.TARGET}' not at second position, got {t[0]}"
-                        )
-                    if len(t[0]) < 3 or t[0][2] != FC.TPOINT:
-                        raise KeyError(
-                            f"Input {mtype} data entry '{v}': Expecting dimension '{FC.TPOINT}' as third entry. Got {t[0]}"
-                        )
-            elif FC.TURBINE in t[0]:
-                raise ValueError(
-                    f"Input {mtype} data entry '{v}': Dimension '{FC.TURBINE}' requires combination with dimension '{FC.STATE}'"
-                )
-            for d, s in zip(t[0], t[1].shape):
-                if d not in sizes:
-                    sizes[d] = s
-                elif sizes[d] != s:
-                    raise ValueError(
-                        f"Input {mtype} data entry '{v}': Dimension '{d}' has wrong size, expecting {sizes[d]}, got {s}"
-                    )
-        for v, c in idata["coords"].items():
-            if v not in sizes:
-                raise KeyError(
-                    f"Input coords entry '{v}': Not used in farm data, found {sorted(list(sizes.keys()))}"
-                )
-            elif len(c) != sizes[v]:
-                raise ValueError(
-                    f"Input coords entry '{v}': Wrong coordinate size for '{v}': Expecting {sizes[v]}, got {len(c)}"
-                )
-
-        return sizes
+        Returns
+        -------
+        mb: foxes.models.ModelBook()
+            The model book
 
-    def __get_xrdata(self, idata, sizes):
-        """
-        Private helper function
         """
-        xrdata = xr.Dataset(**idata)
-        if self.chunks is not None:
-            if FC.TURBINE in self.chunks.keys():
-                raise ValueError(
-                    f"Dimension '{FC.TURBINE}' cannot be chunked, got chunks {self.chunks}"
-                )
-            if FC.TPOINT in self.chunks.keys():
-                raise ValueError(
-                    f"Dimension '{FC.TPOINT}' cannot be chunked, got chunks {self.chunks}"
-                )
-            xrdata = xrdata.chunk(
-                chunks={c: v for c, v in self.chunks.items() if c in sizes}
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot access mbook while running"
             )
-        return xrdata
-
-    def chunked(self, ds):
-        return (
-            ds.chunk(chunks={c: v for c, v in self.chunks.items() if c in ds.coords})
-            if self.chunks is not None
-            else ds
-        )
+        return self.__mbook
 
-    def initialize(self):
+    @property
+    def dbook(self):
         """
-        Initializes the algorithm.
+        The data book
+
+        Returns
+        -------
+        mb: foxes.data.StaticData()
+            The data book
+
         """
-        super().initialize(self, self.verbosity)
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot access dbook while running"
+            )
+        return self.__dbook
 
     @property
     def idata_mem(self):
@@ -198,7 +135,51 @@ class Algorithm(Model):
             Keys: model name, value: idata dict
 
         """
-        return self._idata_mem
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot access idata_mem while running"
+            )
+        return self.__idata_mem
+
+    @property
+    def chunk_store(self):
+        """
+        The current chunk store
+
+        Returns
+        -------
+        dict :
+            Keys: model name, value: idata dict
+
+        """
+        return self.__chunk_store
+
+    def print(self, *args, vlim=1, **kwargs):
+        """
+        Print function, based on verbosity.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Arguments for the print function
+        kwargs: dict, optional
+            Keyword arguments for the print function
+        vlim: int
+            The verbosity limit
+
+        """
+        if self.verbosity >= vlim:
+            print(*args, **kwargs)
+
+    def initialize(self):
+        """
+        Initializes the algorithm.
+        """
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot initialize while running"
+            )
+        super().initialize(self, self.verbosity)
 
     def store_model_data(self, model, idata, force=False):
         """
@@ -217,9 +198,12 @@ class Algorithm(Model):
 
         """
         mname = f"{type(model).__name__}_{model.name}"
-        if not force and mname in self._idata_mem:
+        if force:
+            self.__idata_mem[mname] = idata
+        elif mname in self.idata_mem:
             raise KeyError(f"Attempt to overwrite stored data for model '{mname}'")
-        self._idata_mem[mname] = idata
+        else:
+            self.idata_mem[mname] = idata
 
     def get_model_data(self, model):
         """
@@ -233,10 +217,10 @@ class Algorithm(Model):
         """
         mname = f"{type(model).__name__}_{model.name}"
         try:
-            return self._idata_mem[mname]
+            return self.idata_mem[mname]
         except KeyError:
             raise KeyError(
-                f"Key '{mname}' not found in idata_mem, available keys: {sorted(list(self._idata_mem.keys()))}"
+                f"Key '{mname}' not found in idata_mem, available keys: {sorted(list(self.idata_mem.keys()))}"
             )
 
     def del_model_data(self, model):
@@ -251,7 +235,7 @@ class Algorithm(Model):
         """
         mname = f"{type(model).__name__}_{model.name}"
         try:
-            del self._idata_mem[mname]
+            del self.idata_mem[mname]
         except KeyError:
             raise KeyError(f"Attempt to delete data of model '{mname}', but not stored")
 
@@ -308,7 +292,7 @@ class Algorithm(Model):
                                 np.append(d[1], a, axis=i),
                             )
 
-            self._idata_mem.update(newk)
+            self.idata_mem.update(newk)
 
     def get_models_idata(self):
         """
@@ -328,13 +312,13 @@ class Algorithm(Model):
                 f"Algorithm '{self.name}': get_models_idata called before initialization"
             )
         idata = {"coords": {}, "data_vars": {}}
-        for k, hidata in self._idata_mem.items():
+        for k, hidata in self.idata_mem.items():
             if len(k) < 3 or k[:2] != "__":
                 idata["coords"].update(hidata["coords"])
                 idata["data_vars"].update(hidata["data_vars"])
         return idata
 
-    def get_models_data(self, idata=None):
+    def get_models_data(self, idata=None, sel=None, isel=None):
         """
         Creates xarray from model input data.
 
@@ -345,19 +329,27 @@ class Algorithm(Model):
             a dict with entries `name_str -> (dim_tuple, data_ndarray)`;
             and `coords`, a dict with entries `dim_name_str -> dim_array`.
             Take algorithm's idata object by default.
+        sel: dict, optional
+            Selection of coordinates in dataset
+        isel: dict, optional
+            Selection of coordinates in dataset
 
         Returns
         -------
-        xarray.Dataset
+        ds: xarray.Dataset
             The model input data
 
         """
         if idata is None:
             idata = self.get_models_idata()
-        sizes = self.__get_sizes(idata, "models")
-        return self.__get_xrdata(idata, sizes)
-
-    def new_point_data(self, points, states_indices=None):
+        ds = xr.Dataset(**idata)
+        if isel is not None:
+            ds = ds.isel(isel)
+        if sel is not None:
+            ds = ds.sel(sel)
+        return ds
+
+    def new_point_data(self, points, states_indices=None, n_states=None):
         """
         Creates a point data xarray object, containing only points.
 
@@ -367,6 +359,8 @@ class Algorithm(Model):
             The points, shape: (n_states, n_points, 3)
         states_indices: array_like, optional
             The indices of the states dimension
+        n_states: int, optional
+            The number of states
 
         Returns
         -------
@@ -374,7 +368,8 @@ class Algorithm(Model):
             A dataset containing the points data
 
         """
-
+        if n_states is None:
+            n_states = self.n_states
         if states_indices is None:
             idata = {"coords": {}, "data_vars": {}}
         else:
@@ -382,11 +377,11 @@ class Algorithm(Model):
 
         if (
             len(points.shape) != 3
-            or points.shape[0] != self.n_states
+            or points.shape[0] != n_states
             or points.shape[2] != 3
         ):
             raise ValueError(
-                f"points have wrong dimensions, expecting ({self.n_states}, {points.shape[1]}, 3), got {points.shape}"
+                f"points have wrong dimensions, expecting ({n_states}, {points.shape[1]}, 3), got {points.shape}"
             )
         idata["data_vars"][FC.TARGETS] = (
             (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH),
@@ -397,8 +392,495 @@ class Algorithm(Model):
             np.array([1.0], dtype=FC.DTYPE),
         )
 
-        sizes = self.__get_sizes(idata, "point")
-        return self.__get_xrdata(idata, sizes)
+        return xr.Dataset(**idata)
+
+    def find_chunk_in_store(
+        self,
+        mdata,
+        tdata=None,
+        prev_s=0,
+        prev_t=0,
+        error=True,
+    ):
+        """
+        Finds indices in chunk store
+
+        Parameters
+        ----------
+        name: str
+            The data name
+        mdata: foxes.core.MData
+            The mdata object
+        tdata: foxes.core.TData, optional
+            The tdata object
+        prev_s: int
+            How many states chunks backward
+        prev_t: int
+            How many points chunks backward
+        error: bool
+            Flag for raising KeyError if data not found
+
+        Returns
+        -------
+        inds: tuple
+            The (i0, n_states, t0, n_targets) data of the
+            returning chunk
+
+        """
+        i0 = int(mdata.states_i0(counter=True))
+        t0 = int(tdata.targets_i0() if tdata is not None else 0)
+        n_states = int(mdata.n_states)
+        n_targets = int(tdata.n_targets if tdata is not None else 0)
+
+        if prev_s > 0 or prev_t > 0:
+
+            inds = np.array(
+                [
+                    [
+                        d["i0"],
+                        d["i0"] + d["n_states"],
+                        d["n_states"],
+                        d["t0"],
+                        d["t0"] + d["n_targets"],
+                        d["n_targets"],
+                    ]
+                    for d in self.chunk_store.values()
+                ],
+                dtype=int,
+            )
+
+            if prev_t > 0:
+                while prev_t > 0:
+                    sel = np.where((inds[:, 0] == i0) & (inds[:, 4] == t0))[0]
+                    if len(sel) == 0:
+                        if error:
+                            raise KeyError(
+                                f"{self.name}: Previous key {(i0, t0)}, prev={(prev_s, prev_t)}, not found in chunk store, got inds {inds}"
+                            )
+                        else:
+                            return None
+                    else:
+                        n_targets = inds[sel[0], 5]
+                        t0 -= n_targets
+                        prev_t -= 1
+
+            if prev_s > 0:
+                while prev_s > 0:
+                    sel = np.where((inds[:, 1] == i0) & (inds[:, 3] == t0))[0]
+                    if len(sel) == 0:
+                        if error:
+                            raise KeyError(
+                                f"{self.name}: Previous key {(i0, t0)}, prev={(prev_s, prev_t)}, not found in chunk store, got inds {inds}"
+                            )
+                        else:
+                            return None
+                    else:
+                        n_states = inds[sel[0], 2]
+                        i0 -= n_states
+                        prev_s -= 1
+
+        return i0, n_states, t0, n_targets
+
+    def add_to_chunk_store(
+        self,
+        name,
+        data,
+        mdata,
+        tdata=None,
+        copy=True,
+    ):
+        """
+        Add data to the chunk store
+
+        Parameters
+        ----------
+        name: str
+            The data name
+        data: numpy.ndarray
+            The data
+        mdata: foxes.core.MData
+            The mdata object
+        tdata: foxes.core.TData, optional
+            The tdata object
+        copy: bool
+            Flag for copying incoming data
+
+        """
+        i0 = int(mdata.states_i0(counter=True))
+        t0 = int(tdata.targets_i0() if tdata is not None else 0)
+
+        key = (i0, t0)
+        if key not in self.chunk_store:
+            n_states = int(mdata.n_states)
+            n_targets = int(tdata.n_targets if tdata is not None else 0)
+            self.chunk_store[key] = Dict(
+                {
+                    "i0": i0,
+                    "t0": t0,
+                    "n_states": n_states,
+                    "n_targets": n_targets,
+                },
+                name=f"chunk_store_{i0}_{t0}",
+            )
+
+        self.chunk_store[key][name] = data.copy() if copy else data
+
+    def get_from_chunk_store(
+        self,
+        name,
+        mdata,
+        tdata=None,
+        prev_s=0,
+        prev_t=0,
+        ret_inds=False,
+        error=True,
+    ):
+        """
+        Get data to the chunk store
+
+        Parameters
+        ----------
+        name: str
+            The data name
+        mdata: foxes.core.MData
+            The mdata object
+        tdata: foxes.core.TData, optional
+            The tdata object
+        prev_s: int
+            How many states chunks backward
+        prev_t: int
+            How many points chunks backward
+        ret_inds: bool
+            Also return (i0, n_states, t0, n_targets)
+            of the returned chunk
+        error: bool
+            Flag for raising KeyError if data not found
+
+        Returns
+        -------
+        data: numpy.ndarray
+            The data
+        inds: tuple, optional
+            The (i0, n_states, t0, n_targets) data of the
+            returning chunk
+
+        """
+        inds = self.find_chunk_in_store(mdata, tdata, prev_s, prev_t, error)
+
+        if inds is None:
+            return (None, (None, None, None, None)) if ret_inds else None
+        else:
+            i0, __, t0, __ = inds
+            try:
+                data = self.chunk_store[(i0, t0)][name]
+            except KeyError as e:
+                if error:
+                    raise e
+                else:
+                    data = None
+            if ret_inds:
+                return data, inds
+            else:
+                return data
+
+    def reset_chunk_store(self, new_chunk_store=None):
+        """
+        Resets the chunk store
+
+        Parameters
+        ----------
+        new_chunk_store: foxes.utils.Dict, optional
+            The new chunk store
+
+        Returns
+        -------
+        chunk_store: foxes.utils.Dict
+            The chunk store before resetting
+
+        """
+        chunk_store = self.chunk_store
+        if new_chunk_store is None:
+            self.__chunk_store = Dict(name="chunk_store")
+        elif isinstance(new_chunk_store, Dict):
+            self.__chunk_store = new_chunk_store
+        else:
+            self.__chunk_store = Dict(name="chunk_store")
+            self.__chunk_store.update(new_chunk_store)
+        return chunk_store
+
+    def block_convergence(self, **kwargs):
+        """
+        Switch on convergence block during iterative run
+
+        Parameters
+        ----------
+        kwargs: dict, optional
+            Parameters for add_to_chunk_store()
+
+        """
+        self.add_to_chunk_store(
+            name=FC.BLOCK_CONVERGENCE, data=True, copy=False, **kwargs
+        )
+
+    def eval_conv_block(self):
+        """
+        Evaluate convergence block, removing blocks on the fly
+
+        Returns
+        -------
+        blocked: bool
+            True if convergence is currently blocked
+
+        """
+        blocked = False
+        for c in self.__chunk_store.values():
+            blocked = c.pop(FC.BLOCK_CONVERGENCE, False) or blocked
+        return blocked
+
+    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
+
+        """
+        assert algo is self
+
+        super().set_running(algo, data_stash, sel, isel, verbosity)
+
+        data_stash[self.name].update(
+            dict(
+                mbook=self.__mbook,
+                dbook=self.__dbook,
+                idata_mem=self.__idata_mem,
+            )
+        )
+        del self.__mbook, self.__dbook
+        self.__idata_mem = {}
+
+    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
+
+        """
+        assert algo is self
+
+        super().unset_running(algo, data_stash, sel, isel, verbosity)
+
+        data = data_stash[self.name]
+        self.__mbook = data.pop("mbook")
+        self.__dbook = data.pop("dbook")
+        self.__idata_mem = data.pop("idata_mem")
+
+    @abstractmethod
+    def _launch_parallel_farm_calc(
+        self,
+        *args,
+        mbook,
+        dbook,
+        chunk_store,
+        **kwargs,
+    ):
+        """
+        Runs the main farm calculation, launching parallelization
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional parameters for running
+        mbook: foxes.models.ModelBook
+            The model book
+        dbook: foxes.DataBook
+            The data book, or None for default
+        chunk_store: foxes.utils.Dict
+            The chunk store
+        kwargs: dict, optional
+            Additional parameters for running
+
+        Returns
+        -------
+        farm_results: xarray.Dataset
+            The farm results. The calculated variables have
+            dimensions (state, turbine)
+
+        """
+        pass
+
+    def calc_farm(self, *args, **kwargs):
+        """
+        Calculate farm data.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Parameters
+        kwargs: dict, optional
+            Keyword parameters
+
+        Returns
+        -------
+        farm_results: xarray.Dataset
+            The farm results. The calculated variables have
+            dimensions (state, turbine)
+
+        """
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot call calc_farm while running"
+            )
+
+        # set to running:
+        data_stash = {}
+        chunk_store = self.reset_chunk_store()
+        mdls = [
+            m
+            for m in [self] + list(args) + list(kwargs.values())
+            if isinstance(m, Model)
+        ]
+        for m in mdls:
+            m.set_running(
+                self, data_stash, sel=None, isel=None, verbosity=self.verbosity - 2
+            )
+
+        # run parallel calculation:
+        farm_results = self._launch_parallel_farm_calc(
+            *args,
+            chunk_store=chunk_store,
+            sel=None,
+            isel=None,
+            **kwargs,
+        )
+
+        # reset to not running:
+        for m in mdls:
+            m.unset_running(
+                self, data_stash, sel=None, isel=None, verbosity=self.verbosity - 2
+            )
+
+        return farm_results
+
+    @abstractmethod
+    def _launch_parallel_points_calc(
+        self,
+        *args,
+        chunk_store,
+        **kwargs,
+    ):
+        """
+        Runs the main points calculation, launching parallelization
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional parameters for running
+        chunk_store: foxes.utils.Dict
+            The chunk store
+        kwargs: dict, optional
+            Additional parameters for running
+
+        Returns
+        -------
+        point_results: xarray.Dataset
+            The point results. The calculated variables have
+            dimensions (state, point)
+
+        """
+        pass
+
+    def calc_points(self, *args, sel=None, isel=None, **kwargs):
+        """
+        Calculate points data.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Parameters
+        sel: dict, optional
+            The subset selection dictionary
+        isel: dict, optional
+            The index subset selection dictionary
+        kwargs: dict, optional
+            Keyword parameters
+
+        Returns
+        -------
+        point_results: xarray.Dataset
+            The point results. The calculated variables have
+            dimensions (state, point)
+
+        """
+        if self.running:
+            raise ValueError(
+                f"Algorithm '{self.name}': Cannot call calc_points while running"
+            )
+
+        # set to running:
+        data_stash = {}
+        self.set_running(
+            self, data_stash, sel=sel, isel=isel, verbosity=self.verbosity - 2
+        )
+
+        # run parallel calculation:
+        chunk_store = self.reset_chunk_store()
+        point_results = self._launch_parallel_points_calc(
+            *args,
+            chunk_store=chunk_store,
+            sel=sel,
+            isel=isel,
+            **kwargs,
+        )
+
+        # reset to not running:
+        self.unset_running(
+            self, data_stash, sel=sel, isel=isel, verbosity=self.verbosity - 2
+        )
+
+        return point_results
 
     def finalize(self, clear_mem=False):
         """
@@ -410,9 +892,12 @@ class Algorithm(Model):
             Clear idata memory
 
         """
+        if self.running:
+            raise ValueError(f"Algorithm '{self.name}': Cannot finalize while running")
         super().finalize(self, self.verbosity)
         if clear_mem:
-            self._idata_mem = Dict()
+            self.__idata_mem = Dict()
+            # self.reset_chunk_store()
 
     @classmethod
     def new(cls, algo_type, *args, **kwargs):