foxes 0.6.2__py3-none-any.whl → 0.7.0.2__py3-none-any.whl

foxes/models/wake_frames/timelines.py

@@ -2,7 +2,7 @@ import numpy as np
 
 from foxes.core import WakeFrame
 from foxes.utils import wd2uv
-from foxes.core.data import Data
+from foxes.core.data import MData, FData, TData
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -47,6 +47,9 @@ class Timelines(WakeFrame):
         self.cl_ipars = cl_ipars
         self.dt_min = dt_min
 
+    def __repr__(self):
+        return f"{type(self).__name__}(dt_min={self.dt_min})"
+
     def initialize(self, algo, verbosity=0):
         """
         Initializes the model.
@@ -87,28 +90,30 @@ class Timelines(WakeFrame):
         mdata = algo.get_model_data(algo.states)["data_vars"]
         mdict = {v: d[1] for v, d in mdata.items()}
         mdims = {v: d[0] for v, d in mdata.items()}
-        mdata = Data(mdict, mdims, loop_dims=[FC.STATE])
+        mdata = MData(mdict, mdims, loop_dims=[FC.STATE])
         del mdict, mdims
 
         # prepare fdata:
-        fdata = Data({}, {}, loop_dims=[FC.STATE])
+        fdata = FData({}, {}, loop_dims=[FC.STATE])
 
-        # prepare pdata:
-        pdata = {
-            v: np.zeros((algo.n_states, 1), dtype=FC.DTYPE)
+        # prepare tdata:
+        tdata = {
+            v: np.zeros((algo.n_states, 1, 1), dtype=FC.DTYPE)
             for v in algo.states.output_point_vars(algo)
         }
-        pdata[FC.POINTS] = np.zeros((algo.n_states, 1, 3), dtype=FC.DTYPE)
-        pdims = {FC.POINTS: (FC.STATE, FC.POINT, FC.XYH)}
-        pdims.update({v: (FC.STATE, FC.POINT) for v in pdata.keys()})
-        pdata = Data(pdata, pdims, loop_dims=[FC.STATE, FC.POINT])
+        pdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in tdata.keys()}
+        tdata = TData.from_points(
+            points=np.zeros((algo.n_states, 1, 3), dtype=FC.DTYPE),
+            data=tdata,
+            dims=pdims,
+        )
 
         # calculate:
-        res = algo.states.calculate(algo, mdata, fdata, pdata)
+        res = algo.states.calculate(algo, mdata, fdata, tdata)
         if len(dt) == 1:
-            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:, 0, :2] * dt[:, None]
+            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:, 0, 0, :2] * dt[:, None]
         else:
-            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:-1, 0, :2] * dt[:, None]
+            self._dxy = wd2uv(res[FV.WD], res[FV.WS])[:-1, 0, 0, :2] * dt[:, None]
             self._dxy = np.insert(self._dxy, 0, self._dxy[0], axis=0)
 
         """ DEBUG
@@ -131,9 +136,9 @@ class Timelines(WakeFrame):
         ----------
         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
@@ -142,19 +147,18 @@ class Timelines(WakeFrame):
             The turbine order, shape: (n_states, n_turbines)
 
         """
-
         # prepare:
         n_states = fdata.n_states
         n_turbines = algo.n_turbines
-        pdata = Data.from_points(points=fdata[FV.TXYH])
+        tdata = TData.from_points(points=fdata[FV.TXYH])
 
         # calculate streamline x coordinates for turbines rotor centre points:
         # n_states, n_turbines_source, n_turbines_target
         coosx = np.zeros((n_states, n_turbines, n_turbines), dtype=FC.DTYPE)
         for ti in range(n_turbines):
-            coosx[:, ti, :] = self.get_wake_coos(
-                algo, mdata, fdata, pdata, np.full(n_states, ti)
-            )[..., 0]
+            coosx[:, ti, :] = self.get_wake_coos(algo, mdata, fdata, tdata, ti)[
+                :, :, 0, 0
+            ]
 
         # derive turbine order:
         # TODO: Remove loop over states
@@ -164,41 +168,47 @@ class Timelines(WakeFrame):
 
         return order
 
-    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)
 
         """
-
         # prepare:
