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

foxes/engines/single.py

@@ -0,0 +1,139 @@
+from xarray import Dataset
+
+import foxes.constants as FC
+from foxes.core import Engine
+
+
+class SingleChunkEngine(Engine):
+    """
+    Runs computations in a single chunk.
+
+    :group: engines
+
+    """
+
+    def __init__(self, *args, **kwargs):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        args: tuple, optional
+            Additional parameters for the base class
+        kwargs: dict, optional
+            Additional parameters for the base class
+
+        """
+        ignr = ["chunk_size_states", "chunk_size_points", "n_procs"]
+        for k in ignr:
+            if kwargs.pop(k, None) is not None and kwargs.get("verbosity", 1) > 1:
+                print(f"{type(self).__name__}: Ignoring {k}")
+        super().__init__(
+            *args,
+            chunk_size_states=None,
+            chunk_size_points=None,
+            n_procs=1,
+            **kwargs,
+        )
+
+    def __repr__(self):
+        return f"{type(self).__name__}()"
+
+    def run_calculation(
+        self,
+        algo,
+        model,
+        model_data=None,
+        farm_data=None,
+        point_data=None,
+        out_vars=[],
+        chunk_store={},
+        sel=None,
+        isel=None,
+        iterative=False,
+        **calc_pars,
+    ):
+        """
+        Runs the model calculation
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The algorithm object
+        model: foxes.core.DataCalcModel
+            The model that whose calculate function
+            should be run
+        model_data: xarray.Dataset
+            The initial model data
+        farm_data: xarray.Dataset
+            The initial farm data
+        point_data: xarray.Dataset
+            The initial point data
+        out_vars: list of str, optional
+            Names of the output variables
+        chunk_store: foxes.utils.Dict
+            The chunk store
+        sel: dict, optional
+            Selection of coordinate subsets
+        isel: dict, optional
+            Selection of coordinate subsets index values
+        iterative: bool
+            Flag for use within the iterative algorithm
+        calc_pars: dict, optional
+            Additional parameters for the model.calculate()
+
+        Returns
+        -------
+        results: xarray.Dataset
+            The model results
+
+        """
+        # subset selection:
+        model_data, farm_data, point_data = self.select_subsets(
+            model_data, farm_data, point_data, sel=sel, isel=isel
+        )
+
+        # basic checks:
+        super().run_calculation(algo, model, model_data, farm_data, point_data)
+
+        # prepare:
+        n_states = model_data.sizes[FC.STATE]
+        n_targets = point_data.sizes[FC.TARGET] if point_data is not None else 0
+        out_coords = model.output_coords()
+        coords = {}
+        if FC.STATE in out_coords and FC.STATE in model_data.coords:
+            coords[FC.STATE] = model_data[FC.STATE].to_numpy()
+        if farm_data is None:
+            farm_data = Dataset()
+        goal_data = farm_data if point_data is None else point_data
+        algo.reset_chunk_store(chunk_store)
+
+        # calculate:
+
+        if n_states > 1:
+            self.print(f"Running single chunk calculation for {n_states} states")
+
+        data = self.get_chunk_input_data(
+            algo=algo,
+            model_data=model_data,
+            farm_data=farm_data,
+            point_data=point_data,
+            states_i0_i1=(0, n_states),
+            targets_i0_i1=(0, n_targets),
+            out_vars=out_vars,
+        )
+
+        results = {}
+        results[(0, 0)] = (model.calculate(algo, *data, **calc_pars), algo.chunk_store)
+
+        return self.combine_results(
+            algo=algo,
+            results=results,
+            model_data=model_data,
+            out_vars=out_vars,
+            out_coords=out_coords,
+            n_chunks_states=1,
+            n_chunks_targets=1,
+            goal_data=goal_data,
+            iterative=iterative,
+        )

foxes/input/farm_layout/__init__.py

@@ -9,3 +9,4 @@ from .from_csv import add_from_csv
 from .from_file import add_from_file
 from .from_df import add_from_df
 from .from_random import add_random
+from .ring import add_ring

foxes/input/farm_layout/from_csv.py

@@ -14,6 +14,7 @@ def add_from_csv(
     col_D=None,
     col_id=None,
     cols_models_pre=None,
+    col_turbine_type=None,
     cols_models_post=None,
     turbine_base_name="T",
     turbine_ids=None,
@@ -47,6 +48,8 @@ def add_from_csv(
     cols_models_pre: list of str, optional
         The turbine model columns, entered before
         turbine_models
+    col_turbine_type: str, optional
+        The turbine type name
     cols_models_post: list of str, optional
         The turbine model columns, entered after
         turbine_models
@@ -95,6 +98,7 @@ def add_from_csv(
         hmodels = (
             [] if cols_models_pre is None else data.loc[i, cols_models_pre].tolist()
         )
+        hmodels += [] if col_turbine_type is None else [data.loc[i, col_turbine_type]]
         hmodels += tmodels
         hmodels += (
             [] if cols_models_post is None else data.loc[i, cols_models_post].tolist()

foxes/input/farm_layout/from_json.py

@@ -60,7 +60,7 @@ def add_from_json(
                 xy=np.array([wdict["UTMX"], wdict["UTMY"]]),
                 index=wdict.get("id", None),
                 name=wt_name,
-                **pars
+                **pars,
             ),
             verbosity=verbosity,
         )

foxes/input/farm_layout/grid.py

@@ -12,7 +12,7 @@ def add_grid(
     indices=None,
     names=None,
     verbosity=1,
-    **turbine_parameters
+    **turbine_parameters,
 ):
     """
     Add a regular grid of turbines.
