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

foxes/core/model.py

@@ -296,6 +296,7 @@ class Model(ABC):
         accept_nan=True,
         algo=None,
         upcast=False,
+        selection=None,
     ):
         """
         Getter for a data entry in the model object
@@ -335,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
 
         """
 
@@ -358,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)
@@ -375,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 (
@@ -419,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 (
@@ -442,84 +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
 
         # 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:
-                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}"
+        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 (
@@ -529,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"
@@ -592,4 +558,52 @@ class Model(ABC):
             except TypeError:
                 pass
 
+        # 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))
+
+        # apply upcast:
+        if upcast and out.shape != shp:
+            tmp = np.zeros(shp, dtype=out.dtype)
+            tmp[:] = out
+            out = tmp
+            del tmp
+
         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

@@ -66,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,
@@ -218,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,

foxes/core/states.py

@@ -295,7 +295,7 @@ class ExtendedStates(States):
         return self.states.output_point_vars(algo)
 
     def calculate(self, algo, mdata, fdata, tdata):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/core/turbine_type.py

@@ -69,7 +69,7 @@ class TurbineType(TurbineModel):
     @abstractmethod
     def needs_rews2(self):
         """
-        Returns flag for requirering REWS2 variable
+        Returns flag for requiring REWS2 variable
 
         Returns
         -------
@@ -82,7 +82,7 @@ class TurbineType(TurbineModel):
     @abstractmethod
     def needs_rews3(self):
         """
-        Returns flag for requirering REWS3 variable
+        Returns flag for requiring REWS3 variable
 
         Returns
         -------

foxes/core/wake_frame.py

@@ -45,7 +45,7 @@ class WakeFrame(Model):
 
     @abstractmethod
     def calc_order(self, algo, mdata, fdata):
-        """ "
+        """
         Calculates the order of turbine evaluation.
 
         This function is executed on a single chunk of data,
@@ -92,7 +92,7 @@ class WakeFrame(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
 
         Returns
         -------
@@ -112,7 +112,6 @@ class WakeFrame(Model):
         tdata,
         target,
         states0=None,
-        upcast=False,
     ):
         """
         Return data that is required for computing the
@@ -136,47 +135,26 @@ class WakeFrame(Model):
             FC.STATE_TARGET_TPOINT
         states0: numpy.ndarray, optional
             The states of wake creation
-        upcast: bool
-            Flag for ensuring targets dimension,
-            otherwise dimension 1 is entered
 
         Returns
         -------
         data: numpy.ndarray
             Data for wake modelling, shape:
             (n_states, n_turbines) or (n_states, n_target)
-        dims: tuple
-            The data dimensions
 
         """
-        n_states = fdata.n_states
         s = np.s_[:] if states0 is None else states0
 
-        if not upcast:
-            if target == FC.STATE_TARGET_TPOINT:
-                out = fdata[variable][s, downwind_index, None, None]
-                dims = (FC.STATE, 1, 1)
-            else:
-                out = fdata[variable][s, downwind_index, None]
-                dims = (FC.STATE, 1)
-        elif target == FC.STATE_TURBINE:
-            out = np.zeros((n_states, fdata.n_turbines), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None]
-            dims = (FC.STATE, FC.TURBINE)
-        elif target == FC.STATE_TARGET:
-            out = np.zeros((n_states, tdata.n_targets), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None]
-            dims = (FC.STATE, FC.TARGET)
-        elif target == FC.STATE_TARGET_TPOINT:
-            out = np.zeros((n_states, tdata.n_targets, tdata.n_tpoints), dtype=FC.DTYPE)
-            out[:] = fdata[variable][s, downwind_index, None, None]
-            dims = (FC.STATE, FC.TARGET, FC.TPOINT)
+        if target == FC.STATE_TARGET_TPOINT:
+            out = fdata[variable][s, downwind_index, None, None]
+        elif target in [FC.STATE_TURBINE, FC.STATE_TARGET]:
+            out = fdata[variable][s, downwind_index, None]
         else:
             raise ValueError(
-                f"Unsupported target '{target}', expcting '{FC.STATE_TURBINE}', '{FC.STATE_TARGET}', {FC.STATE_TARGET_TPOINT}"
+                f"Unkown target '{target}', choices are {FC.STATE_TURBINE}, {FC.STATE_TARGET}, {FC.STATE_TARGET_TPOINT}"
             )
 
-        return out, dims
+        return out
 
     def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """

foxes/core/wake_model.py

@@ -81,7 +81,7 @@ class WakeModel(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
@@ -304,6 +304,7 @@ class WakeK(Model):
             The k array as returned by get_data
 
         """
+        sel = kwargs.pop("selection", 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:
@@ -315,6 +316,6 @@ class WakeK(Model):
             kb = 0 if self._kb is None else self._kb
             setattr(self, self.k_var, self._ka * ti + kb)
 
-        k = self.get_data(self.k_var, *args, lookup=lookup_k, **kwargs)
+        k = self.get_data(self.k_var, *args, lookup=lookup_k, selection=sel, **kwargs)
         setattr(self, self.k_var, None)
         return k

foxes/core/wake_superposition.py

@@ -45,7 +45,7 @@ class WakeSuperposition(Model):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         st_sel: numpy.ndarray of bool
             The selection of targets, shape: (n_states, n_targets)
         variable: str

foxes/data/windio/windio_5turbines_timeseries.yaml

@@ -14,10 +14,9 @@ site:
 wind_farm: 
   name: One row with 5 turbines
   layouts:
-      initial_layout:
-          coordinates:
-              x: [0, 0, 0, 0, 0]
-              y: [0, 600, 1150, 1730, 2400]
+    - coordinates:
+        x: [0, 0, 0, 0, 0]
+        y: [0, 600, 1150, 1730, 2400]
   turbines: !include DTU_10MW_turbine.yaml
 
 attributes:
@@ -26,36 +25,31 @@ attributes:
 
   analysis:
 
+    #pywake and foxes
     wind_deficit_model:
       name: Bastankhah2014
       wake_expansion_coefficient: # k = ka*ti + kb
-        k_a: 0.04 
-        k_b: 0.0
+        k_a: 0.0
+        k_b: 0.04
         free_stream_ti: false
       ceps: 0.2
       use_effective_ws: true
-
     axial_induction_model: Madsen
-
     deflection_model:
       name: None
-    
     turbulence_model:
       name: CrespoHernandez
-    
     superposition_model:
       ws_superposition: Linear
       ti_superposition: Quadratic
-
     rotor_averaging:
       grid: grid
       n_x_grid_points: 4
       n_y_grid_points: 4
-      background_averaging: grid
-      wake_averaging: axiwake9
+      background_averaging: center
+      wake_averaging: centre
       wind_speed_exponent_for_power: 3
       wind_speed_exponent_for_ct: 2
-
     blockage_model:
       name: None
 
@@ -66,7 +60,7 @@ attributes:
         output_variables: ['power', 'rotor_effective_velocity'] #'frequency'
     #
     flow_field:
-      report: True
+      report: False
       flow_nc_filename: flow_field.nc
       cases_run:
         all_occurences: True

foxes/engines/__init__.py

@@ -4,6 +4,7 @@ from .numpy import NumpyEngine
 from .single import SingleChunkEngine
 from .futures import ThreadsEngine, ProcessEngine
 from .mpi import MPIEngine
+from .ray import RayEngine
 
 from .dask import (
     DaskBaseEngine,

foxes/engines/dask.py

@@ -8,6 +8,9 @@ from foxes.utils import import_module
 import foxes.variables as FV
 import foxes.constants as FC
 
+dask = None
+distributed = None
+
 
 def delayed(func):
     """A dummy decorator"""
@@ -17,15 +20,19 @@ def delayed(func):
 def load_dask():
     """On-demand loading of the dask package"""
     global dask, ProgressBar, delayed
-    dask = import_module("dask", hint="pip install dask")
-    ProgressBar = import_module("dask.diagnostics", hint="pip install dask").ProgressBar
-    delayed = dask.delayed
+    if dask is None:
+        dask = import_module("dask", hint="pip install dask")
+        ProgressBar = import_module(
+            "dask.diagnostics", hint="pip install dask"
+        ).ProgressBar
+        delayed = dask.delayed
 
 
 def load_distributed():
     """On-demand loading of the distributed package"""
     global distributed
-    distributed = import_module("distributed", hint="pip install distributed")
+    if distributed is None:
+        distributed = import_module("distributed", hint="pip install distributed")
 
 
 class DaskBaseEngine(Engine):
@@ -337,13 +344,13 @@ class XArrayEngine(DaskBaseEngine):
         chunk_size_points0 = self.chunk_size_points
         n_states = model_data.sizes[FC.STATE]
         n_targets = point_data.sizes[FC.TARGET] if point_data is not None else 0
-        __, chunk_sizes_states, chunk_sizes_targets = self.calc_chunk_sizes(
+        chunk_sizes_states, chunk_sizes_targets = self.calc_chunk_sizes(
             n_states, n_targets
         )
         self.chunk_size_states = np.min(chunk_sizes_states)
         self.chunk_size_points = np.min(chunk_sizes_targets)
         self.print(
-            f"Selecting chunk_size_states = {self.chunk_size_states}, chunk_size_points = {self.chunk_size_points}"
+            f"{type(self).__name__}: Selecting chunk_size_states = {self.chunk_size_states}, chunk_size_points = {self.chunk_size_points}"
         )  # , level=2)
 
         # prepare:

foxes/engines/multiprocess.py

@@ -2,11 +2,14 @@ from foxes.utils import import_module
 
 from .pool import PoolEngine
 
+Pool = None
+
 
 def load_multiprocess():
     """On-demand loading of the multiprocess package"""
     global Pool
-    Pool = import_module("multiprocess", hint="pip install multiprocess").Pool
+    if Pool is None:
+        Pool = import_module("multiprocess", hint="pip install multiprocess").Pool
 
 
 class MultiprocessEngine(PoolEngine):
@@ -17,15 +20,9 @@ class MultiprocessEngine(PoolEngine):
 
     """
 
-    def initialize(self):
-        """
-        Initializes the engine.
-        """
-        load_multiprocess()
-        super().initialize()
-
     def _create_pool(self):
         """Creates the pool"""
+        load_multiprocess()
         self._pool = Pool(processes=self.n_procs)
 
     def _submit(self, f, *args, **kwargs):