-        n_states = mdata.n_states
-        n_points = pdata.n_points
-        points = pdata[FC.POINTS]
-        stsel = (np.arange(n_states), states_source_turbine)
-        rxyz = fdata[FV.TXYH][stsel]
+        targets = tdata[FC.TARGETS]
+        n_states, n_targets, n_tpoints = targets.shape[:3]
+        n_points = n_targets * n_tpoints
+        points = targets.reshape(n_states, n_points, 3)
+        rxyz = fdata[FV.TXYH][:, downwind_index]
 
         D = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        D[:] = fdata[FV.D][stsel][:, None]
+        D[:] = fdata[FV.D][:, downwind_index, None]
 
         i0 = mdata.states_i0(counter=True, algo=algo)
         i1 = i0 + mdata.n_states
@@ -256,14 +266,18 @@ class Timelines(WakeFrame):
                 break
 
         # turbines that cause wake:
-        pdata.add(FC.STATE_SOURCE_TURBINE, states_source_turbine, (FC.STATE,))
+        tdata[FC.STATE_SOURCE_ORDERI] = downwind_index
 
         # states that cause wake for each target point:
-        pdata.add(FC.STATES_SEL, trace_si, (FC.STATE, FC.POINT))
+        tdata.add(
+            FC.STATES_SEL,
+            trace_si.reshape(n_states, n_targets, n_tpoints),
+            (FC.STATE, FC.TARGET, FC.TPOINT),
+        )
 
-        return wcoos
+        return wcoos.reshape(n_states, n_targets, n_tpoints, 3)
 
-    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.
@@ -272,13 +286,12 @@ class Timelines(WakeFrame):
         ----------
         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)
 
@@ -288,5 +301,4 @@ class Timelines(WakeFrame):
             The centreline points, shape: (n_states, n_points, 3)
 
         """
-
         raise NotImplementedError

foxes/models/wake_frames/yawed_wakes.py

@@ -77,6 +77,16 @@ class YawedWakes(WakeFrame):
         setattr(self, k_var, k)
         setattr(self, FV.YAWM, 0.0)
 
+    def __repr__(self):
+        k = getattr(self, self.k_var)
+        s = f"{type(self).__name__}("
+        if k is None:
+            s += f"k_var={self.k_var}"
+        else:
+            s += f"{self.k_var}={k}"
+        s += ")"
+        return s
+
     def sub_models(self):
         """
         List of all sub-models
@@ -132,9 +142,9 @@ class YawedWakes(WakeFrame):
         ----------
         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
@@ -145,7 +155,7 @@ class YawedWakes(WakeFrame):
         """
         return self.base_frame.calc_order(algo, mdata, fdata)
 
-    def _update_y(self, algo, mdata, fdata, pdata, states_source_turbine, x, y):
+    def _update_y(self, algo, mdata, fdata, tdata, downwind_index, x, y):
         """
         Helper function for y deflection
         """
@@ -153,39 +163,39 @@ class YawedWakes(WakeFrame):
         # get gamma:
         gamma = self.get_data(
             FV.YAWM,
-            FC.STATE_POINT,
+            FC.STATE_TARGET,
             lookup="wfs",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
+            accept_nan=False,
         )
         gamma *= np.pi / 180
 
         # get k:
         k = self.get_data(
             self.k_var,
-            FC.STATE_POINT,
+            FC.STATE_TARGET,
             lookup="sf",
             algo=algo,
             fdata=fdata,
-            pdata=pdata,
+            tdata=tdata,
             upcast=True,
-            states_source_turbine=states_source_turbine,
+            downwind_index=downwind_index,
+            accept_nan=False,
         )
 
         # run model calculation:
-        self.model.calc_data(
-            algo, mdata, fdata, pdata, states_source_turbine, x, gamma, k
-        )
+        self.model.calc_data(algo, mdata, fdata, tdata, downwind_index, x, gamma, k)
 
         # select targets:
-        sp_sel = self.model.get_data(Bastankhah2016Model.SP_SEL, mdata)
-        if np.any(sp_sel):
+        st_sel = self.model.get_data(Bastankhah2016Model.ST_SEL, mdata)
+        if np.any(st_sel):
             # prepare:
-            n_sp_sel = np.sum(sp_sel)
-            ydef = np.zeros((n_sp_sel,), dtype=FC.DTYPE)
+            n_st_sel = np.sum(st_sel)
+            ydef = np.zeros((n_st_sel,), dtype=FC.DTYPE)
 
             # collect data:
             near = self.model.get_data(Bastankhah2016Model.NEAR, mdata)
@@ -208,47 +218,61 @@ class YawedWakes(WakeFrame):
                 ydef[far] = delta
 
             # apply deflection:
-            y[sp_sel] -= ydef
+            y[st_sel] -= ydef
 
-    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)
 
         """
