foxes 1.3__py3-none-any.whl → 1.5__py3-none-any.whl

foxes/core/wake_model.py

@@ -1,11 +1,10 @@
 from abc import abstractmethod
-import numpy as np
 
 from foxes.utils import new_instance
 import foxes.variables as FV
-import foxes.constants as FC
 
 from .model import Model
+from .wake_superposition import WindVectorWakeSuperposition
 
 
 class WakeModel(Model):
@@ -16,6 +15,26 @@ class WakeModel(Model):
 
     """
 
+    def __init__(self):
+        """
+        Constructor.
+        """
+        super().__init__()
+        self._has_uv = False
+
+    @property
+    def affects_ws(self):
+        """
+        Flag for wind speed wake models
+
+        Returns
+        -------
+        dws: bool
+            If True, this model affects wind speed
+
+        """
+        return False
+
     @property
     def affects_downwind(self):
         """
@@ -30,6 +49,38 @@ class WakeModel(Model):
         """
         return True
 
+    @property
+    def has_uv(self):
+        """
+        This model uses wind vector data
+
+        Returns
+        -------
+        hasuv: bool
+            Flag for wind vector data
+
+        """
+        return self._has_uv
+
+    def initialize(self, algo, verbosity=0, force=False):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
+
+        """
+        if self.affects_ws and algo.wake_deflection.has_uv:
+            self._has_uv = True
+        super().initialize(algo, verbosity, force)
+
+    @abstractmethod
     def new_wake_deltas(self, algo, mdata, fdata, tdata):
         """
         Creates new empty wake delta arrays.
@@ -52,7 +103,7 @@ class WakeModel(Model):
             wake deltas, shape: (n_states, n_targets, n_tpoints, ...)
 
         """
-        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
+        pass
 
     @abstractmethod
     def contribute(
@@ -98,7 +149,7 @@ class WakeModel(Model):
         algo,
         mdata,
         fdata,
-        amb_results,
+        tdata,
         wake_deltas,
     ):
         """
@@ -114,10 +165,8 @@ class WakeModel(Model):
             The model data
         fdata: foxes.core.FData
             The farm data
-        amb_results: dict
-            The ambient results, key: variable name str,
-            values: numpy.ndarray with shape
-            (n_states, n_targets, n_tpoints)
+        tdata: foxes.core.TData
+            The target point data
         wake_deltas: dict
             The wake deltas object at the selected target
             turbines. Key: variable str, value: numpy.ndarray
@@ -144,7 +193,171 @@ class WakeModel(Model):
         return new_instance(cls, wmodel_type, *args, **kwargs)
 
 
-class TurbineInductionModel(WakeModel):
+class SingleTurbineWakeModel(WakeModel):
+    """
+    Abstract base class for wake models that represent
+    a single turbine wake
+
+    Single turbine wake models depend on superposition models.
+
+    Attributes
+    ----------
+    wind_superposition: str
+        The wind superposition model name (vector or compenent model),
+        will be looked up in model book
+    other_superpositions: dict
+        The superpositions for other than (ws, wd) variables.
+        Key: variable name str, value: The wake superposition
+        model name, will be looked up in model book
+    vec_superp: foxes.core.WindVectorWakeSuperposition or None
+        The wind vector wake superposition model
+    superp: dict
+        The superposition dict, key: variable name str,
+        value: `foxes.core.WakeSuperposition`
+
+    :group: models.wake_models
+
+    """
+
+    def __init__(self, wind_superposition=None, other_superpositions={}):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        wind_superposition: str, optional
+            The wind superposition model name (vector or compenent model),
+            will be looked up in model book
+        other_superpositions: dict
+            The superpositions for other than (ws, wd) variables.
+            Key: variable name str, value: The wake superposition
+            model name, will be looked up in model book
+
+        """
+        super().__init__()
+        self.wind_superposition = wind_superposition
+        self.other_superpositions = other_superpositions
+        self.vec_superp = None
+        self.superp = {}
+
+        for v in [FV.WS, FV.WD]:
+            assert v not in other_superpositions, (
+                f"Wake model '{self.name}': Found variable '{v}' among 'other_superposition' keyword, use 'wind_superposition' instead"
+            )
+
+        self.__has_vector_superp = False
+
+    @property
+    def has_vector_wind_superp(self):
+        """
+        This model uses a wind vector superposition
+
+        Returns
+        -------
+        hasv: bool
+            Flag for wind vector superposition
+
+        """
+        return self.__has_vector_superp
+
+    def sub_models(self):
+        """
+        List of all sub-models
+
+        Returns
+        -------
+        smdls: list of foxes.core.Model
+            Names of all sub models
+
+        """
+        w = [self.vec_superp] if self.vec_superp is not None else []
+        return w + list(self.superp.values())
+
+    def initialize(self, algo, verbosity=0, force=False):
+        """
+        Initializes the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        verbosity: int
+            The verbosity level, 0 = silent
+        force: bool
+            Overwrite existing data
+
+        """
+        self.superp = {
+            v: algo.mbook.wake_superpositions[s]
+            for v, s in self.other_superpositions.items()
+        }
+
+        if self.wind_superposition is not None:
+            self.vec_superp = algo.mbook.wake_superpositions[self.wind_superposition]
+            self.__has_vector_superp = isinstance(
+                self.vec_superp, WindVectorWakeSuperposition
+            )
+            if self.__has_vector_superp:
+                self._has_uv = True
+            else:
+                self.superp[FV.WS] = self.vec_superp
+                self.vec_superp = None
+
+        super().initialize(algo, verbosity, force)
+
+    def finalize_wake_deltas(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        wake_deltas,
+    ):
+        """
+        Finalize the wake calculation.
+
+        Modifies wake_deltas on the fly.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        wake_deltas: dict
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
+
+        """
+        for v in wake_deltas.keys():
+            if v != FV.UV:
+                try:
+                    wake_deltas[v] = self.superp[v].calc_final_wake_delta(
+                        algo, mdata, fdata, tdata, v, wake_deltas[v]
+                    )
+                except KeyError:
+                    raise KeyError(
+                        f"Wake model '{self.name}': Variable '{v}' appears to be modified, missing superposition model"
+                    )
+
+        if FV.UV in wake_deltas:
+            assert self.has_vector_wind_superp, (
+                f"{self.name}: Expecting wind vector superposition, got '{self.wind_superposition}'"
+            )
+            dws, dwd = self.vec_superp.calc_final_wake_delta_uv(
+                algo, mdata, fdata, tdata, wake_deltas.pop(FV.UV)
+            )
+
+            wake_deltas[FV.WS] = dws
+            wake_deltas[FV.WD] = dwd
+
+
+class TurbineInductionModel(SingleTurbineWakeModel):
     """
     Abstract base class for turbine induction models.
 

foxes/core/wake_superposition.py

@@ -74,8 +74,8 @@ class WakeSuperposition(Model):
         algo,
         mdata,
         fdata,
+        tdata,
         variable,
-        amb_results,
         wake_delta,
     ):
         """
