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

foxes/algorithms/iterative/models/farm_wakes_calc.py

@@ -1,7 +1,7 @@
 import numpy as np
+from copy import deepcopy
 
-import foxes.variables as FV
-from foxes.core import FarmDataModel
+from foxes.core import FarmDataModel, TData
 
 
 class FarmWakesCalculation(FarmDataModel):
@@ -60,22 +60,7 @@ class FarmWakesCalculation(FarmDataModel):
             All sub models
 
         """
-        return [self.pwakes] if self.urelax is None else [self.urelax, self.pwakes]
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        self.pwakes = algo.partial_wakes_model
-        super().initialize(algo, verbosity)
+        return [] if self.urelax is None else [self.urelax]
 
     def calculate(self, algo, mdata, fdata):
         """ "
@@ -100,35 +85,57 @@ class FarmWakesCalculation(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-
-        torder = fdata[FV.ORDER]
-        n_order = torder.shape[1]
-        n_states = mdata.n_states
-
-        def _evaluate(algo, mdata, fdata, pdata, wdeltas, o):
-            self.pwakes.evaluate_results(
-                algo, mdata, fdata, pdata, wdeltas, states_turbine=o
-            )
-
-            trbs = np.zeros((n_states, algo.n_turbines), dtype=bool)
-            np.put_along_axis(trbs, o[:, None], True, axis=1)
-
-            res = algo.farm_controller.calculate(
-                algo, mdata, fdata, pre_rotor=False, st_sel=trbs
-            )
-            fdata.update(res)
-
-            if self.urelax is not None:
-                res = self.urelax.calculate(algo, mdata, fdata)
-                for v, d in res.items():
-                    fdata[v][trbs] = d[trbs]
-
-        wdeltas, pdata = self.pwakes.new_wake_deltas(algo, mdata, fdata)
-        for oi in range(n_order):
-            o = torder[:, oi]
-            self.pwakes.contribute_to_wake_deltas(algo, mdata, fdata, pdata, o, wdeltas)
-
-        for oi in range(n_order):
-            _evaluate(algo, mdata, fdata, pdata, wdeltas, torder[:, oi])
+        # collect ambient rotor results and weights:
+        rotor = algo.rotor_model
+        weights = rotor.from_data_or_store(rotor.RWEIGHTS, algo, mdata)
+        amb_res = rotor.from_data_or_store(rotor.AMBRES, algo, mdata)
+
+        # generate all wake evaluation points
+        # (n_states, n_order, n_rpoints)
+        pwake2tdata = {}
+        for wname, wmodel in algo.wake_models.items():
+            pwake = algo.partial_wakes[wname]
+            if pwake.name not in pwake2tdata:
+                tpoints, tweights = pwake.get_wake_points(algo, mdata, fdata)
+                pwake2tdata[pwake.name] = TData.from_tpoints(tpoints, tweights)
+
+        def _get_wdata(tdatap, wdeltas, s):
+            """Helper function for wake data extraction"""
+            tdata = tdatap.get_slice(s, keep=True)
+            wdelta = {v: d[s] for v, d in wdeltas.items()}
+            return tdata, wdelta
+
+        wake_res = deepcopy(amb_res)
+        n_turbines = mdata.n_turbines
+        for wname, wmodel in algo.wake_models.items():
+            pwake = algo.partial_wakes[wname]
+            tdatap = pwake2tdata[pwake.name]
+            wdeltas = pwake.new_wake_deltas(algo, mdata, fdata, tdatap, wmodel)
+
+            for oi in range(n_turbines):
+
+                if oi > 0:
+                    tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, :oi])
+                    pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+
+                if oi < n_turbines - 1:
+                    tdata, wdelta = _get_wdata(tdatap, wdeltas, np.s_[:, oi + 1 :])
+                    pwake.contribute(algo, mdata, fdata, tdata, oi, wdelta, wmodel)
+
+            for oi in range(n_turbines):
+                wres = pwake.finalize_wakes(
+                    algo, mdata, fdata, tdatap, amb_res, weights, wdeltas, wmodel, oi
+                )
+                for v, d in wres.items():
+                    if v in wake_res:
+                        wake_res[v][:, oi] += d
+
+            del pwake, tdatap, wdeltas
+
+        rotor.eval_rpoint_results(algo, mdata, fdata, wake_res, weights)
+        res = algo.farm_controller.calculate(algo, mdata, fdata, pre_rotor=False)
+        if self.urelax is not None:
+            res = self.urelax.calculate(algo, mdata, fdata, res)
+        fdata.update(res)
 
         return {v: fdata[v] for v in self.output_farm_vars(algo)}