-
         # get unyawed results:
         xyz = self.base_frame.get_wake_coos(
-            algo, mdata, fdata, pdata, states_source_turbine
+            algo,
+            mdata,
+            fdata,
+            tdata,
+            downwind_index,
         )
-        x = xyz[:, :, 0]
-        y = xyz[:, :, 1]
+
+        # take rotor average:
+        xy = np.einsum("stpd,p->std", xyz[..., :2], tdata[FC.TWEIGHTS])
+        x = xy[:, :, 0]
+        y = xy[:, :, 1]
 
         # apply deflection:
-        self._update_y(algo, mdata, fdata, pdata, states_source_turbine, x, y)
+        self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
+        xyz[..., 1] = y[:, :, None]
 
         return xyz
 
-    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.
@@ -257,13 +281,12 @@ class YawedWakes(WakeFrame):
         ----------
         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)
 
@@ -274,7 +297,7 @@ class YawedWakes(WakeFrame):
 
         """
         points = self.base_frame.get_centreline_points(
-            algo, mdata, fdata, states_source_turbine, x
+            algo, mdata, fdata, downwind_index, x
         )
 
         nx = np.zeros_like(points)
@@ -291,7 +314,7 @@ class YawedWakes(WakeFrame):
         del nx, nz
 
         y = np.zeros_like(x)
-        self._update_y(algo, mdata, fdata, None, states_source_turbine, x, y)
+        self._update_y(algo, mdata, fdata, None, downwind_index, x, y)
 
         points += y[:, :, None] * ny
 

foxes/models/wake_models/axisymmetric.py

@@ -17,13 +17,13 @@ class AxisymmetricWakeModel(DistSlicedWakeModel):
     """
 
     @abstractmethod
-    def calc_wakes_spsel_x_r(
+    def calc_wakes_x_r(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
         r,
     ):
@@ -34,40 +34,39 @@ class AxisymmetricWakeModel(DistSlicedWakeModel):
         ----------
         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 in the downwind order
         x: numpy.ndarray
-            The x values, shape: (n_states, n_points)
+            The x values, shape: (n_states, n_targets)
         r: numpy.ndarray
             The radial values for each x value, shape:
-            (n_states, n_points, n_r_per_x, 2)
+            (n_states, n_targets, n_yz_per_target)
 
         Returns
         -------
         wdeltas: dict
             The wake deltas. Key: variable name str,
-            value: numpy.ndarray, shape: (n_sp_sel, n_r_per_x)
-        sp_sel: numpy.ndarray of bool
-            The state-point selection, for which the wake
-            is non-zero, shape: (n_states, n_points)
+            value: numpy.ndarray, shape: (n_st_sel, n_r_per_x)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
 
         """
         pass
 
-    def calc_wakes_spsel_x_yz(
+    def calc_wakes_x_yz(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         x,
         yz,
     ):
@@ -78,32 +77,29 @@ class AxisymmetricWakeModel(DistSlicedWakeModel):
         ----------
         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 in the downwind order
         x: numpy.ndarray
-            The x values, shape: (n_states, n_points)
+            The x values, shape: (n_states, n_targets)
         yz: numpy.ndarray
             The yz values for each x value, shape:
-            (n_states, n_points, n_yz_per_x, 2)
+            (n_states, n_targets, n_yz_per_target, 2)
 
         Returns
         -------
         wdeltas: dict
             The wake deltas. Key: variable name str,
-            value: numpy.ndarray, shape: (n_sp_sel, n_yz_per_x)
-        sp_sel: numpy.ndarray of bool
-            The state-point selection, for which the wake
-            is non-zero, shape: (n_states, n_points)
+            value: numpy.ndarray, shape: (n_st_sel, n_yz_per_target)
+        st_sel: numpy.ndarray of bool
+            The state-target selection, for which the wake
+            is non-zero, shape: (n_states, n_targets)
 
         """
         r = np.linalg.norm(yz, axis=-1)
-        return self.calc_wakes_spsel_x_r(
-            algo, mdata, fdata, pdata, states_source_turbine, x, r
-        )
+        return self.calc_wakes_x_r(algo, mdata, fdata, tdata, downwind_index, x, r)