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

foxes/core/partial_wakes_model.py

@@ -23,54 +23,33 @@ class PartialWakesModel(Model):
 
     """
 
-    def __init__(self, wake_models=None, wake_frame=None):
+    @abstractmethod
+    def get_wake_points(self, algo, mdata, fdata):
         """
-        Constructor.
+        Get the wake calculation points, and their
+        weights.
 
         Parameters
         ----------
-        wake_models: list of foxes.core.WakeModel
-            The wake model selection, None for all
-            from algorithm.
-        wake_frame: foxes.core.WakeFrame, optional
-            The wake frame, None takes from algorithm
-
-        """
-        super().__init__()
-
-        self._wmodels = wake_models
-        self._wframe = wake_frame
-
-    def sub_models(self):
-        """
-        List of all sub-models
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.Data
+            The model data
+        fdata: foxes.core.Data
+            The farm data
 
         Returns
         -------
-        smdls: list of foxes.core.Model
-            Names of all sub models
-
-        """
-        return self.wake_models + [self.wake_frame]
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
+        rpoints: numpy.ndarray
+            The wake calculation points, shape:
+            (n_states, n_turbines, n_tpoints, 3)
+        rweights: numpy.ndarray
+            The target point weights, shape: (n_tpoints,)
 
         """
-        self.wake_models = algo.wake_models if self._wmodels is None else self._wmodels
-        self.wake_frame = algo.wake_frame if self._wframe is None else self._wframe
-        super().initialize(algo, verbosity)
+        pass
 
-    @abstractmethod
-    def new_wake_deltas(self, algo, mdata, fdata):
+    def new_wake_deltas(self, algo, mdata, fdata, tdata, wmodel):
         """
         Creates new initial wake deltas, filled
         with zeros.
@@ -83,88 +62,112 @@ class PartialWakesModel(Model):
             The model data
         fdata: foxes.core.Data
             The farm data
+        tdata: foxes.core.Data
+            The target point data
+        wmodel: foxes.core.WakeModel
+            The wake model
+        wpoints: numpy.ndarray
+            The wake evaluation points,
+            shape: (n_states, n_turbines, n_tpoints, 3)
 
         Returns
         -------
         wake_deltas: dict
-            Keys: Variable name str, values: any
-        pdata: foxes.core.Data
-            The evaluation point data
+            Key: variable name, value: The zero filled
+            wake deltas, shape: (n_states, n_turbines, n_tpoints, ...)
 
         """
-        pass
+        return wmodel.new_wake_deltas(algo, mdata, fdata, tdata)
 
-    @abstractmethod
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         wake_deltas,
+        wmodel,
     ):
         """
-        Modifies wake deltas by contributions from the
-        specified wake source turbines.
+        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 of int
-            For each state, one turbine index corresponding
-            to the wake causing turbine. Shape: (n_states,)
-        wake_deltas: Any
-            The wake deltas object created by the
-            `new_wake_deltas` function
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
+        wmodel: foxes.core.WakeModel
+            The wake model
 
         """
-        pass
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
 
     @abstractmethod
