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

foxes/core/farm_data_model.py

@@ -52,6 +52,18 @@ class FarmDataModel(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.TURBINE)
+
     def ensure_variables(self, algo, mdata, fdata):
         """
         Add variables to fdata, initialized with NaN
@@ -171,6 +183,9 @@ class FarmDataModelList(FarmDataModel):
         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

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(
@@ -241,7 +343,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:
@@ -353,6 +455,12 @@ class Model(ABC):
             if out is not None:
                 break
 
+        # check for None:
+        if not accept_none and out is None:
+            raise ValueError(
+                f"Model '{self.name}': Variable '{variable}' is requested but not found."
+            )
+
         # cast dimensions:
         if out_dims != dims:
             if out_dims is None:
@@ -438,7 +546,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 +559,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(
@@ -476,67 +593,3 @@ class Model(ABC):
                 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
-
-        """
-        if name in data:
-            return (data[name], data.dims[name]) if ret_dims else data[name]
-
-        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

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
@@ -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

foxes/core/rotor_model.py

@@ -27,13 +27,13 @@ class RotorModel(FarmDataModel):
 
     """
 
-    def __init__(self, calc_vars):
+    def __init__(self, calc_vars=None):
         """
         Constructor.
 
         Parameters
         ----------
-        calc_vars: list of str
+        calc_vars: list of str, optional
             The variables that are calculated by the model
             (Their ambients are added automatically)
 
@@ -41,10 +41,6 @@ class RotorModel(FarmDataModel):
         super().__init__()
         self.calc_vars = calc_vars
 
-        self.RPOINTS = self.var("rpoints")
-        self.RWEIGHTS = self.var("rweights")
-        self.AMBRES = self.var("amb_res")
-
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -60,12 +56,21 @@ class RotorModel(FarmDataModel):
             The output variable names
 
         """
-        return list(
-            set(
-                self.calc_vars
-                + [FV.var2amb[v] for v in self.calc_vars if v in FV.var2amb]
-            )
-        )
+        if self.calc_vars is None:
+            vrs = algo.states.output_point_vars(algo)
+            if FV.WS in vrs:
+                self.calc_vars = [FV.REWS] + [v for v in vrs if v != FV.WS]
+            else:
+                self.calc_vars = vrs
+
+            if algo.farm_controller.needs_rews2() and FV.REWS2 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS2)
+            if algo.farm_controller.needs_rews3() and FV.REWS3 not in self.calc_vars:
+                self.calc_vars.append(FV.REWS3)
+
+            self.calc_vars = sorted(self.calc_vars)
+
+        return self.calc_vars
 
     @abstractmethod
     def n_rotor_points(self):
@@ -207,6 +212,10 @@ class RotorModel(FarmDataModel):
             variables after calculation
 
         """
