foxes 1.3__py3-none-any.whl → 1.5__py3-none-any.whl

foxes/core/farm_data_model.py

@@ -66,28 +66,29 @@ class FarmDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TURBINE)
 
-    def ensure_variables(self, algo, mdata, fdata):
+    def ensure_output_vars(self, algo, fdata):
         """
-        Add variables to fdata, initialized with NaN
+        Ensures that the output variables are present in the farm data.
 
         Parameters
         ----------
         algo: foxes.core.Algorithm
             The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
+        fdata: foxes.core.FData
             The farm data
 
         """
-        n_states = fdata.n_states
-        n_turbines = fdata.n_turbines
-        for v in self.output_farm_vars(algo):
-            if v not in fdata:
-                fdata[v] = np.full(
-                    (n_states, n_turbines), np.nan, dtype=config.dtype_double
+        for var in self.output_farm_vars(algo):
+            if var not in fdata:
+                fdata.add(
+                    var,
+                    np.full(
+                        (fdata.n_states, fdata.n_turbines),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TURBINE),
                 )
-                fdata.dims[v] = (FC.STATE, FC.TURBINE)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata):
@@ -264,7 +265,7 @@ class FarmDataModelList(FarmDataModel):
             The model data
         fdata: foxes.core.FData
             The farm data
-        parameters: list of dict, optional
+        parameters: list of dict
             A list of parameter dicts, one for each model
 
         Returns
@@ -274,6 +275,8 @@ class FarmDataModelList(FarmDataModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):

foxes/core/ground_model.py

@@ -91,7 +91,6 @@ class GroundModel(Model):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -114,11 +113,6 @@ class GroundModel(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
@@ -143,7 +137,6 @@ class GroundModel(Model):
             mdata,
             fdata,
             tdata,
-            amb_res,
             rpoint_weights,
             wake_deltas,
             wmodel,
@@ -226,7 +219,7 @@ class GroundModel(Model):
         algo,
         mdata,
         fdata,
-        amb_results,
+        tdata,
         wake_deltas,
         wmodel,
     ):
@@ -243,17 +236,15 @@ class GroundModel(Model):
             The model data
         fdata: foxes.core.FData
             The farm data
-        amb_results: dict
-            The ambient results, key: variable name str,
-            values: numpy.ndarray with shape
-            (n_states, n_targets, n_tpoints)
+        tdata: foxes.core.TData
+            The target point data
         wake_deltas: dict
             The wake deltas object at the selected target
             turbines. Key: variable str, value: numpy.ndarray
             with shape (n_states, n_targets, n_tpoints)
 
         """
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, amb_results, wake_deltas)
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, tdata, wake_deltas)
 
     @classmethod
     def new(cls, ground_type, *args, **kwargs):

foxes/core/model.py

@@ -64,12 +64,30 @@ class Model(ABC):
 
         Returns
         -------
-        str
+        vnm: str
             Model specific variable name
 
         """
         return f"{self.name}_{v}"
 
+    def unvar(self, vnm):
+        """
+        Translates model specific variable name to origninal variable name.
+
+        Parameters
+        ----------
+        vnm: str
+            The vamodel specific variable name
+
+        Returns
+        -------
+        v: str
+            Original variable name
+
+        """
+        lng = len(f"{self.name}_")
+        return vnm[lng:] if vnm.startswith(f"{self.name}_") else None
+
     @property
     def initialized(self):
         """
@@ -77,7 +95,7 @@ class Model(ABC):
 
         Returns
         -------
-        bool :
+        bool:
             True if the model has been initialized.
 
         """
@@ -424,8 +442,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 +466,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

@@ -42,30 +42,33 @@ class PointDataModel(DataCalcModel):
         """
         return (FC.STATE, FC.TARGET, FC.TPOINT)
 
-    def ensure_variables(self, algo, mdata, fdata, tdata):
+    def ensure_output_vars(self, algo, tdata):
         """
-        Add variables to tdata, initialized with NaN
+        Ensures that the output variables are present in the target data.
 
         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
+        tdata: foxes.core.TData
             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=config.dtype_double,
+        vrs = set(self.output_point_vars(algo))
+        if hasattr(self, "fixed_vars"):
+            vrs.update(self.fixed_vars.keys())
+
+        for var in vrs:
+            if var not in tdata:
+                tdata.add(
+                    var,
+                    np.full(
+                        (tdata.n_states, tdata.n_targets, tdata.n_tpoints),
+                        np.nan,
+                        dtype=config.dtype_double,
+                    ),
+                    (FC.STATE, FC.TARGET, FC.TPOINT),
                 )
-                tdata.dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
 
     @abstractmethod
     def calculate(self, algo, mdata, fdata, tdata):
@@ -98,8 +101,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 +151,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
     ----------
@@ -248,6 +250,8 @@ class PointDataModelList(PointDataModel):
             (n_states, n_targets, n_tpoints)
 
         """
+        self.ensure_output_vars(algo, tdata)
+
         if parameters is None:
             parameters = [{}] * len(self.models)
         elif not isinstance(parameters, list):

foxes/core/rotor_model.py

@@ -60,9 +60,9 @@ 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"
+            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]
@@ -362,6 +362,7 @@ class RotorModel(FarmDataModel):
             numpy.ndarray with results, shape: (n_states, n_turbines)
 
         """
+        self.ensure_output_vars(algo, fdata)
 
         if rpoints is None:
             rpoints = mdata.get(

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
 
 
@@ -114,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:
@@ -268,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, wdefl_type, *args, **kwargs):
+        """
+        Run-time wake deflection model factory.
+
+        Parameters
+        ----------
+        wdefl_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, wdefl_type, *args, **kwargs)