foxes 0.6.1__py3-none-any.whl → 0.7__py3-none-any.whl

foxes/core/turbine_model.py

@@ -28,13 +28,13 @@ class TurbineModel(FarmDataModel):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------

foxes/core/turbine_type.py

@@ -60,6 +60,30 @@ class TurbineType(TurbineModel):
                 f"Turbine type '{self.name}': Unkown P_unit '{P_unit}', expecting {list(FC.P_UNITS.keys())}"
             )
 
+    def __repr__(self):
+        a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}"
+        return f"{type(self).__name__}({a})"
+
+    def modify_cutin(self, modify_ct, modify_P):
+        """
+        Modify the data such that a discontinuity
+        at cutin wind speed is avoided
+
+        Parameters
+        ----------
+        variable: str
+            The target variable
+        modify_ct: bool
+            Flag for modification of the ct curve
+        modify_P: bool
+            Flag for modification of the power curve
+
+        """
+        if modify_ct or modify_P:
+            raise NotImplementedError(
+                f"Turbine type '{self.name}': Continuous cutin not implemented for modify_ct = {modify_ct}, modify_P = {modify_P}"
+            )
+
     @classmethod
     def new(cls, ttype_type, *args, **kwargs):
         """

foxes/core/vertical_profile.py

@@ -27,14 +27,14 @@ class VerticalProfile(Model):
         return []
 
     @abstractmethod
-    def calculate(self, data, heights):
+    def calculate(self, tdata, heights):
         """
         Run the profile calculation.
 
         Parameters
         ----------
-        data: dict
-            The input data
+        tdata: dict
+            The target point data
         heights: numpy.ndarray
             The evaluation heights
 

foxes/core/wake_frame.py

@@ -51,29 +51,36 @@ class WakeFrame(Model):
         pass
 
     @abstractmethod
-    def get_wake_coos(self, algo, mdata, fdata, pdata, states_source_turbine):
+    def get_wake_coos(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+    ):
         """
-        Calculate wake coordinates.
+        Calculate wake coordinates of rotor points.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
 
         Returns
         -------
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
-            points, shape: (n_states, n_points, 3)
+            points, shape: (n_states, n_targets, n_tpoints, 3)
 
         """
         pass
@@ -82,10 +89,12 @@ class WakeFrame(Model):
         self,
         algo,
         variable,
-        states_source_turbine,
+        downwind_index,
         fdata,
-        pdata,
+        tdata,
+        target,
         states0=None,
+        upcast=False,
     ):
         """
         Return data that is required for computing the
@@ -97,27 +106,61 @@ class WakeFrame(Model):
             The algorithm, needed for data from previous iteration
         variable: str
             The variable, serves as data key
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        fdata: foxes.core.Data
+        downwind_index: int, optional
+            The index in the downwind order
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
+        tdata: foxes.core.TData
+            The target point data
+        target: str, optional
+            The dimensions identifier for the output,
+            FC.STATE_TURBINE, FC.STATE_TARGET,
+            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
-        n_points = pdata.n_points
-        s = np.arange(n_states) if states0 is None else states0
-
-        out = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        out[:] = fdata[variable][s, states_source_turbine][:, None]
+        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)
+        else:
+            raise ValueError(
+                f"Unsupported target '{target}', expcting '{FC.STATE_TURBINE}', '{FC.STATE_TARGET}', {FC.STATE_TARGET_TPOINT}"
+            )
 
-        return out
+        return out, dims
 
-    def get_centreline_points(self, algo, mdata, fdata, states_source_turbine, x):
+    def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
         """
         Gets the points along the centreline for given
         values of x.