@@ -54,7 +54,7 @@ def add_grid(
                 xy=xy_base + xi * step_vectors[0] + yi * step_vectors[1],
                 index=None if indices is None else indices[i],
                 name=None if names is None else names[i],
-                **turbine_parameters
+                **turbine_parameters,
             ),
             verbosity=verbosity,
         )

foxes/input/farm_layout/ring.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from foxes.core import Turbine
+from foxes.utils import wd2wdvec
+
+
+def add_ring(
+    farm,
+    xy_base,
+    dist,
+    n_turbines,
+    offset_deg=0,
+    indices=None,
+    names=None,
+    verbosity=1,
+    **turbine_parameters,
+):
+    """
+    Add a ring of turbines.
+
+    Parameters
+    ----------
+    farm: foxes.WindFarm
+        The wind farm
+    xy_base: numpy.ndarray
+        The base point, shape: (2,)
+    dist: float
+        The distance between turbines
+    n_turbines: int
+        The number of turbines
+    offset_deg: float
+        The offset from north in degrees,
+        following wind direction conventions
+    indices: list of int, optional
+        The turbine indices
+    names: list of str, optional
+        The turbine names
+    verbosity: int
+        The verbosity level, 0 = silent
+    turbine_parameters: dict, optional
+        Parameters forwarded to `foxes.core.Turbine`
+
+    :group: input.farm_layout
+
+    """
+    p0 = np.array(xy_base)
+    R = n_turbines * dist / (2 * np.pi)
+    a = np.atleast_1d(offset_deg)
+    da = 360 / n_turbines
+
+    for i in range(n_turbines):
+
+        n = wd2wdvec(a)[0]
+
+        farm.add_turbine(
+            Turbine(
+                xy=p0 + R * n,
+                index=None if indices is None else indices[i],
+                name=None if names is None else names[i],
+                **turbine_parameters,
+            ),
+            verbosity=verbosity,
+        )
+
+        a[0] += da

foxes/input/farm_layout/row.py

