foxes 1.2.5__py3-none-any.whl → 1.4__py3-none-any.whl

foxes/core/model.py

@@ -77,7 +77,7 @@ class Model(ABC):
 
         Returns
         -------
-        bool :
+        bool:
             True if the model has been initialized.
 
         """
@@ -424,8 +424,8 @@ class Model(ABC):
             # lookup mdata:
             elif s == "m" and mdata is not None and variable in mdata:
                 a, d = _filter_dims(mdata)
-                l = len(d)
-                if l <= len(dims) and d == dims[:l]:
+                ld = len(d)
+                if ld <= len(dims) and d == dims[:ld]:
                     out = _match_shape(mdata[variable])
 
             # lookup fdata:
@@ -448,8 +448,8 @@ class Model(ABC):
                 and variable in tdata
             ):
                 a, d = _filter_dims(tdata)
-                l = len(d)
-                if l <= len(dims) and d == dims[:l]:
+                ld = len(ld)
+                if ld <= len(dims) and d == dims[:ld]:
                     out = _match_shape(tdata[variable])
 
             # lookup wake modelling data:

foxes/core/partial_wakes_model.py

@@ -1,8 +1,13 @@
 from abc import abstractmethod
+import numpy as np
 
-from foxes.utils import new_instance
+from foxes.utils import new_instance, wd2uv, uv2wd
+from foxes.config import config
+import foxes.variables as FV
+import foxes.constants as FC
 
 from .model import Model
+from .data import TData
 
 
 class PartialWakesModel(Model):
@@ -68,6 +73,144 @@ class PartialWakesModel(Model):
         """
         pass
 