-    def evaluate_results(
+    def finalize_wakes(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
+        tdata,
+        amb_res,
+        rpoint_weights,
         wake_deltas,
-        states_turbine,
-        amb_res=None,
+        wmodel,
+        downwind_index,
     ):
         """
-        Updates the farm data according to the wake
-        deltas.
+        Updates the wake_deltas at the selected target
+        downwind index.
+
+        Modifies wake_deltas on the fly.
 
         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
-            Modified in-place by this function
-        pdata: foxes.core.Data
-            The evaluation point data
-        wake_deltas: Any
-            The wake deltas object, created by the
-            `new_wake_deltas` function and filled
-            by `contribute_to_wake_deltas`
-        states_turbine: numpy.ndarray of int
-            For each state, the index of one turbine
-            for which to evaluate the wake deltas.
-            Shape: (n_states,)
-        amb_res: dict, optional
-            Ambient states results. Keys: var str, values:
-            numpy.ndarray of shape (n_states, n_points)
+        tdata: foxes.core.Data
+            The target point data
+        amb_res: dict
+            The ambient results at the target points
+            of all rotors. Key: variable name, value
+            np.ndarray of shape:
+            (n_states, n_turbines, n_rotor_points)
+        rpoint_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: np.ndarray of shape
+            (n_states, n_turbines, n_tpoints)
+        wmodel: foxes.core.WakeModel
+            The wake model
+        downwind_index: int
+            The index in the downwind order
+
+        Returns
+        -------
+        final_wake_deltas: dict
+            The final wake deltas at the selected downwind
+            turbines. Key: variable name, value: np.ndarray
+            of shape (n_states, n_rotor_points)
 
         """
         pass

foxes/core/point_data_model.py

@@ -1,3 +1,4 @@
+import numpy as np
 from abc import abstractmethod
 
 from .data_calc_model import DataCalcModel
@@ -26,8 +27,33 @@ class PointDataModel(DataCalcModel):
         """
         return []
 
+    def ensure_variables(self, algo, mdata, fdata, tdata):
+        """
+        Add variables to tdata, initialized with NaN
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.Data
+            The model data
+        fdata: foxes.core.Data
+            The farm data
+        tdata: foxes.core.Data
+            The target point data
+
+        """
+        for v in self.output_point_vars(algo):
+            if v not in tdata:
+                tdata[v] = np.full(
+                    (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                    np.nan,
+                    dtype=FC.DTYPE,
+                )
+                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
+
     @abstractmethod
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -38,18 +64,19 @@ class PointDataModel(DataCalcModel):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
         pass
@@ -78,14 +105,19 @@ class PointDataModel(DataCalcModel):
             The calculation results
 
         """
-        return super().run_calculation(
+        results = super().run_calculation(
             algo,
             *data,
             out_vars=out_vars,
-            loop_dims=[FC.STATE, FC.POINT],
-            out_core_vars=[FC.VARS],
+            loop_dims=[FC.STATE, FC.TARGET],
+            out_core_vars=[FC.TPOINT, FC.VARS],
             **calc_pars,
         )
+        if results.sizes[FC.TPOINT] != 1:
+            raise ValueError(
+                f"PointDataModel '{self.name}': Expecting dimension '{FC.TPOINT}' of size 1, found {results.sizes[FC.TPOINT]}"
+            )
+        return results.sel({FC.TPOINT: 0}).rename({FC.TARGET: FC.POINT})
 
     def __add__(self, m):
         if isinstance(m, list):
@@ -170,7 +202,7 @@ class PointDataModelList(PointDataModel):
             ovars += m.output_point_vars(algo)
         return list(dict.fromkeys(ovars))
 
-    def calculate(self, algo, mdata, fdata, pdata, parameters=None):
+    def calculate(self, algo, mdata, fdata, tdata, parameters=None):
         """ "
         The main model calculation.
 
@@ -181,12 +213,12 @@ class PointDataModelList(PointDataModel):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
         parameters: list of dict, optional
             A list of parameter dicts, one for each model
 
@@ -194,7 +226,8 @@ class PointDataModelList(PointDataModel):
         -------
         results: dict
             The resulting data, keys: output variable str.
-            Values: numpy.ndarray with shape (n_states, n_points)
+            Values: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints)
 
         """
         if parameters is None:
@@ -209,7 +242,7 @@ class PointDataModelList(PointDataModel):
             )
 
         for mi, m in enumerate(self.models):
-            res = m.calculate(algo, mdata, fdata, pdata, **parameters[mi])
-            pdata.update(res)
+            res = m.calculate(algo, mdata, fdata, tdata, **parameters[mi])
+            tdata.update(res)
 
-        return {v: pdata[v] for v in self.output_point_vars(algo)}
+        return {v: tdata[v] for v in self.output_point_vars(algo)}

foxes/core/rotor_model.py

@@ -6,7 +6,7 @@ import foxes.constants as FC
 from .farm_data_model import FarmDataModel
 from foxes.utils import wd2uv, uv2wd, all_subclasses
 
-from .data import Data
+from .data import TData
 
 
 class RotorModel(FarmDataModel):
@@ -41,6 +41,10 @@ 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.
@@ -118,9 +122,9 @@ class RotorModel(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
 
         Returns
@@ -152,17 +156,17 @@ class RotorModel(FarmDataModel):
 
         return points
 
-    def _set_res(self, fdata, v, res, stsel):
+    def _set_res(self, fdata, v, res, downwind_index):
         """
         Helper function for results setting
         """
-        if stsel is None:
+        if downwind_index is None:
             fdata[v] = res.copy()
         elif res.shape[1] == 1:
-            fdata[v][stsel] = res[:, 0]
+            fdata[v][:, downwind_index] = res[:, 0]
         else:
             raise ValueError(
-                f"Rotor model '{self.name}': states_turbine is not None, but results shape for '{v}' has more than one turbine, {res.shape}"
+                f"Rotor model '{self.name}': downwind_index is not None, but results shape for '{v}' has more than one turbine, {res.shape}"
             )
 
     def eval_rpoint_results(
@@ -170,9 +174,9 @@ class RotorModel(FarmDataModel):
         algo,
         mdata,
         fdata,
-        rpoint_results,
+        tdata,
         weights,
-        states_turbine=None,
+        downwind_index=None,
         copy_to_ambient=False,
     ):
         """
@@ -188,32 +192,21 @@ class RotorModel(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
-        rpoint_results: dict
-            The results at rotor points. Keys: variable str.
-            Values: numpy.ndarray, shape if `states_turbine`
-            is None: (n_states, n_turbines, n_rpoints).
-            Else: (n_states, 1, n_rpoints)
+        tdata: foxes.core.TData
+            The target point data
         weights: numpy.ndarray
             The rotor point weights, shape: (n_rpoints,)
-        states_turbine: numpy.ndarray of int, optional
-            The turbine indices, one per state. Shape: (n_states,)
-        copy_to_ambient: bool, optional
+        downwind_index: int, optional
+            The index in the downwind order
+        copy_to_ambient: bool
             If `True`, the fdata results are copied to ambient
             variables after calculation
 
         """
-
-        n_states = mdata.n_states
-        n_turbines = algo.n_turbines
-        if states_turbine is not None:
-            stsel = (np.arange(n_states), states_turbine)
-        else:
-            stsel = None
-
         uvp = None
         uv = None
         if (
@@ -224,8 +217,8 @@ class RotorModel(FarmDataModel):
             or FV.REWS2 in self.calc_vars
             or FV.REWS3 in self.calc_vars
         ):
-            wd = rpoint_results[FV.WD]
-            ws = rpoint_results[FV.WS]
+            wd = tdata[FV.WD]
+            ws = tdata[FV.WS]
             uvp = wd2uv(wd, ws, axis=-1)
             uv = np.einsum("stpd,p->std", uvp, weights)
 
@@ -235,12 +228,12 @@ class RotorModel(FarmDataModel):
             if v == FV.WD or v == FV.YAW:
                 if wd is None:
                     wd = uv2wd(uv, axis=-1)
-                self._set_res(fdata, v, wd, stsel)
+                self._set_res(fdata, v, wd, downwind_index)
                 vdone.append(v)
 
             elif v == FV.WS:
                 ws = np.linalg.norm(uv, axis=-1)
-                self._set_res(fdata, v, ws, stsel)
+                self._set_res(fdata, v, ws, downwind_index)
                 del ws
                 vdone.append(v)
         del uv, wd
@@ -250,17 +243,17 @@ class RotorModel(FarmDataModel):
             or FV.REWS2 in self.calc_vars
             or FV.REWS3 in self.calc_vars
         ):
-            if stsel is None:
+            if downwind_index is None:
                 yaw = fdata[FV.YAW].copy()
             else:
-                yaw = fdata[FV.YAW][stsel][:, None]
+                yaw = fdata[FV.YAW][:, downwind_index, None]
             nax = wd2uv(yaw, axis=-1)
             wsp = np.einsum("stpd,std->stp", uvp, nax)
 
             for v in self.calc_vars:
                 if v == FV.REWS:
                     rews = np.maximum(np.einsum("stp,p->st", wsp, weights), 0.0)
-                    self._set_res(fdata, v, rews, stsel)
+                    self._set_res(fdata, v, rews, downwind_index)
                     del rews
                     vdone.append(v)
 
@@ -278,7 +271,7 @@ class RotorModel(FarmDataModel):
                         )
                     else:
                         rews2 = np.sqrt(np.einsum("stp,p->st", wsp**2, weights))