@@ -11,7 +11,7 @@ def add_row(
     indices=None,
     names=None,
     verbosity=1,
-    **turbine_parameters
+    **turbine_parameters,
 ):
     """
     Add a single row of turbines.
@@ -47,7 +47,7 @@ def add_row(
                 xy=p0 + i * delta,
                 index=None if indices is None else indices[i],
                 name=None if names is None else names[i],
-                **turbine_parameters
+                **turbine_parameters,
             ),
             verbosity=verbosity,
         )

foxes/input/states/__init__.py

@@ -8,5 +8,11 @@ from .states_table import StatesTable, Timeseries, TabStates
 from .field_data_nc import FieldDataNC
 from .multi_height import MultiHeightStates, MultiHeightTimeseries
 from .multi_height import MultiHeightNCStates, MultiHeightNCTimeseries
+from .one_point_flow import (
+    OnePointFlowStates,
+    OnePointFlowTimeseries,
+    OnePointFlowMultiHeightTimeseries,
+    OnePointFlowMultiHeightNCTimeseries,
+)
 
 from . import create

foxes/input/states/create/random_abl_states.py

@@ -67,7 +67,7 @@ def write_random_abl_states(
     normalize=True,
     verbosity=1,
     digits="auto",
-    **kwargs
+    **kwargs,
 ):
     """
     Writes random abl states to file

foxes/input/states/field_data_nc.py

@@ -2,9 +2,10 @@ import numpy as np
 import pandas as pd
 import xarray as xr
 from scipy.interpolate import interpn
+from pathlib import Path
 
 from foxes.core import States
-from foxes.utils import wd2uv, uv2wd
+from foxes.utils import wd2uv, uv2wd, import_module
 from foxes.data import STATES, StaticData
 import foxes.variables as FV
 import foxes.constants as FC
@@ -120,7 +121,6 @@ class FieldDataNC(States):
         """
         super().__init__()
 
-        self.data_source = data_source
         self.states_coord = states_coord
         self.ovars = output_vars
         self.fixed_vars = fixed_vars
@@ -139,16 +139,18 @@ class FieldDataNC(States):
             v: var2ncvar.get(v, v) for v in output_vars if v not in fixed_vars
         }
 
-        self._inds = None
         self._N = None
-        self._weights = None
 
-        # pre-load file reading, usually prior to DaskRunner:
+        self.__data_source = data_source
+        self.__weights = None
+        self.__inds = None
+
+        # pre-load file reading:
         if not isinstance(self.data_source, xr.Dataset):
             if "*" in str(self.data_source):
                 pass
             else:
-                self.data_source = StaticData().get_file_path(
+                self.__data_source = StaticData().get_file_path(
                     STATES, self.data_source, check_raw=True
                 )
             if verbosity:
@@ -161,26 +163,54 @@ class FieldDataNC(States):
                         f"States '{self.name}': Reading index from '{self.data_source}'"
                     )
 
-            with xr.open_mfdataset(
-                str(self.data_source),
-                parallel=False,
-                concat_dim=self.states_coord,
-                combine="nested",
-                data_vars="minimal",
-                coords="minimal",
-                compat="override",
-            ) as ds:
-                self.data_source = ds
+            def _read_ds():
+                if Path(self.data_source).is_file():
+                    return xr.open_dataset(self.data_source)
+                else:
+                    # try to read multiple files, needs dask:
+                    try:
+                        return xr.open_mfdataset(
+                            str(self.data_source),
+                            parallel=False,
+                            concat_dim=self.states_coord,
+                            combine="nested",
+                            data_vars="minimal",
+                            coords="minimal",
+                            compat="override",
+                        )
+                    except ValueError as e:
+                        import_module("dask", hint="pip install dask")
+                        raise e
+
+            with _read_ds() as ds:
+                self.__data_source = ds
 
         if sel is not None:
-            self.data_source = self.data_source.sel(self.sel)
+            self.__data_source = self.data_source.sel(self.sel)
         if isel is not None:
-            self.data_source = self.data_source.isel(self.isel)
+            self.__data_source = self.data_source.isel(self.isel)
         if pre_load:
-            self.data_source.load()
+            self.__data_source.load()
 
         self._get_inds(self.data_source)
 
+    @property
+    def data_source(self):
+        """
+        The data source
+
+        Returns
+        -------
+        s: object
+            The data source
+
+        """
+        if self.pre_load and self.running:
+            raise ValueError(
+                f"States '{self.name}': Cannot acces data_source while running"
+            )
+        return self.__data_source
+
     def _get_inds(self, ds):
         """
         Helper function for index and weights