+    def get_initial_tdata(
+        self,
+        algo,
+        mdata,
+        fdata,
+        amb_rotor_res,
+        rotor_weights,
+        wmodels,
+    ):
+        """
+        Creates the initial target data object
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        amb_rotor_res: dict
+            The ambient results at rotor points,
+            key: variable name, value: numpy.ndarray
+            of shape: (n_states, n_turbines, n_rotor_points)
+        rotor_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+        wmodels: list of foxes.core.WakeModel
+            The wake models for this partial wake model
+
+        Returns
+        -------
+        tdata: foxes.core.TData
+            The target point data for the wake points
+
+        """
+        tpoints, tweights = self.get_wake_points(algo, mdata, fdata)
+        tdata = TData.from_tpoints(tpoints, tweights)
+
+        # map wind data:
+        if FV.WD in amb_rotor_res or FV.WS in amb_rotor_res:
+            assert FV.WD in amb_rotor_res and FV.WS in amb_rotor_res, (
+                "Require both wind direction and speed in ambient rotor results."
+            )
+            uv = wd2uv(amb_rotor_res[FV.WD], amb_rotor_res[FV.WS])
+            uv = np.stack(
+                [
+                    self.map_rotor_results(
+                        algo, mdata, fdata, tdata, FV.U, uv[..., 0], rotor_weights
+                    ),
+                    self.map_rotor_results(
+                        algo, mdata, fdata, tdata, FV.V, uv[..., 1], rotor_weights
+                    ),
+                ],
+                axis=-1,
+            )
+            tdata.add(FV.AMB_WD, uv2wd(uv), dims=(FC.STATE, FC.TARGET, FC.TPOINT))
+            tdata.add(
+                FV.AMB_WS,
+                np.linalg.norm(uv, axis=-1),
+                dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+            )
+            for wmodel in wmodels:
+                if wmodel.has_uv:
+                    tdata.add(
+                        FV.AMB_UV, uv, dims=(FC.STATE, FC.TARGET, FC.TPOINT, FC.XY)
+                    )
+                    break
+
+        # map rotor point results onto target points:
+        for v, d in amb_rotor_res.items():
+            if v not in [FV.WS, FV.WD, FV.U, FV.V, FV.UV]:
+                w = FV.var2amb.get(v, v)
+                tdata.add(
+                    w,
+                    self.map_rotor_results(
+                        algo, mdata, fdata, tdata, v, d, rotor_weights
+                    ),
+                    dims=(FC.STATE, FC.TARGET, FC.TPOINT),
+                )
+
+        return tdata
+
+    def map_rotor_results(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        variable,
+        rotor_res,
+        rotor_weights,
+    ):
+        """
+        Map ambient rotor point results onto target points.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        variable: str
+            The variable name to map
+        rotor_res: numpy.ndarray
+            The results at rotor points, shape:
+            (n_states, n_turbines, n_rotor_points)
+        rotor_weights: numpy.ndarray
+            The rotor point weights, shape: (n_rotor_points,)
+
+        Returns
+        -------
+        res: numpy.ndarray
+            The mapped results at target points, shape:
+            (n_states, n_targets, n_tpoints)
+
+        """
+        if len(rotor_res.shape) > 2 and rotor_res.shape[:2] == (
+            tdata.n_states,
+            tdata.n_targets,
+        ):
+            q = np.zeros(
+                (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                dtype=config.dtype_double,
+            )
+            if rotor_res.shape[2] == 1:
+                q[:] = rotor_res
+            else:
+                q[:] = np.einsum("str,r->st", rotor_res, rotor_weights)[:, :, None]
+            return q
+        else:
+            raise ValueError(
+                f"Partial wakes '{self.name}': Incompatible shape '{rotor_res.shape}' for variable '{variable}' in rotor results."
+            )
+
     def new_wake_deltas(self, algo, mdata, fdata, tdata, wmodel):
         """
         Creates new initial wake deltas, filled
@@ -77,11 +220,11 @@ class PartialWakesModel(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
-        tdata: foxes.core.Data
+        tdata: foxes.core.TData
             The target point data
         wmodel: foxes.core.WakeModel
             The wake model
@@ -140,7 +283,6 @@ class PartialWakesModel(Model):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -162,11 +304,6 @@ class PartialWakesModel(Model):
             The farm data
         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

foxes/core/point_data_model.py

@@ -98,8 +98,7 @@ class PointDataModel(DataCalcModel):
 
     def run_calculation(self, algo, *data, out_vars, **calc_pars):
         """
-        Starts the model calculation in parallel, via
-        xarray's `apply_ufunc`.
+        Starts the model calculation in parallel.
 
         Typically this function is called by algorithms.
 
@@ -149,7 +148,7 @@ class PointDataModelList(PointDataModel):
 
     By using the PointDataModelList the models'
     `calculate` functions are called together
-    under one common call of xarray's `apply_ufunc`.
+    under one common call by the engine.
 
     Attributes
     ----------

foxes/core/rotor_model.py

@@ -60,6 +60,10 @@ class RotorModel(FarmDataModel):
         """
         if self.calc_vars is None:
             vrs = algo.states.output_point_vars(algo)
+            assert FV.WEIGHT not in vrs, (
+                f"Rotor '{self.name}': States '{algo.states.name}' output_point_vars contain '{FV.WEIGHT}', please remove"
+            )
+
             if FV.WS in vrs:
                 self.calc_vars = [FV.REWS] + [v for v in vrs if v != FV.WS]
             else:
@@ -72,6 +76,9 @@ class RotorModel(FarmDataModel):
 
             self.calc_vars = sorted(self.calc_vars)
 
+        if FV.WEIGHT not in self.calc_vars:
+            self.calc_vars.append(FV.WEIGHT)
+
         return self.calc_vars
 
     @abstractmethod
@@ -174,9 +181,7 @@ class RotorModel(FarmDataModel):
         elif res.shape[1] == 1:
             fdata[v][:, downwind_index] = res[:, 0]
         else:
-            raise ValueError(
-                f"Rotor model '{self.name}': downwind_index is not None, but results shape for '{v}' has more than one turbine, {res.shape}"
-            )
+            fdata[v, downwind_index] = res[:, downwind_index]
 
     def eval_rpoint_results(
         self,
@@ -184,7 +189,7 @@ class RotorModel(FarmDataModel):
         mdata,
         fdata,
         tdata,
-        weights,
+        rpoint_weights,
         downwind_index=None,
         copy_to_ambient=False,
     ):
@@ -207,7 +212,7 @@ class RotorModel(FarmDataModel):
             The farm data
         tdata: foxes.core.TData
             The target point data
-        weights: numpy.ndarray
+        rpoint_weights: numpy.ndarray
             The rotor point weights, shape: (n_rpoints,)
         downwind_index: int, optional
             The index in the downwind order
@@ -233,7 +238,7 @@ class RotorModel(FarmDataModel):
             wd = tdata[FV.WD]
             ws = tdata[FV.WS]
             uvp = wd2uv(wd, ws, axis=-1)
-            uv = np.einsum("stpd,p->std", uvp, weights)
+            uv = np.einsum("stpd,p->std", uvp, rpoint_weights)
 
         wd = None
         vdone = []
@@ -243,7 +248,6 @@ class RotorModel(FarmDataModel):
                     wd = uv2wd(uv, axis=-1)
                 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, downwind_index)
@@ -265,7 +269,7 @@ class RotorModel(FarmDataModel):
 
             for v in self.calc_vars:
                 if v == FV.REWS:
-                    rews = np.maximum(np.einsum("stp,p->st", wsp, weights), 0.0)
+                    rews = np.maximum(np.einsum("stp,p->st", wsp, rpoint_weights), 0.0)
                     self._set_res(fdata, v, rews, downwind_index)
                     del rews
                     vdone.append(v)
@@ -278,12 +282,14 @@ class RotorModel(FarmDataModel):
                     if uvp.shape[2] > 1:
                         rews2 = np.sqrt(
                             np.maximum(
-                                np.einsum("stp,p->st", np.sign(wsp) * wsp**2, weights),
+                                np.einsum(
+                                    "stp,p->st", np.sign(wsp) * wsp**2, rpoint_weights
+                                ),
                                 0.0,
                             )
                         )
                     else:
-                        rews2 = np.sqrt(np.einsum("stp,p->st", wsp**2, weights))
+                        rews2 = np.sqrt(np.einsum("stp,p->st", wsp**2, rpoint_weights))
                     self._set_res(fdata, v, rews2, downwind_index)
                     del rews2
                     vdone.append(v)
@@ -295,10 +301,12 @@ class RotorModel(FarmDataModel):
                     # turbine axis direction:
                     if uvp.shape[2] > 1:
                         rews3 = np.maximum(
-                            np.einsum("stp,p->st", wsp**3, weights), 0.0
+                            np.einsum("stp,p->st", wsp**3, rpoint_weights), 0.0
                         ) ** (1.0 / 3.0)
                     else:
-                        rews3 = (np.einsum("stp,p->st", wsp**3, weights)) ** (1.0 / 3.0)
+                        rews3 = (np.einsum("stp,p->st", wsp**3, rpoint_weights)) ** (
+                            1.0 / 3.0
+                        )
                     self._set_res(fdata, v, rews3, downwind_index)
                     del rews3
                     vdone.append(v)
@@ -307,8 +315,10 @@ class RotorModel(FarmDataModel):
         del uvp
 
         for v in self.calc_vars:
-            if v not in vdone:
-                res = np.einsum("stp,p->st", tdata[v], weights)
+            if v not in vdone and (
+                fdata[v].shape[1] > 1 or downwind_index is None or downwind_index == 0
+            ):
+                res = np.einsum("stp,p->st", tdata[v], rpoint_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()
@@ -319,10 +329,8 @@ class RotorModel(FarmDataModel):
         mdata,
         fdata,
         rpoints=None,
-        weights=None,
-        store_rpoints=False,
-        store_rweights=False,
-        store_amb_res=False,
+        rpoint_weights=None,
+        store=False,
         downwind_index=None,
     ):
         """
@@ -339,16 +347,11 @@ class RotorModel(FarmDataModel):
         rpoints: numpy.ndarray, optional
             The rotor points, or None for automatic for
             this rotor. Shape: (n_states, n_turbines, n_rpoints, 3)
-        weights: numpy.ndarray, optional
+        rpoint_weights: numpy.ndarray, optional
             The rotor point weights, or None for automatic
             for this rotor. Shape: (n_rpoints,)
-        store_rpoints: bool, optional
-            Switch for storing rotor points to mdata
-        store_rweights: bool, optional
-            Switch for storing rotor point weights to mdata
-        store_amb_res: bool, optional
-            Switch for storing ambient rotor point reults as they
-            come from the states to mdata
+        store: bool, optional
+            Flag for storing ambient rotor point results
         downwind_index: int, optional
             Only compute for index in the downwind order
 
@@ -364,18 +367,12 @@ class RotorModel(FarmDataModel):
             rpoints = mdata.get(
                 FC.ROTOR_POINTS, self.get_rotor_points(algo, mdata, fdata)
             )
-        if store_rpoints:
-            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
-
         if downwind_index is not None:
             rpoints = rpoints[:, downwind_index, None]
+        if rpoint_weights is None:
+            rpoint_weights = mdata.get_item(FC.TWEIGHTS, self.rotor_point_weights())
 
-        if weights is None:
-            weights = mdata.get(FC.TWEIGHTS, self.rotor_point_weights())
-        if store_rweights:
-            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, weights, mdata=mdata)
-
-        tdata = TData.from_tpoints(rpoints, weights)
+        tdata = TData.from_tpoints(rpoints, rpoint_weights)
         svars = algo.states.output_point_vars(algo)
         for v in svars:
             tdata.add(
@@ -386,16 +383,23 @@ class RotorModel(FarmDataModel):
 
         sres = algo.states.calculate(algo, mdata, fdata, tdata)
         tdata.update(sres)
+        if FV.WEIGHT not in tdata:
+            raise KeyError(
+                f"Rotor '{self.name}': States '{algo.states.name}' failed to provide '{FV.WEIGHT}' in tdata"
+            )
 
-        if store_amb_res:
-            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres.copy(), mdata=mdata)
+        if store:
+            algo.add_to_chunk_store(FC.ROTOR_POINTS, rpoints, mdata=mdata)
+            algo.add_to_chunk_store(FC.ROTOR_WEIGHTS, rpoint_weights, mdata=mdata)
+            algo.add_to_chunk_store(FC.AMB_ROTOR_RES, sres, mdata=mdata)
+            algo.add_to_chunk_store(FC.WEIGHT_RES, tdata[FV.WEIGHT], mdata=mdata)
 
         self.eval_rpoint_results(
             algo,
             mdata,
             fdata,
             tdata,
-            weights,
+            rpoint_weights,
             downwind_index,
             copy_to_ambient=True,
         )