@@ -126,13 +169,12 @@ class WakeFrame(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        downwind_index: int
+            The index in the downwind order
         x: numpy.ndarray
             The wake frame x coordinates, shape: (n_states, n_points)
 
@@ -151,7 +193,7 @@ class WakeFrame(Model):
         algo,
         mdata,
         fdata,
-        states_source_turbine,
+        downwind_index,
         variables,
         x,
         dx,
@@ -166,13 +208,12 @@ class WakeFrame(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        downwind_index: int
+            The index in the downwind order
         variables: list of str
             The variables to be integrated
         x: numpy.ndarray
@@ -208,22 +249,22 @@ class WakeFrame(Model):
         xs = np.arange(xmin, xmin + n_ix * dx, dx)
         xpts = np.zeros((n_states, n_steps), dtype=FC.DTYPE)
         xpts[:] = xs[None, 1:]
-        pts = self.get_centreline_points(
-            algo, mdata, fdata, states_source_turbine, xpts
-        )
+        pts = self.get_centreline_points(algo, mdata, fdata, downwind_index, xpts)
 
         # run ambient calculation:
-        pdata = Data.from_points(
+        tdata = Data.from_points(
             pts,
-            data={v: np.full((n_states, n_steps), np.nan, dtype=FC.DTYPE) for v in vrs},
-            dims={v: (FC.STATE, FC.POINT) for v in vrs},
+            data={
+                v: np.full((n_states, n_steps, 1), np.nan, dtype=FC.DTYPE) for v in vrs
+            },
+            dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in vrs},
         )
-        res = algo.states.calculate(algo, mdata, fdata, pdata)
-        pdata.update(res)
+        res = algo.states.calculate(algo, mdata, fdata, tdata)
+        tdata.update(res)
         amb2var = algo.get_model("SetAmbPointResults")()
         amb2var.initialize(algo, verbosity=0)
-        res = amb2var.calculate(algo, mdata, fdata, pdata)
-        pdata.update(res)
+        res = amb2var.calculate(algo, mdata, fdata, tdata)
+        tdata.update(res)
         del res, amb2var
 
         # find out if all vars ambient:
@@ -237,16 +278,16 @@ class WakeFrame(Model):
         if not ambient:
             wcalc = algo.get_model("PointWakesCalculation")(wake_models=wake_models)
             wcalc.initialize(algo, verbosity=0)
-            wsrc = states_source_turbine if self_wake else None
-            res = wcalc.calculate(algo, mdata, fdata, pdata, states_source_turbine=wsrc)
-            pdata.update(res)
+            wsrc = downwind_index if self_wake else None
+            res = wcalc.calculate(algo, mdata, fdata, tdata, downwind_index=wsrc)
+            tdata.update(res)
             del wcalc, res
 
         # collect integration results:
         iresults = np.zeros((n_states, n_ix, n_vars), dtype=FC.DTYPE)
         for vi, v in enumerate(variables):
             for i in range(n_steps):
-                iresults[:, i + 1, vi] = iresults[:, i, vi] + pdata[v][:, i] * dx
+                iresults[:, i + 1, vi] = iresults[:, i, vi] + tdata[v][:, i, 0] * dx
 
         # interpolate to x of interest:
         qts = np.zeros((n_states, n_points, 2), dtype=FC.DTYPE)

foxes/core/wake_model.py

@@ -1,6 +1,9 @@
 from abc import abstractmethod
+import numpy as np
 
 from foxes.utils import all_subclasses
+import foxes.variables as FV
+import foxes.constants as FC
 
 from .model import Model
 
@@ -13,70 +16,79 @@ class WakeModel(Model):
 
     """
 
-    @abstractmethod
-    def init_wake_deltas(self, algo, mdata, fdata, pdata, wake_deltas):
+    @property
+    def affects_downwind(self):
+        """
+        Flag for downwind or upwind effects
+        on other turbines
+
+        Returns
+        -------
+        dwnd: bool
+            Flag for downwind effects by this model
+
         """
-        Initialize wake delta storage.
+        return True
 
-        They are added on the fly to the wake_deltas dict.
+    def new_wake_deltas(self, algo, mdata, fdata, tdata):
+        """
+        Creates new empty wake delta arrays.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
+        tdata: foxes.core.TData
+            The target point data
+
+        Returns
+        -------
         wake_deltas: dict
-            The wake deltas storage, add wake deltas
-            on the fly. Keys: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_turbines, n_rpoints, ...)
 
         """
-        pass
+        return {FV.WS: np.zeros_like(tdata[FC.TARGETS][..., 0])}
 
     @abstractmethod
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         wake_coos,
         wake_deltas,
     ):
         """
-        Calculate the contribution to the wake deltas
-        by this wake model.
-
-        Modifies wake_deltas on the fly.
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
         wake_coos: numpy.ndarray
             The wake frame coordinates of the evaluation
-            points, shape: (n_states, n_points, 3)
+            points, shape: (n_states, n_targets, n_tpoints, 3)
         wake_deltas: dict
-            The wake deltas, are being modified ob the fly.
-            Key: Variable name str, for which the
-            wake delta applies, values: numpy.ndarray with
-            shape (n_states, n_points, ...)
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         pass
@@ -86,7 +98,6 @@ class WakeModel(Model):
         algo,
         mdata,
         fdata,
-        pdata,
         amb_results,
         wake_deltas,
     ):