+        for v in [FV.REWS2, FV.REWS3]:
+            if v in fdata and v not in self.calc_vars:
+                self.calc_vars.append(v)
+
         uvp = None
         uv = None
         if (
@@ -348,11 +357,11 @@ class RotorModel(FarmDataModel):
         """
 
         if rpoints is None:
-            rpoints = mdata.get(self.RPOINTS, self.get_rotor_points(algo, mdata, fdata))
+            rpoints = mdata.get(
+                FC.ROTOR_POINTS, self.get_rotor_points(algo, mdata, fdata)
+            )
         if store_rpoints:
-            mdata[self.RPOINTS] = rpoints
-            mdata.dims[self.RPOINTS] = (FC.STATE, FC.TURBINE, FC.TPOINT, FC.XYH)
-            self.data_to_store(self.RPOINTS, algo, mdata)
+            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
 
         if downwind_index is not None:
             rpoints = rpoints[:, downwind_index, None]
@@ -360,9 +369,7 @@ class RotorModel(FarmDataModel):
         if weights is None:
             weights = mdata.get(FC.TWEIGHTS, self.rotor_point_weights())
         if store_rweights:
-            mdata[self.RWEIGHTS] = weights
-            mdata.dims[self.RWEIGHTS] = (FC.TPOINT,)
-            self.data_to_store(self.RWEIGHTS, algo, mdata)
+            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, weights, mdata=mdata)
 
         tdata = TData.from_tpoints(rpoints, weights)
         svars = algo.states.output_point_vars(algo)
@@ -377,8 +384,7 @@ class RotorModel(FarmDataModel):
         tdata.update(sres)
 
         if store_amb_res:
-            mdata[self.AMBRES] = sres.copy()
-            self.data_to_store(self.AMBRES, algo, mdata)
+            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres.copy(), mdata=mdata)
 
         self.eval_rpoint_results(
             algo,

foxes/core/states.py

@@ -61,6 +61,22 @@ class States(PointDataModel):
         """
         pass
 
+    def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
+        """
+        Reset the states, optionally select states
+
+        Parameters
+        ----------
+        states_sel: slice or range or list of int, optional
+            States subset selection
+        states_loc: list, optional
+            State index selection via pandas loc function
+        verbosity: int
+            The verbosity level, 0 = silent
+
+        """
+        raise NotImplementedError(f"States '{self.name}': Reset is not implemented")
+
     def load_data(self, algo, verbosity=0):
         """
         Load and/or create all model data that is subject to chunking.

foxes/core/turbine_type.py

@@ -1,3 +1,5 @@
+from abc import abstractmethod
+
 import foxes.constants as FC
 from foxes.utils import all_subclasses
 
@@ -64,6 +66,32 @@ class TurbineType(TurbineModel):
         a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}"
         return f"{type(self).__name__}({a})"
 
+    @abstractmethod
+    def needs_rews2(self):
+        """
+        Returns flag for requirering REWS2 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS2 is required
+
+        """
+        pass
+
+    @abstractmethod
+    def needs_rews3(self):
+        """
+        Returns flag for requirering REWS3 variable
+
+        Returns
+        -------
+        flag: bool
+            True if REWS3 is required
+
+        """
+        pass
+
     def modify_cutin(self, modify_ct, modify_P):
         """
         Modify the data such that a discontinuity

foxes/core/wake_frame.py

@@ -6,7 +6,7 @@ from foxes.utils import all_subclasses
 import foxes.constants as FC
 import foxes.variables as FV
 
-from .data import MData, FData, TData
+from .data import TData
 from .model import Model
 
 
@@ -21,10 +21,28 @@ class WakeFrame(Model):
     They are also responsible for the calculation of
     the turbine evaluation order.
 
+    Attributes
+    ----------
+    max_length_km: float
+        The maximal wake length in km
+
     :group: core
 
     """
 
+    def __init__(self, max_length_km=3e4):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        max_length_km: float
+            The maximal wake length in km
+
+        """
+        super().__init__()
+        self.max_length_km = max_length_km
+
     @abstractmethod
     def calc_order(self, algo, mdata, fdata):
         """ "
@@ -241,7 +259,7 @@ class WakeFrame(Model):
 
         # calc evaluation points:
         xmin = 0.0
-        xmax = np.nanmax(x)
+        xmax = min(np.nanmax(x), self.max_length_km * 1e3)
         n_steps = int((xmax - xmin) / dx)
         if xmin + n_steps * dx < xmax:
             n_steps += 1
@@ -262,7 +280,7 @@ class WakeFrame(Model):
         res = algo.states.calculate(algo, mdata, fdata, tdata)
         tdata.update(res)
         amb2var = algo.get_model("SetAmbPointResults")()
-        amb2var.initialize(algo, verbosity=0)
+        amb2var.initialize(algo, verbosity=0, force=True)
         res = amb2var.calculate(algo, mdata, fdata, tdata)
         tdata.update(res)
         del res, amb2var
@@ -277,7 +295,7 @@ class WakeFrame(Model):
         # calc wakes:
         if not ambient:
             wcalc = algo.get_model("PointWakesCalculation")(wake_models=wake_models)
-            wcalc.initialize(algo, verbosity=0)
+            wcalc.initialize(algo, verbosity=0, force=True)
             wsrc = downwind_index if self_wake else None
             res = wcalc.calculate(algo, mdata, fdata, tdata, downwind_index=wsrc)
             tdata.update(res)

foxes/core/wake_model.py

@@ -304,9 +304,8 @@ class WakeK(Model):
             The k array as returned by get_data
 
         """
-        if self._k is not None:
-            setattr(self, self.k_var, self._k)
-        elif self._ka is not None or self._kb is not None:
+        setattr(self, self.k_var, self._k)
+        if self._ka is not None or self._kb is not None:
             if self.ti_var == FV.TI and ti is not None:
                 pass
             elif self.ti_var == FV.AMB_TI and amb_ti is not None:

foxes/data/windio/windio_5turbines_timeseries.yaml

@@ -59,5 +59,27 @@ attributes:
     blockage_model:
       name: None
 
-
+  outputs:
+    output_folder: "results"
+    turbine_outputs:
+        turbine_nc_filename: 'turbine_data.nc' # dimension = states, turbine
+        output_variables: ['power', 'rotor_effective_velocity'] #'frequency'
+    #
+    flow_field:
+      report: True
+      flow_nc_filename: flow_field.nc
+      cases_run:
+        all_occurences: True
+      output_variables: ['wind_speed', 'wind_direction']
+      z_planes:
+        z_sampling: "hub_height"
+        xy_sampling: "default"
+    #
+    statistics:
+      stats_filename: None
+      AEP: False
+      AEP_per_turbine: False
+      power_percentiles:
+        report: False
+        percentiles: None
 

foxes/engines/__init__.py

@@ -0,0 +1,16 @@
+from .pool import PoolEngine
+from .multiprocess import MultiprocessEngine
+from .numpy import NumpyEngine
+from .single import SingleChunkEngine
+from .futures import ThreadsEngine, ProcessEngine
+from .mpi import MPIEngine
+
+from .dask import (
+    DaskBaseEngine,
+    XArrayEngine,
+    DaskEngine,
+    LocalClusterEngine,
+    SlurmClusterEngine,
+)
+
+from .default import DefaultEngine