foxes/algorithms/sequential/models/seq_state.py

@@ -134,8 +134,8 @@ class SeqState(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.
 
         This function is executed on a single chunk of data,
@@ -149,14 +149,15 @@ class SeqState(States):
             The model data
         fdata: foxes.core.Data
             The farm data
-        pdata: foxes.core.Data
-            The point data
+        tdata: foxes.core.Data
+            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)
 
         """
-        return self.states.calculate(algo, mdata, fdata, pdata)
+        return self.states.calculate(algo, mdata, fdata, tdata)

foxes/algorithms/sequential/sequential.py

@@ -4,7 +4,7 @@ from xarray import Dataset
 from foxes.algorithms.downwind.downwind import Downwind
 import foxes.constants as FC
 import foxes.variables as FV
-from foxes.core.data import Data
+from foxes.core.data import MData, FData, TData
 
 from . import models as mdls
 
@@ -30,7 +30,8 @@ class Sequential(Downwind):
         The points of interest, shape: (n_states, n_points, 3)
     plugins: list of foxes.algorithm.sequential.SequentialIterPlugin
         The plugins, updated with every iteration
-
+    outputs: list of str
+        The output variables
     :group: algorithms.sequential
 
     """
@@ -58,15 +59,15 @@ class Sequential(Downwind):
 
     def __init__(
         self,
-        mbook,
         farm,
         states,
         *args,
         points=None,
         ambient=False,
         calc_pars={},
-        chunks={FC.STATE: None, FC.POINT: 10000},
+        chunks={FC.STATE: None, FC.POINT: 4000},
         plugins=[],
+        outputs=None,
         **kwargs,
     ):
         """
@@ -74,8 +75,6 @@ class Sequential(Downwind):
 
         Parameters
         ----------
-        mbook: foxes.ModelBook
-            The model book
         farm: foxes.WindFarm
             The wind farm
         states: foxes.core.States
@@ -93,18 +92,19 @@ class Sequential(Downwind):
             The xarray.Dataset chunk parameters
         plugins: list of foxes.algorithm.sequential.SequentialIterPlugin
             The plugins, updated with every iteration
+        outputs: list of str, optional
+            The output variables
         kwargs: dict, optional
             Additional arguments for Downwind
 
         """
-        super().__init__(
-            mbook, farm, mdls.SeqState(states), *args, chunks=chunks, **kwargs
-        )
+        super().__init__(farm, mdls.SeqState(states), *args, chunks=chunks, **kwargs)
         self.ambient = ambient
         self.calc_pars = calc_pars
         self.states0 = self.states.states
         self.points = points
         self.plugins = plugins
+        self.outputs = outputs if outputs is not None else self.DEFAULT_FARM_OUTPUTS
 
         self._i = None
 
@@ -135,7 +135,7 @@ class Sequential(Downwind):
             self._counter = 0
 
             self._mlist, self._calc_pars = self._collect_farm_models(
-                self.calc_pars, self.ambient
+                self.outputs, self.calc_pars, self.ambient
             )
             if not self._mlist.initialized:
                 self._mlist.initialize(self, self.verbosity)
@@ -155,14 +155,14 @@ class Sequential(Downwind):
                 print(f"Output farm variables:", ", ".join(self.farm_vars))
                 print()
 