@@ -99,21 +110,18 @@ class WakeModel(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
         amb_results: dict
             The ambient results, key: variable name str,
-            values: numpy.ndarray with shape (n_states, n_points)
+            values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
         wake_deltas: dict
-            The wake deltas, are being modified ob the fly.
-            Key: Variable name str, for which the wake delta
-            applies, values: numpy.ndarray with shape
-            (n_states, n_points, ...) before evaluation,
-            numpy.ndarray with shape (n_states, n_points) afterwards
+            The wake deltas object at the selected target
+            turbines. Key: variable str, value: numpy.ndarray
+            with shape (n_states, n_targets, n_tpoints)
 
         """
         pass
@@ -152,3 +160,26 @@ class WakeModel(Model):
                 )
             )
             raise KeyError(estr)
+
+
+class TurbineInductionModel(WakeModel):
+    """
+    Abstract base class for turbine induction models.
+
+    :group: core
+
+    """
+
+    @property
+    def affects_downwind(self):
+        """
+        Flag for downwind or upwind effects
+        on other turbines
+
+        Returns
+        -------
+        dwnd: bool
+            Flag for downwind effects by this model
+
+        """
+        return False

foxes/core/wake_superposition.py

@@ -17,48 +17,51 @@ class WakeSuperposition(Model):
     """
 
     @abstractmethod
-    def calc_wakes_plus_wake(
+    def add_wake(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
-        sel_sp,
+        tdata,
+        downwind_index,
+        st_sel,
         variable,
         wake_delta,
         wake_model_result,
     ):
         """
-        Add a wake delta to previous wake deltas.
+        Add a wake delta to previous wake deltas,
+        at rotor points.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
-        states_source_turbine: numpy.ndarray
-            For each state, one turbine index for the
-            wake causing turbine. Shape: (n_states,)
-        sel_sp: numpy.ndarray of bool
-            The selection of points, shape: (n_states, n_points)
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        st_sel: numpy.ndarray of bool
+            The selection of targets, shape: (n_states, n_targets)
         variable: str
             The variable name for which the wake deltas applies
         wake_delta: numpy.ndarray
-            The original wake deltas, shape: (n_states, n_points)
+            The original wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
         wake_model_result: numpy.ndarray
-            The new wake deltas of the selected points,
-            shape: (n_sel_sp,)
+            The new wake deltas of the selected rotors,
+            shape: (n_st_sel, n_tpoints, ...)
 
         Returns
         -------
         wdelta: numpy.ndarray
-            The updated wake deltas, shape: (n_states, n_points)
+            The updated wake deltas, shape:
+            (n_states, n_targets, n_tpoints, ...)
 
         """
         pass
@@ -69,7 +72,6 @@ class WakeSuperposition(Model):
         algo,
         mdata,
         fdata,
-        pdata,
         variable,
         amb_results,
         wake_delta,
@@ -82,24 +84,25 @@ class WakeSuperposition(Model):
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
+        mdata: foxes.core.MData
             The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
-        pdata: foxes.core.Data
-            The evaluation point data
         variable: str
             The variable name for which the wake deltas applies
         amb_results: numpy.ndarray
-            The ambient results, shape: (n_states, n_points)
+            The ambient results at targets,
+            shape: (n_states, n_targets, n_tpoints)
         wake_delta: numpy.ndarray
-            The wake deltas, shape: (n_states, n_points)
+            The wake deltas at targets, shape:
+            (n_states, n_targets, n_tpoints)
 
         Returns
         -------
         final_wake_delta: numpy.ndarray
             The final wake delta, which will be added to the ambient
-            results by simple plus operation. Shape: (n_states, n_points)
+            results by simple plus operation. Shape:
+            (n_states, n_targets, n_tpoints)
 
         """
         pass

foxes/input/farm_layout/__init__.py

@@ -8,3 +8,4 @@ from .from_json import add_from_json
 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

foxes/input/farm_layout/from_random.py

@@ -0,0 +1,49 @@
+import numpy as np
+
+from foxes.utils import random_xy_square
+from foxes.core import Turbine
+
+
+def add_random(
+    farm,
+    n_turbines,
+    min_dist,
+    centre=[0, 0],
+    seed=None,
+    verbosity=1,
+    **turbine_parameters,
+):
+    """
+    Add turbines that lie randomly within a square
+
+    Parameters
+    ----------
+    farm: foxes.WindFarm
+        The wind farm
+    n_turbines: int
+        The number of turbines
+    min_dist: float
+        The minimal distance between turbines
+    centre: array-like
+        The (x, y) coordinates of the mean
+    seed: int, optional
+        The random seed
+    verbosity: int
+        The verbosity level, 0 = silent
+    turbine_parameters: dict, optional
+        Additional parameters are forwarded to the WindFarm.add_turbine().
+
+    :group: input.farm_layout
+
+    """
+    xy = random_xy_square(n_turbines, min_dist, seed=seed, verbosity=verbosity)
+    xy += np.array(centre)[None, :]
+
+    for i in range(len(xy)):
+        farm.add_turbine(
+            Turbine(
+                xy=xy[i],
+                **turbine_parameters,
+            ),
+            verbosity=verbosity,
+        )

foxes/input/states/__init__.py

@@ -8,4 +8,4 @@ from .states_table import StatesTable, Timeseries, TabStates
 from .field_data_nc import FieldDataNC
 from .multi_height import MultiHeightStates, MultiHeightTimeseries
 
-from .create import create_random_abl_states
+from . import create

foxes/input/states/create/__init__.py

@@ -1 +1,2 @@
 from .random_abl_states import create_random_abl_states, write_random_abl_states
+from .random_timeseries import random_timseries_data