foxes/core/states.py

@@ -2,7 +2,6 @@ from abc import abstractmethod
 
 from .point_data_model import PointDataModel, PointDataModelList
 from foxes.utils import new_instance
-import foxes.variables as FV
 import foxes.constants as FC
 
 
@@ -43,24 +42,6 @@ class States(PointDataModel):
         """
         return list(range(self.size()))
 
-    @abstractmethod
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        pass
-
     def reset(self, algo=None, states_sel=None, states_loc=None, verbosity=0):
         """
         Reset the states, optionally select states
@@ -106,19 +87,9 @@ class States(PointDataModel):
         if sinds is not None:
             idata["coords"][FC.STATE] = sinds
 
-        weights = self.weights(algo)
-        if len(weights.shape) != 2:
-            raise ValueError(
-                f"States '{self.name}': Wrong weights dimension, expecing ({FC.STATE}, {FC.TURBINE}), got shape {weights.shape}"
-            )
-        if weights.shape[1] != algo.n_turbines:
-            raise ValueError(
-                f"States '{self.name}': Wrong size of second axis dimension '{FC.TURBINE}': Expecting {algo.n_turbines}, got {weights.shape[1]}"
-            )
-        idata["data_vars"][FV.WEIGHT] = ((FC.STATE, FC.TURBINE), weights)
-
         return idata
 