-                    self._set_res(fdata, v, rews2, stsel)
+                    self._set_res(fdata, v, rews2, downwind_index)
                     del rews2
                     vdone.append(v)
 
@@ -293,7 +286,7 @@ class RotorModel(FarmDataModel):
                         ) ** (1.0 / 3.0)
                     else:
                         rews3 = (np.einsum("stp,p->st", wsp**3, weights)) ** (1.0 / 3.0)
-                    self._set_res(fdata, v, rews3, stsel)
+                    self._set_res(fdata, v, rews3, downwind_index)
                     del rews3
                     vdone.append(v)
 
@@ -302,8 +295,8 @@ class RotorModel(FarmDataModel):
 
         for v in self.calc_vars:
             if v not in vdone:
-                res = np.einsum("stp,p->st", rpoint_results[v], weights)
-                self._set_res(fdata, v, res, stsel)
+                res = np.einsum("stp,p->st", tdata[v], weights)
+                self._set_res(fdata, v, res, downwind_index)
             if copy_to_ambient and v in FV.var2amb:
                 fdata[FV.var2amb[v]] = fdata[v].copy()
 
@@ -317,7 +310,7 @@ class RotorModel(FarmDataModel):
         store_rpoints=False,
         store_rweights=False,
         store_amb_res=False,