-            self._mdata = Data(
+            self._mdata = MData(
                 data={v: d[1] for v, d in self._mdata["data_vars"].items()},
                 dims={v: d[0] for v, d in self._mdata["data_vars"].items()},
                 loop_dims=[FC.STATE],
                 name="mdata",
             )
 
-            self._fdata = Data(
+            self._fdata = FData(
                 data={
                     v: np.zeros((self.n_states, self.n_turbines), dtype=FC.DTYPE)
                     for v in self.farm_vars
@@ -182,14 +182,13 @@ class Sequential(Downwind):
                 self.print(f"\nOutput point variables:", ", ".join(self._pvars), "\n")
 
                 n_points = self.points.shape[1]
-                self._pdata = Data.from_points(
+                self._tdata = TData.from_points(
                     self.points,
                     data={
-                        v: np.zeros((self.n_states, n_points), dtype=FC.DTYPE)
+                        v: np.zeros((self.n_states, n_points, 1), dtype=FC.DTYPE)
                         for v in self._pvars
                     },
-                    dims={v: (FC.STATE, FC.POINT) for v in self._pvars},
-                    name="pdata",
+                    dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in self._pvars},
                 )
 
             for p in self.plugins:
@@ -207,7 +206,7 @@ class Sequential(Downwind):
             self.states._indx = self._inds[self._i]
             self.states._weight = self._weights[self._i]
 
-            mdata = Data(
+            mdata = MData(
                 data={
                     v: d[self._i, None] if self._mdata.dims[v][0] == FC.STATE else d
                     for v, d in self._mdata.items()
@@ -217,7 +216,7 @@ class Sequential(Downwind):
                 name="mdata",
             )
 
-            fdata = Data(
+            fdata = FData(
                 data={
                     v: np.zeros((1, self.n_turbines), dtype=FC.DTYPE)
                     for v in self.farm_vars
@@ -234,7 +233,7 @@ class Sequential(Downwind):
                 self._fdata[v][self._i] = d[0]
 
             fres = Dataset(
-                coords={FC.STATE: [self.index], FC.TURBINE: np.arange(self.n_turbines)},
+                coords={FC.STATE: [self.index]},
                 data_vars={v: ((FC.STATE, FC.TURBINE), d) for v, d in fres.items()},
             )
             fres[FC.TNAME] = ((FC.TURBINE,), self.farm.turbine_names)
@@ -250,25 +249,28 @@ class Sequential(Downwind):
 
             else:
                 n_points = self.points.shape[1]
-                pdata = Data.from_points(
+                tdata = TData.from_points(
                     self.points[self.counter, None],
                     data={
-                        v: np.zeros((1, n_points), dtype=FC.DTYPE) for v in self._pvars
+                        v: np.zeros((1, n_points, 1), dtype=FC.DTYPE)
+                        for v in self._pvars
                     },
-                    dims={v: (FC.STATE, FC.POINT) for v in self._pvars},
-                    name="pdata",
+                    dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in self._pvars},
                 )
 
                 pres = self._plist.calculate(
-                    self, mdata, fdata, pdata, parameters=self._calc_pars_p
+                    self, mdata, fdata, tdata, parameters=self._calc_pars_p
                 )
 
                 for v, d in pres.items():
-                    self._pdata[v][self._i] = d[0]
+                    self._tdata[v][self._i] = d[0]
 
                 pres = Dataset(
-                    coords={FC.STATE: [self.index], FC.POINT: np.arange(n_points)},
-                    data_vars={v: ((FC.STATE, FC.POINT), d) for v, d in pres.items()},
+                    coords={FC.STATE: [self.index]},
+                    data_vars={
+                        v: ((FC.STATE, FC.TARGET, FC.TPOINT), d)
+                        for v, d in pres.items()
+                    },
                 )
 
                 for p in self.plugins:
@@ -330,6 +332,26 @@ class Sequential(Downwind):
         """
         return self.states._indx if self.iterating else None
 
+    def states_i0(self, counter, algo=None):
+        """
+        Returns counter or index
+
+        Parameters
+        ----------
+        counter: bool
+            Flag for counter
+        algo: object, optional
+            Dummy argument, due to consistency with
+            foxes.core.Data.states_i0
+
+        Returns
+        -------
+        i0: int
+            The counter or index
+
+        """
+        return self.counter if counter else self.index
+
     @property
     def weight(self):
         """
@@ -350,7 +372,7 @@ class Sequential(Downwind):
 
         Returns
         -------
-        d: foxes.core.Data
+        d: foxes.core.MData
             The current model data
 
         """
@@ -363,24 +385,24 @@ class Sequential(Downwind):
 
         Returns
         -------
-        d: foxes.core.Data
+        d: foxes.core.FData
             The current farm data
 
         """
         return self._fdata
 
     @property
-    def pdata(self):
+    def tdata(self):
         """
         Get the current point data
 
         Returns
         -------
-        d: foxes.core.Data
+        d: foxes.core.TData
             The current point data
 
         """
-        return self._pdata if self.points is not None and self.iterating else None
+        return self._tdata if self.points is not None and self.iterating else None
 
     @property
     def farm_results(self):
@@ -404,6 +426,19 @@ class Sequential(Downwind):
 
         return results
 
+    @property
+    def prev_farm_results(self):
+        """
+        Alias for farm_results
+
+        Returns
+        -------
+        results: xarray.Dataset
+            The overall farm results
+
+        """
+        return self.farm_results
+
     @property
     def cur_farm_results(self):
         """
@@ -449,7 +484,7 @@ class Sequential(Downwind):
                 FC.POINT: np.arange(n_points),
                 FC.XYH: np.arange(3),
             },
-            data_vars={v: (self._pdata.dims[v], d) for v, d in self._pdata.items()},
+            data_vars={v: (self._tdata.dims[v], d) for v, d in self._tdata.items()},
         )
 
         return results
@@ -477,7 +512,7 @@ class Sequential(Downwind):
                 FC.XYH: np.arange(3),
             },
             data_vars={
-                v: (self._pdata.dims[v], d[i, None]) for v, d in self._pdata.items()
+                v: (self._tdata.dims[v], d[i, None]) for v, d in self._tdata.items()
             },
         )
 
@@ -501,13 +536,13 @@ class Sequential(Downwind):
         pvars = plist.output_point_vars(self)
 
         mdata = self.get_models_idata()
-        mdata = Data(
+        mdata = MData(
             data={v: d[1] for v, d in mdata["data_vars"].items()},
             dims={v: d[0] for v, d in mdata["data_vars"].items()},
             loop_dims=[FC.STATE],
             name="mdata",
         )
-        mdata = Data(
+        mdata = MData(
             data={
                 v: d[self.states.counter, None] if mdata.dims[v][0] == FC.STATE else d
                 for v, d in mdata.items()
@@ -517,24 +552,26 @@ class Sequential(Downwind):
             name="mdata",
         )
 
-        fdata = Data(
+        fdata = FData(
             data={v: farm_results[v].to_numpy() for v in self.farm_vars},
             dims={v: (FC.STATE, FC.TURBINE) for v in self.farm_vars},
             loop_dims=[FC.STATE],
             name="fdata",
         )
 
-        pdata = Data.from_points(
+        tdata = TData.from_points(
             points[0, None],
-            data={v: np.zeros((1, n_points), dtype=FC.DTYPE) for v in pvars},
-            dims={v: (FC.STATE, FC.POINT) for v in pvars},
-            name="pdata",
+            data={v: np.zeros((1, n_points, 1), dtype=FC.DTYPE) for v in pvars},
+            dims={v: (FC.STATE, FC.TARGET, FC.TPOINT) for v in pvars},
+            name="tdata",
         )
 
-        pres = plist.calculate(self, mdata, fdata, pdata, parameters=calc_pars)
+        pres = plist.calculate(self, mdata, fdata, tdata, parameters=calc_pars)
         pres = Dataset(
-            coords={FC.STATE: self.states.index(), FC.POINT: np.arange(n_points)},
-            data_vars={v: ((FC.STATE, FC.POINT), d) for v, d in pres.items()},
+            coords={FC.STATE: self.states.index()},
+            data_vars={
+                v: ((FC.STATE, FC.TARGET, FC.TPOINT), d) for v, d in pres.items()
+            },
         )
 
         # plist.finalize(self, self.verbosity)

foxes/constants.py

@@ -25,33 +25,43 @@ TNAME = "tname"
 :group: foxes.constants
 """
 
-POINT = "point"
-""" Point identifier
+TARGET = "target"
+""" Target identifier
 :group: foxes.constants
 """
 
-POINTS = "points"
-""" Points identifier
+TARGETS = "targets"
+""" Targets identifier
 :group: foxes.constants
 """
 
-RPOINT = "rotor_point"
-""" Rotor point identifier
+TPOINT = "target_point"
+""" Target point identifier
 :group: foxes.constants
 """
 
-RPOINTS = "rotor_points"
-""" Rotor points identifier
+TPOINTS = "target_points"
+""" Points per target identifier
 :group: foxes.constants
 """
 
-RWEIGHTS = "rotor_weights"
-""" Rotor point weights identifier
+TWEIGHTS = "tpoint_weights"
+""" Target point weights identifier
 :group: foxes.constants
 """
 
-AMB_RPOINT_RESULTS = "amb_rpoint_res"
-""" Identified for ambient rotor point results
+POINT = "point"
+""" Point identifier
+:group: foxes.constants
+"""
+
+POINTS = "points"
+""" Points identifier
+:group: foxes.constants
+"""
+
+AMB_TARGET_RESULTS = "amb_target_res"
+""" Identified for ambient target results
 :group: foxes.constants
 """
 
@@ -81,18 +91,23 @@ STATES_SEL = "states_sel"
 :group: foxes.constants
 """
 
-STATE_SOURCE_TURBINE = "state_source_turbine"
-"""Identifier for the source turbines per state
+STATE_TURBINE = "state-turbine"
+"""Identifier for state-turbine dimensions
+:group: foxes.constants
+"""
+
+STATE_TARGET = "state-target"
+"""Identifier for state-target dimensions
 :group: foxes.constants
 """
 
-STATE_TURBINE = "state-turbine"
-"""Identifier for state-turbine dimensions
+STATE_TARGET_TPOINT = "state-target-tpoint"
+"""Identifier for state-target-tpoints dimensions
 :group: foxes.constants
 """
 
-STATE_POINT = "state-point"
-"""Identifier for state-point dimensions
+STATE_SOURCE_ORDERI = "state-source-orderi"
+"""Identifier for order index of wake causing turbines
 :group: foxes.constants
 """
 

foxes/core/__init__.py

@@ -2,7 +2,7 @@
 Abstract classes and core functionality.
 """
 
-from .data import Data
+from .data import Data, MData, FData, TData
 from .model import Model
 from .data_calc_model import DataCalcModel
 from .states import States, ExtendedStates
@@ -18,7 +18,7 @@ from .farm_controller import FarmController
 from .turbine import Turbine
 from .partial_wakes_model import PartialWakesModel
 from .wake_frame import WakeFrame
-from .wake_model import WakeModel
+from .wake_model import WakeModel, TurbineInductionModel
 from .wake_superposition import WakeSuperposition
 from .vertical_profile import VerticalProfile
 from .axial_induction_model import AxialInductionModel

foxes/core/algorithm.py

@@ -63,6 +63,9 @@ class Algorithm(Model):
         self.n_turbines = farm.n_turbines
         self.dbook = StaticData() if dbook is None else dbook
 
+        if chunks is not None and FC.TARGET not in chunks:
+            self.chunks[FC.TARGET] = chunks.get(FC.POINT, None)
+
         self._idata_mem = Dict()
 
     def print(self, *args, vlim=1, **kwargs):
@@ -115,15 +118,24 @@ class Algorithm(Model):
                     raise ValueError(
                         f"Input {mtype} data entry '{v}': Dimension '{FC.STATE}' not at first position, got {t[0]}"
                     )
-                if FC.POINT in t[0] and t[0][1] != FC.POINT:
-                    raise ValueError(
-                        f"Input {mtype} data entry '{v}': Dimension '{FC.POINT}' not at second position, got {t[0]}"
-                    )
-            elif FC.POINT in t[0]:
-                if t[0][0] != FC.POINT:
-                    raise ValueError(
-                        f"Input {mtype} data entry '{v}': Dimension '{FC.POINT}' not at first position, got {t[0]}"
-                    )
+                if FC.TURBINE in t[0]:
+                    if t[0][1] != FC.TURBINE:
+                        raise ValueError(
+                            f"Input {mtype} data entry '{v}': Dimension '{FC.TURBINE}' not at second position, got {t[0]}"
+                        )
+                if FC.TARGET in t[0]:
+                    if t[0][1] != FC.TARGET:
+                        raise ValueError(
+                            f"Input {mtype} data entry '{v}': Dimension '{FC.TARGET}' not at second position, got {t[0]}"
+                        )
+                    if len(t[0]) < 3 or t[0][2] != FC.TPOINT:
+                        raise KeyError(
+                            f"Input {mtype} data entry '{v}': Expecting dimension '{FC.TPOINT}' as third entry. Got {t[0]}"
+                        )
+            elif FC.TURBINE in t[0]:
+                raise ValueError(
+                    f"Input {mtype} data entry '{v}': Dimension '{FC.TURBINE}' requires combination with dimension '{FC.STATE}'"
+                )
             for d, s in zip(t[0], t[1].shape):
                 if d not in sizes:
                     sizes[d] = s
@@ -153,9 +165,9 @@ class Algorithm(Model):
                 raise ValueError(
                     f"Dimension '{FC.TURBINE}' cannot be chunked, got chunks {self.chunks}"
                 )
-            if FC.RPOINT in self.chunks.keys():
+            if FC.TPOINT in self.chunks.keys():
                 raise ValueError(
-                    f"Dimension '{FC.RPOINT}' cannot be chunked, got chunks {self.chunks}"
+                    f"Dimension '{FC.TPOINT}' cannot be chunked, got chunks {self.chunks}"
                 )
             xrdata = xrdata.chunk(
                 chunks={c: v for c, v in self.chunks.items() if c in sizes}
@@ -376,7 +388,14 @@ class Algorithm(Model):
             raise ValueError(
                 f"points have wrong dimensions, expecting ({self.n_states}, {points.shape[1]}, 3), got {points.shape}"
             )
-        idata["data_vars"][FC.POINTS] = ((FC.STATE, FC.POINT, FC.XYH), points)
+        idata["data_vars"][FC.TARGETS] = (
+            (FC.STATE, FC.TARGET, FC.TPOINT, FC.XYH),
+            points[:, :, None, :],
+        )
+        idata["data_vars"][FC.TWEIGHTS] = (
+            (FC.TPOINT,),
+            np.array([1.0], dtype=FC.DTYPE),
+        )
 
         sizes = self.__get_sizes(idata, "point")
         return self.__get_xrdata(idata, sizes)