@@ -90,11 +90,10 @@ class WakeSuperposition(Model):
             The model data
         fdata: foxes.core.FData
             The farm data
+        tdata: foxes.core.TData
+            The target point data
         variable: str
             The variable name for which the wake deltas applies
-        amb_results: numpy.ndarray
-            The ambient results at targets,
-            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
             The wake deltas at targets, shape:
             (n_states, n_targets, n_tpoints)
@@ -125,3 +124,122 @@ class WakeSuperposition(Model):
 
         """
         return new_instance(cls, superp_type, *args, **kwargs)
+
+
+class WindVectorWakeSuperposition(Model):
+    """
+    Base class for wind vector superposition.
+
+    Note that it is a matter of the wake model
+    if superposition models are used, or if the
+    wake model computes the total wake result by
+    other means.
+
+    :group: core
+
+    """
+
+    @abstractmethod
+    def add_wake_vector(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        st_sel,
+        wake_delta_uv,
+        wake_model_result_uv,
+    ):
+        """
+        Add a wake delta vector to previous wake deltas,
+        at rotor points.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
+        wake_delta_uv: numpy.ndarray
+            The original wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, 2)
+        wake_model_result_uv: numpy.ndarray
+            The new wind vector wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, 2, ...)
+
+        Returns
+        -------
+        wdelta_uv: numpy.ndarray
+            The updated wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
+
+        """
+        pass
+
+    @abstractmethod
+    def calc_final_wake_delta_uv(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        wake_delta_uv,
+    ):
+        """
+        Calculate the final wind vector wake delta after adding all
+        contributions.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        wake_delta_uv: numpy.ndarray
+            The original wind vector wake deltas, shape:
+            (n_states, n_targets, n_tpoints, 2)
+
+        Returns
+        -------
+        final_wake_delta_ws: numpy.ndarray
+            The final wind speed wake delta, which will be added to
+            the ambient results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
+        final_wake_delta_wd: numpy.ndarray
+            The final wind direction wake delta, which will be added to
+            the ambient results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
+
+        """
+        pass
+
+    @classmethod
+    def new(cls, superp_type, *args, **kwargs):
+        """
+        Run-time wind wake superposition model factory.
+
+        Parameters
+        ----------
+        superp_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+        return new_instance(cls, superp_type, *args, **kwargs)

foxes/core/wind_farm.py

@@ -124,12 +124,12 @@ class WindFarm:
 
         if extra_space is not None:
             if isinstance(extra_space, str):
