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

foxes/models/wake_frames/seq_dynamic_wakes.py

@@ -3,7 +3,7 @@ from scipy.spatial.distance import cdist
 
 from foxes.core import WakeFrame
 from foxes.utils import wd2uv
-from foxes.core.data import Data
+from foxes.core.data import TData
 import foxes.variables as FV
 import foxes.constants as FC
 from foxes.algorithms import Sequential
@@ -44,6 +44,9 @@ class SeqDynamicWakes(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.
@@ -98,9 +101,9 @@ class SeqDynamicWakes(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
@@ -109,19 +112,18 @@ class SeqDynamicWakes(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
@@ -131,94 +133,112 @@ class SeqDynamicWakes(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 = 1
-        n_points = pdata.n_points
-        points = pdata[FC.POINTS]
-        stsel = (np.arange(n_states), states_source_turbine)
-        tindx = states_source_turbine[0]
+        n_targets = tdata.n_targets
+        n_tpoints = tdata.n_tpoints
+        n_points = n_targets * n_tpoints
+        points = tdata[FC.TARGETS].reshape(n_states, n_points, 3)
         counter = algo.states.counter
         N = counter + 1
 
         # new wake starts at turbine:
-        self._traces_p[counter, tindx] = fdata[FV.TXYH][0, tindx]
-        self._traces_l[counter, tindx] = 0
+        self._traces_p[counter, downwind_index] = fdata[FV.TXYH][0, downwind_index]
+        self._traces_l[counter, downwind_index] = 0
 
         # transport wakes that originate from previous time steps:
         if counter > 0:
-            dxyz = self._traces_v[:counter, tindx] * self._dt[:counter, None]
-            self._traces_p[:counter, tindx] += dxyz
-            self._traces_l[:counter, tindx] += np.linalg.norm(dxyz, axis=-1)
+            dxyz = self._traces_v[:counter, downwind_index] * self._dt[:counter, None]
+            self._traces_p[:counter, downwind_index] += dxyz
+            self._traces_l[:counter, downwind_index] += np.linalg.norm(dxyz, axis=-1)
 
         # compute wind vectors at wake traces:
         # TODO: dz from U_z is missing here
         hpdata = {
-            v: np.zeros((1, N), dtype=FC.DTYPE)
+            v: np.zeros((1, N, 1), dtype=FC.DTYPE)
             for v in algo.states.output_point_vars(algo)
         }
-        hpdata[FC.POINTS] = self._traces_p[None, :N, tindx]
-        hpdims = {FC.POINTS: (FC.STATE, FC.POINT, FC.XYH)}
-        hpdims.update({v: (FC.STATE, FC.POINT) for v in hpdata.keys()})
-        hpdata = Data(hpdata, hpdims, loop_dims=[FC.STATE, FC.POINT])
+        hpdims = {v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in hpdata.keys()}
+        hpdata = TData.from_points(
+            points=self._traces_p[None, :N, downwind_index],
+            data=hpdata,
+            dims=hpdims,
+        )
         res = algo.states.calculate(algo, mdata, fdata, hpdata)
-        self._traces_v[:N, tindx, :2] = wd2uv(res[FV.WD][0], res[FV.WS][0])
+        self._traces_v[:N, downwind_index, :2] = wd2uv(
+            res[FV.WD][0, :, 0], res[FV.WS][0, :, 0]
+        )
         del hpdata, hpdims, res
 
         # project:
-        dists = cdist(points[0], self._traces_p[:N, tindx])
+        dists = cdist(points[0], self._traces_p[:N, downwind_index])
         tri = np.argmin(dists, axis=1)
         del dists
         wcoos = np.full((n_states, n_points, 3), 1e20, dtype=FC.DTYPE)
-        wcoos[0, :, 2] = points[0, :, 2] - fdata[FV.TXYH][stsel][0, None, 2]
-        delp = points[0, :, :2] - self._traces_p[tri, tindx, :2]
-        nx = self._traces_v[tri, tindx, :2]
+        wcoos[0, :, 2] = points[0, :, 2] - fdata[FV.TXYH][:, downwind_index][0, None, 2]
+        delp = points[0, :, :2] - self._traces_p[tri, downwind_index, :2]
+        nx = self._traces_v[tri, downwind_index, :2]
         nx /= np.linalg.norm(nx, axis=1)[:, None]
         ny = np.concatenate([-nx[:, 1, None], nx[:, 0, None]], axis=1)
-        wcoos[0, :, 0] = np.einsum("pd,pd->p", delp, nx) + self._traces_l[tri, tindx]
+        wcoos[0, :, 0] = (
+            np.einsum("pd,pd->p", delp, nx) + self._traces_l[tri, downwind_index]
+        )
         wcoos[0, :, 1] = np.einsum("pd,pd->p", delp, ny)
 
         # 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, tri[None, :], (FC.STATE, FC.POINT))
+        tdata.add(
+            FC.STATES_SEL,
+            tri[None, :].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_wake_modelling_data(
         self,
         algo,
         variable,
-        states_source_turbine,
+        downwind_index,
         fdata,
-        pdata,
+        tdata,
+        target,
         states0=None,
+        upcast=False,
     ):
         """
         Return data that is required for computing the
@@ -230,35 +250,65 @@ class SeqDynamicWakes(WakeFrame):
             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_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
 
         """
-        if states0 is None:
+        if states0 is None and FC.STATE_SOURCE_ORDERI in tdata:
             # from previous iteration:
-            if not np.all(states_source_turbine == pdata[FC.STATE_SOURCE_TURBINE]):
+            if downwind_index != tdata[FC.STATE_SOURCE_ORDERI]:
                 raise ValueError(
-                    f"Model '{self.name}': Mismatch of 'states_source_turbine'. Expected {list(pdata[FC.STATE_SOURCE_TURBINE])}, got {list(states_source_turbine)}"
+                    f"Model '{self.name}': Mismatch of '{FC.STATE_SOURCE_ORDERI}'. Expected {tdata[FC.STATE_SOURCE_ORDERI]}, got {downwind_index}"
                 )
 
-            s = pdata[FC.STATES_SEL]
-            data = algo.farm_results[variable].to_numpy()
+            n_states = 1
+            n_targets = tdata.n_targets
+            n_tpoints = tdata.n_tpoints
+            n_points = n_targets * n_tpoints
 
-            return data[s, states_source_turbine]
+            s = tdata[FC.STATES_SEL][0].reshape(n_points)
+            data = algo.farm_results[variable].to_numpy()
+            data = data[s, downwind_index].reshape(n_states, n_targets, n_tpoints)
+
+            if target == FC.STATE_TARGET:
+                if n_tpoints == 1:
+                    data = data[:, :, 0]
+                else:
+                    data = np.einsum("stp,p->st", data, tdata[FC.TWEIGHTS])
+                return data, (FC.STATE, FC.TARGET)
+            elif target == FC.STATE_TARGET_TPOINT:
+                return data, (FC.STATE, FC.TARGET, FC.TPOINT)
+            else:
+                raise ValueError(
+                    f"Cannot handle target '{target}', choices are {FC.STATE_TARGET}, {FC.STATE_TARGET_TPOINT}"
+                )
 
         else:
             return super().get_wake_modelling_data(
-                algo, variable, states_source_turbine, fdata, pdata, states0
+                algo, variable, downwind_index, fdata, tdata, target, states0, upcast
             )
 
-    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.
@@ -267,13 +317,12 @@ class SeqDynamicWakes(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)
 
@@ -283,5 +332,4 @@ class SeqDynamicWakes(WakeFrame):
             The centreline points, shape: (n_states, n_points, 3)
 
         """
-
         raise NotImplementedError

foxes/models/wake_frames/streamlines.py

@@ -3,7 +3,7 @@ from scipy.interpolate import interpn
 
 from foxes.core import WakeFrame
 from foxes.utils import wd2uv
-from foxes.core.data import Data
+from foxes.core.data import TData
 import foxes.variables as FV
 import foxes.constants as FC
 
@@ -47,9 +47,11 @@ class Streamlines2D(WakeFrame):
         self.cl_ipars = cl_ipars
 
         self.DATA = self.var("DATA")
+        self.STEPS = self.var("STEPS")
+        self.SDAT = self.var("SDAT")
 
     def __repr__(self):
-        return super().__repr__() + f"(step={self.step})"
+        return f"{type(self).__name__}(step={self.step})"
 
     def _calc_streamlines(self, algo, mdata, fdata):
         """
@@ -80,19 +82,17 @@ class Streamlines2D(WakeFrame):
 
                 # calculate next tangential vector:
                 svars = algo.states.output_point_vars(algo)
-                pdata = {FC.POINTS: data[:, :, i, :3]}
-                pdims = {FC.POINTS: (FC.STATE, FC.POINT, FC.XYH)}
-                pdata.update(
-                    {
-                        v: np.full((n_states, n_turbines), np.nan, dtype=FC.DTYPE)
+                tdata = TData.from_points(
+                    data[:, :, i, :3],
+                    data={
+                        v: np.full((n_states, n_turbines, 1), np.nan, dtype=FC.DTYPE)
                         for v in svars
-                    }
+                    },
+                    dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) 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])
-                data[:, :, i, 3] = algo.states.calculate(algo, mdata, fdata, pdata)[
+                data[:, :, i, 3] = algo.states.calculate(algo, mdata, fdata, tdata)[
                     FV.WD
-                ]
+                ][:, :, 0]
 
                 sel = np.isnan(data[:, :, i, 3])
                 if np.any(sel):
@@ -108,9 +108,9 @@ class Streamlines2D(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
@@ -125,22 +125,23 @@ class Streamlines2D(WakeFrame):
             mdata[self.DATA][:, :, 0, :3] == fdata[FV.TXYH]
         ):
             mdata[self.DATA] = self._calc_streamlines(algo, mdata, fdata)
+            mdata.dims[self.DATA] = (FC.STATE, FC.TURBINE, self.STEPS, self.SDAT)
 
         return mdata[self.DATA]
 
-    def _calc_coos(self, algo, mdata, fdata, points, states_source_turbine):
+    def _calc_coos(self, algo, mdata, fdata, targets, downwind_index):
         """
         Helper function, calculates streamline coordinates
         for given points and given turbine
         """
 
         # prepare:
-        n_states = mdata.n_states
-        n_points = points.shape[1]
-        st_sel = (np.arange(n_states), states_source_turbine)
+        n_states, n_targets, n_tpoints = targets.shape[:3]
+        n_points = n_targets * n_tpoints
+        points = targets.reshape(n_states, n_points, 3)
 
         # find nearest streamline points:
-        data = self.get_streamline_data(algo, mdata, fdata)[st_sel]
+        data = self.get_streamline_data(algo, mdata, fdata)[:, downwind_index]
         dists = np.linalg.norm(points[:, :, None, :2] - data[:, None, :, :2], axis=-1)
         selp = np.argmin(dists, axis=2)
         data = np.take_along_axis(data[:, None], selp[:, :, None, None], axis=2)[
@@ -158,7 +159,7 @@ class Streamlines2D(WakeFrame):
         coos[:, :, 1] = np.einsum("spd,spd->sp", delta, ny)
         coos[:, :, 2] = points[:, :, 2] - data[:, :, 2]
 
-        return coos
+        return coos.reshape(n_states, n_targets, n_tpoints, 3)
 
     def calc_order(self, algo, mdata, fdata):
         """ "
@@ -171,9 +172,9 @@ class Streamlines2D(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
@@ -185,15 +186,15 @@ class Streamlines2D(WakeFrame):
         # 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
@@ -203,36 +204,41 @@ class Streamlines2D(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)
 
         """
-        return self._calc_coos(
-            algo, mdata, fdata, pdata[FC.POINTS], states_source_turbine
-        )
+        return self._calc_coos(algo, mdata, fdata, tdata[FC.TARGETS], downwind_index)
 
-    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.
@@ -241,13 +247,12 @@ class Streamlines2D(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)
 
@@ -263,8 +268,7 @@ class Streamlines2D(WakeFrame):
 
         # get streamline points:
         n_states, n_points = x.shape
-        st_sel = (np.arange(n_states), states_source_turbine)
-        data = self.get_streamline_data(algo, mdata, fdata)[st_sel]
+        data = self.get_streamline_data(algo, mdata, fdata)[:, downwind_index]
         spts = data[:, :, :3]
         n_spts = spts.shape[1]
         xs = self.step * np.arange(n_spts)