-        states_turbine=None,
+        downwind_index=None,
     ):
         """
         Calculate ambient rotor effective results.
@@ -326,9 +319,9 @@ class RotorModel(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
         rpoints: numpy.ndarray, optional
             The rotor points, or None for automatic for
@@ -343,8 +336,8 @@ class RotorModel(FarmDataModel):
         store_amb_res: bool, optional
             Switch for storing ambient rotor point reults as they
             come from the states to mdata
-        states_turbine: numpy.ndarray of int, optional
-            The turbine indices, one per state. Shape: (n_states,)
+        downwind_index: int, optional
+            Only compute for index in the downwind order
 
         Returns
         -------
@@ -355,56 +348,45 @@ class RotorModel(FarmDataModel):
         """
 
         if rpoints is None:
-            rpoints = mdata.get(FC.RPOINTS, self.get_rotor_points(algo, mdata, fdata))
+            rpoints = mdata.get(self.RPOINTS, self.get_rotor_points(algo, mdata, fdata))
         if store_rpoints:
-            mdata[FC.RPOINTS] = rpoints
-            mdata.dims[FC.RPOINTS] = (FC.STATE, FC.TURBINE, FC.RPOINT, FC.XYH)
-            self.data_to_store(FC.RPOINTS, algo, mdata)
+            mdata[self.RPOINTS] = rpoints
+            mdata.dims[self.RPOINTS] = (FC.STATE, FC.TURBINE, FC.TPOINT, FC.XYH)
+            self.data_to_store(self.RPOINTS, algo, mdata)
 
-        if states_turbine is not None:
-            n_states = mdata.n_states
-            stsel = (np.arange(n_states), states_turbine)
-            rpoints = rpoints[stsel][:, None]
-        n_states, n_turbines, n_rpoints, __ = rpoints.shape
-        n_points = n_turbines * n_rpoints
+        if downwind_index is not None:
+            rpoints = rpoints[:, downwind_index, None]
 
         if weights is None:
-            weights = mdata.get(FC.RWEIGHTS, self.rotor_point_weights())
+            weights = mdata.get(FC.TWEIGHTS, self.rotor_point_weights())
         if store_rweights:
-            mdata[FC.RWEIGHTS] = weights
-            mdata.dims[FC.RWEIGHTS] = (FC.RPOINT,)
-            self.data_to_store(FC.RWEIGHTS, algo, mdata)
+            mdata[self.RWEIGHTS] = weights
+            mdata.dims[self.RWEIGHTS] = (FC.TPOINT,)
+            self.data_to_store(self.RWEIGHTS, algo, mdata)
 
+        tdata = TData.from_tpoints(rpoints, weights)
         svars = algo.states.output_point_vars(algo)
-        points = rpoints.reshape(n_states, n_points, 3)
-        pdata = {FC.POINTS: points}
-        pdims = {FC.POINTS: (FC.STATE, FC.POINT, FC.XYH)}
-        pdata.update(
-            {v: np.full((n_states, n_points), np.nan, dtype=FC.DTYPE) for v in svars}
-        )
-        pdims.update({v: (FC.STATE, FC.POINT) for v in svars})
-        pdata = Data(pdata, pdims, loop_dims=[FC.STATE, FC.POINT])
-        del pdims, points
-
-        sres = algo.states.calculate(algo, mdata, fdata, pdata)
-        pdata.update(sres)
-        del sres
-
-        rpoint_results = {}
         for v in svars:
-            rpoint_results[v] = pdata[v].reshape(n_states, n_turbines, n_rpoints)
+            tdata.add(
+                v,
+                data=np.full_like(rpoints[..., 0], np.nan),
+                dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+            )
+
+        sres = algo.states.calculate(algo, mdata, fdata, tdata)
+        tdata.update(sres)
 
         if store_amb_res:
-            mdata[FC.AMB_RPOINT_RESULTS] = rpoint_results
-            self.data_to_store(FC.AMB_RPOINT_RESULTS, algo, mdata)
+            mdata[self.AMBRES] = sres.copy()
+            self.data_to_store(self.AMBRES, algo, mdata)
 
         self.eval_rpoint_results(
             algo,
             mdata,
             fdata,
-            rpoint_results,
+            tdata,
             weights,
-            states_turbine,
+            downwind_index,
             copy_to_ambient=True,
         )
 

foxes/core/states.py

@@ -245,7 +245,7 @@ class ExtendedStates(States):
         """
         return self.states.output_point_vars(algo)
 
-    def calculate(self, algo, mdata, fdata, pdata):
+    def calculate(self, algo, mdata, fdata, tdata):
         """ "
         The main model calculation.
 
@@ -256,12 +256,12 @@ class ExtendedStates(States):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------
@@ -270,7 +270,7 @@ class ExtendedStates(States):
             Values: numpy.ndarray with shape (n_states, n_points)
 
         """
-        return self.pmodels.calculate(algo, mdata, fdata, pdata)
+        return self.pmodels.calculate(algo, mdata, fdata, tdata)
 
     def __add__(self, m):
         models = self.pmodels.models[1:]