-                assert (
-                    algo is not None
-                ), f"WindFarm: require algo argument for extra_space '{extra_space}'"
-                assert (
-                    len(extra_space) > 1 and extra_space[-1] == "D"
-                ), f"Expecting float or str like '2.5D', got extra_space = '{extra_space}'"
+                assert algo is not None, (
+                    f"WindFarm: require algo argument for extra_space '{extra_space}'"
+                )
+                assert len(extra_space) > 1 and extra_space[-1] == "D", (
+                    f"Expecting float or str like '2.5D', got extra_space = '{extra_space}'"
+                )
                 extra_space = float(extra_space[:-1])
                 rds = self.get_rotor_diameters(algo)
                 if xy is None:

foxes/data/__init__.py

@@ -2,5 +2,10 @@
 Static data collection.
 """
 
-from .parse import parse_Pct_file_name, parse_Pct_two_files
-from .static_data import FARM, STATES, PCTCURVE, StaticData
+from .parse import parse_Pct_file_name as parse_Pct_file_name
+from .parse import parse_Pct_two_files as parse_Pct_two_files
+
+from .static_data import FARM as FARM
+from .static_data import STATES as STATES
+from .static_data import PCTCURVE as PCTCURVE
+from .static_data import StaticData as StaticData

foxes/data/states/weibull_sectors_12.csv

@@ -0,0 +1,13 @@
+sector,wind_direction,sector_probability,weibull_a,weibull_k,turbulence_intensity
+0,0.0,0.0359715203597152,9.176929,2.392578,0.1
+1,30.0,0.0394868203948682,9.782334,2.447266,0.1
+2,60.0,0.0516739505167395,9.531809,2.412109,0.1
+3,90.0,0.07000154070001541,9.909545,2.591797,0.1
+4,120.0,0.08364547083645471,10.04269,2.755859,0.1
+5,150.0,0.064348500643485,9.593921,2.595703,0.1
+6,180.0,0.0864319408643194,9.584007,2.583984,0.1
+7,210.0,0.117705101177051,10.51499,2.548828,0.1
+8,240.0,0.151575701515757,11.39895,2.470703,0.1
+9,270.0,0.14737920147379202,11.68746,2.607422,0.1
+10,300.0,0.10012050100120501,11.63732,2.626953,0.1
+11,330.0,0.051659750516597505,10.08803,2.326172,0.1

foxes/engines/__init__.py

@@ -1,17 +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 .ray import RayEngine
+from .pool import PoolEngine as PoolEngine
+from .multiprocess import MultiprocessEngine as MultiprocessEngine
+from .numpy import NumpyEngine as NumpyEngine
+from .single import SingleChunkEngine as SingleChunkEngine
+from .mpi import MPIEngine as MPIEngine
+from .ray import RayEngine as RayEngine
+from .default import DefaultEngine as DefaultEngine
 
-from .dask import (
-    DaskBaseEngine,
-    XArrayEngine,
-    DaskEngine,
-    LocalClusterEngine,
-    SlurmClusterEngine,
-)
+from .futures import ThreadsEngine as ThreadsEngine
+from .futures import ProcessEngine as ProcessEngine
 
-from .default import DefaultEngine
+from .dask import DaskBaseEngine as DaskBaseEngine
+from .dask import XArrayEngine as XArrayEngine
+from .dask import DaskEngine as DaskEngine
+from .dask import LocalClusterEngine as LocalClusterEngine
+from .dask import SlurmClusterEngine as SlurmClusterEngine

foxes/engines/dask.py

@@ -199,7 +199,6 @@ def _run_as_ufunc(
     out_coords,
     calc_pars,
     init_vars,
-    ensure_variables,
     calculate,
 ):
     """