@@ -192,13 +222,15 @@ class FieldDataNC(States):
                     f"States '{self.name}': Missing coordinate '{c}' in data"
                 )
 
-        self._inds = ds[self.states_coord].to_numpy()
+        self.__inds = ds[self.states_coord].to_numpy()
         if self.time_format is not None:
-            self._inds = pd.to_datetime(self._inds, format=self.time_format).to_numpy()
-        self._N = len(self._inds)
+            self.__inds = pd.to_datetime(
+                self.__inds, format=self.time_format
+            ).to_numpy()
+        self._N = len(self.__inds)
 
         if self.weight_ncvar is not None:
-            self._weights = ds[self.weight_ncvar].to_numpy()
+            self.__weights = ds[self.weight_ncvar].to_numpy()
 
         for v in self.ovars:
             if v in self.var2ncvar:
@@ -331,8 +363,8 @@ class FieldDataNC(States):
                 self._dkys[v] = len(self._dkys)
         self._n_dvars = len(self._dkys)
 
-        if self._weights is None:
-            self._weights = np.full(
+        if self.__weights is None:
+            self.__weights = np.full(
                 (self._N, algo.n_turbines), 1.0 / self._N, dtype=FC.DTYPE
             )
 
@@ -363,6 +395,84 @@ class FieldDataNC(States):
 
         return idata
 
+    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
+
+        """
+        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
+
+        if self.pre_load:
+            data_stash[self.name]["data_source"] = self.__data_source
+            del self.__data_source
+
+    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
+
+        """
+        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.pre_load:
+            self.__data_source = data.pop("data_source")
+
     def size(self):
         """
         The total number of states.
@@ -385,7 +495,9 @@ class FieldDataNC(States):
             The index labels of states, or None for default integers
 
         """
-        return self._inds
+        if self.running:
+            raise ValueError(f"States '{self.name}': Cannot acces index while running")
+        return self.__inds
 
     def output_point_vars(self, algo):
         """
@@ -419,7 +531,11 @@ class FieldDataNC(States):
             The weights, shape: (n_states, n_turbines)
 
         """
-        return self._weights
+        if self.running:
+            raise ValueError(
+                f"States '{self.name}': Cannot acces weights while running"
+            )
+        return self.__weights
 
     def calculate(self, algo, mdata, fdata, tdata):
         """ "
@@ -464,7 +580,7 @@ class FieldDataNC(States):
 
         # read data for this chunk:
         else:
-            i0 = np.where(self._inds == mdata[FC.STATE][0])[0][0]
+            i0 = mdata.states_i0(counter=True)
             s = slice(i0, i0 + n_states)
             ds = self.data_source.isel({self.states_coord: s}).load()
 
@@ -520,17 +636,26 @@ class FieldDataNC(States):
 
         # interpolate:
         try:
-            data = interpn(gvars, data, pts, **self.interpn_pars).reshape(
+            ipars = dict(bounds_error=True, fill_value=None)
+            ipars.update(self.interpn_pars)
+            data = interpn(gvars, data, pts, **ipars).reshape(
                 n_states, n_pts, self._n_dvars
             )
         except ValueError as e:
-            print(f"\n\nStates '{self.name}': Interpolation error")
+            print(f"\nStates '{self.name}': Interpolation error")
             print("INPUT VARS: (state, heights, y, x)")
             print(
-                "DATA BOUNDS:", [np.min(d) for d in gvars], [np.max(d) for d in gvars]
+                "DATA BOUNDS:",
+                [float(np.min(d)) for d in gvars],
+                [float(np.max(d)) for d in gvars],
+            )
+            print(
+                "EVAL BOUNDS:",
+                [float(np.min(p)) for p in pts.T],
+                [float(np.max(p)) for p in pts.T],
             )
             print(
-                "EVAL BOUNDS:", [np.min(p) for p in pts.T], [np.max(p) for p in pts.T]
+                "\nMaybe you want to try the option 'bounds_error=False'? This will extrapolate the data.\n"
             )
             raise e
         del pts, x, y, h, gvars