+    @abstractmethod
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -134,7 +105,7 @@ class States(PointDataModel):
             The output variable names
 
         """
-        return [FV.WS, FV.WD, FV.TI, FV.RHO]
+        pass
 
     def __add__(self, s):
         if isinstance(s, list):
@@ -142,7 +113,7 @@ class States(PointDataModel):
         elif isinstance(s, ExtendedStates):
             if s.states is not self:
                 raise ValueError(
-                    f"Cannot add extended states, since not based on same states"
+                    "Cannot add extended states, since not based on same states"
                 )
             return ExtendedStates(self, s.pmodels.models[1:])
         else:
@@ -245,23 +216,6 @@ class ExtendedStates(States):
         """
         return self.states.index()
 
-    def weights(self, algo):
-        """
-        The statistical weights of all states.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-
-        Returns
-        -------
-        weights: numpy.ndarray
-            The weights, shape: (n_states, n_turbines)
-
-        """
-        return self.states.weights(algo)
-
     def output_point_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -313,7 +267,7 @@ class ExtendedStates(States):
         elif isinstance(m, ExtendedStates):
             if m.states is not self.states:
                 raise ValueError(
-                    f"Cannot add extended states, since not based on same states"
+                    "Cannot add extended states, since not based on same states"
                 )
             return ExtendedStates(self.states, models + m.pmodels.models[1:])
         else:

foxes/core/turbine.py

@@ -1,4 +1,5 @@
 import numpy as np
+from copy import deepcopy
 
 
 class Turbine:
@@ -71,7 +72,7 @@ class Turbine:
         self.index = index
         self.name = name
         self.xy = np.array(xy)
-        self.models = turbine_models
+        self.models = deepcopy(turbine_models)
         self.D = D
         self.H = H
 

foxes/core/wake_deflection.py

@@ -0,0 +1,130 @@
+from abc import abstractmethod
+
+from foxes.utils import new_instance
+from .model import Model
+
+
+class WakeDeflection(Model):
+    """
+    Abstract base class for wake deflection models.
+
+    :group: core
+
+    """
+
+    @property
+    def has_uv(self):
+        """
+        This model uses wind vector data
+
+        Returns
+        -------
+        hasuv: bool
+            Flag for wind vector data
+
+        """
+        return False
+
+    @abstractmethod
+    def calc_deflection(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        coos,
+    ):
+        """
+        Calculates the wake deflection.
+
+        This function optionally adds FC.WDEFL_ROT_ANGLE or
+        FC.WDEFL_DWS_FACTOR to the tdata.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
+
+        Returns
+        -------
+        coos: numpy.ndarray
+            The wake frame coordinates of the evaluation
+            points, shape: (n_states, n_targets, n_tpoints, 3)
+
+        """
+        pass
+
+    def get_yaw_alpha_seq(
+        self,
+        algo,
+        mdata,
+        fdata,
+        tdata,
+        downwind_index,
+        x,
+    ):
+        """
+        Computes sequential wind vector rotation angles.
+
+        Wind vector rotation angles are computed at the
+        current trace points due to a yawed rotor
+        for sequential runs.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwind order
+        x: numpy.ndarray
+            The distance from the wake causing rotor
+            for the first n_times subsequent time steps,
+            shape: (n_times,)
+
+        Returns
+        -------
+        alpha: numpy.ndarray
+            The delta WD result at the x locations,
+            shape: (n_times,)
+
+        """
+        raise NotImplementedError(
+            f"Wake deflection '{self.name}' not implemented for sequential runs"
+        )
+
+    @classmethod
+    def new(cls, wframe_type, *args, **kwargs):
+        """
+        Run-time wake deflection model factory.
+
+        Parameters
+        ----------
+        wframe_type: str
+            The selected derived class name
+        args: tuple, optional
+            Additional parameters for constructor
+        kwargs: dict, optional
+            Additional parameters for constructor
+
+        """
+        return new_instance(cls, wframe_type, *args, **kwargs)