@@ -222,19 +221,28 @@ def _run_as_ufunc(
         if i == 0:
             data.append(
                 MData(
-                    data=hdata, dims=hdims, loop_dims=loop_dims, states_i0=state_inds[0]
+                    data=hdata,
+                    dims=hdims,
+                    # loop_dims=loop_dims,
+                    states_i0=state_inds[0],
                 )
             )
         elif i == 1:
             data.append(
                 FData(
-                    data=hdata, dims=hdims, loop_dims=loop_dims, states_i0=state_inds[0]
+                    data=hdata,
+                    dims=hdims,
+                    # loop_dims=loop_dims,
+                    states_i0=state_inds[0],
                 )
             )
         elif i == 2:
             data.append(
                 TData(
-                    data=hdata, dims=hdims, loop_dims=loop_dims, states_i0=state_inds[0]
+                    data=hdata,
+                    dims=hdims,
+                    # loop_dims=loop_dims,
+                    states_i0=state_inds[0],
                 )
             )
         else:
@@ -246,13 +254,13 @@ def _run_as_ufunc(
 
     # deduce output shape:
     oshape = []
-    for li, l in enumerate(out_coords):
+    for li, ld in enumerate(out_coords):
         for i, dims in enumerate(ldims):
-            if l in dims:
-                oshape.append(ldata[i].shape[dims.index(l)])
+            if ld in dims:
+                oshape.append(ldata[i].shape[dims.index(ld)])
                 break
         if len(oshape) != li + 1:
-            raise ValueError(f"Failed to find loop dimension")
+            raise ValueError("Failed to find loop dimension")
 
     # add zero output data arrays:
     odims = {v: tuple(out_coords) for v in out_vars}
@@ -267,14 +275,31 @@ def _run_as_ufunc(
     }
 
     if len(data) == 1:
-        data.append(FData(odata, odims, loop_dims, states_i0=state_inds[0]))
+        data.append(
+            FData(
+                odata,
+                odims,
+                # loop_dims,
+                states_i0=state_inds[0],
+            )
+        )
     else:
         odata.update(data[-1])
         odims.update(data[-1].dims)
         if len(data) == 2:
-            data[-1] = FData(odata, odims, loop_dims, states_i0=state_inds[0])
+            data[-1] = FData(
+                odata,
+                odims,
+                # loop_dims,
+                states_i0=state_inds[0],
+            )
         else:
-            data[-1] = TData(odata, odims, loop_dims, states_i0=state_inds[0])
+            data[-1] = TData(
+                odata,
+                odims,
+                # loop_dims,
+                states_i0=state_inds[0],
+            )
     del odims, odata
 
     # link chunk state indices from mdata to fdata and tdata:
@@ -288,7 +313,6 @@ def _run_as_ufunc(
         data[1].dims[FV.WEIGHT] = data[0].dims[FV.WEIGHT]
 
     # run model calculation:
-    ensure_variables(algo, *data)
     results = calculate(algo, *data, **calc_pars)
 
     # replace missing results by first input data with matching shape:
@@ -359,7 +383,7 @@ class XArrayEngine(DaskBaseEngine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         out_vars=[],
@@ -382,9 +406,9 @@ class XArrayEngine(DaskBaseEngine):
             should be run
         model_data: xarray.Dataset
             The initial model data
-        farm_data: xarray.Dataset
+        farm_data: xarray.Dataset, optional
             The initial farm data
-        point_data: xarray.Dataset
+        point_data: xarray.Dataset, optional
             The initial point data
         out_vars: list of str, optional
             Names of the output variables
@@ -451,7 +475,6 @@ class XArrayEngine(DaskBaseEngine):
             if d is not None
         ]
         for ds in data:
-
             hvarsl = [v for v, d in ds.items() if len(loopd.intersection(d.dims))]
             ldata += [ds[v] for v in hvarsl]
             ldims += [ds[v].dims for v in hvarsl]
@@ -512,7 +535,6 @@ class XArrayEngine(DaskBaseEngine):
             out_coords=out_coords,
             calc_pars=calc_pars,
             init_vars=ivars,
-            ensure_variables=model.ensure_variables,
             calculate=model.calculate,
         )
 
@@ -734,7 +756,7 @@ def _run_on_cluster(
     mdata = MData(
         data={names[i]: data[i] for i in range(mdata_size)},
         dims={names[i]: dims[i] for i in range(mdata_size)},
-        loop_dims=loop_dims[0],
+        # loop_dims=loop_dims[0],
         states_i0=i0_states,
     )
 
@@ -742,7 +764,7 @@ def _run_on_cluster(
     fdata = FData(
         data={names[i]: data[i].copy() for i in range(mdata_size, fdata_end)},
         dims={names[i]: dims[i] for i in range(mdata_size, fdata_end)},
-        loop_dims=loop_dims[1],
+        # loop_dims=loop_dims[1],
         states_i0=i0_states,
     )
 
@@ -751,7 +773,7 @@ def _run_on_cluster(
         tdata = TData(
             data={names[i]: data[i].copy() for i in range(fdata_end, len(data))},
             dims={names[i]: dims[i] for i in range(fdata_end, len(data))},
-            loop_dims=loop_dims[2],
+            # loop_dims=loop_dims[2],
             states_i0=i0_states,
         )
 

foxes/engines/default.py

@@ -60,7 +60,7 @@ class DefaultEngine(Engine):
         self,
         algo,
         model,
-        model_data=None,
+        model_data,
         farm_data=None,
         point_data=None,
         **kwargs,
@@ -75,7 +75,7 @@ class DefaultEngine(Engine):
         model: foxes.core.DataCalcModel
             The model that whose calculate function
             should be run
-        model_data: xarray.Dataset, optional
+        model_data: xarray.Dataset
             The initial model data
         farm_data: xarray.Dataset, optional
             The initial farm data