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

foxes/core/data.py

@@ -28,9 +28,9 @@ class Data(Dict):
 
     def __init__(
         self,
-        data,
-        dims,
-        loop_dims,
+        data={},
+        dims={},
+        loop_dims=[FC.STATE],
         states_i0=None,
         name="data",
     ):
@@ -153,13 +153,13 @@ class Data(Dict):
         # remove axes of size 1, added by dask for extra loop dimensions:
         if dims is not None:
             if len(dims) != len(data.shape):
-                for li, l in enumerate(self.loop_dims):
-                    if data.shape[li] == 1 and (len(dims) < li + 1 or dims[li] != l):
+                for li, ld in enumerate(self.loop_dims):
+                    if data.shape[li] == 1 and (len(dims) < li + 1 or dims[li] != ld):
                         self[name] = np.squeeze(data, axis=li)
             for ci, c in enumerate(dims):
                 if c not in self.sizes or self.sizes[c] == 1:
                     self.sizes[c] = self[name].shape[ci]
-                elif self[name].shape[ci] == 1:
+                elif c != FC.TARGET and self[name].shape[ci] == 1:
                     pass
                 elif self.sizes[c] != self[name].shape[ci]:
                     raise ValueError(
@@ -240,9 +240,14 @@ class Data(Dict):
                 )
         else:
             states_i0 = None
-        return type(self)(
-            data, dims, loop_dims=self.loop_dims, name=name, states_i0=states_i0
-        )
+
+        cls = type(self)
+        if issubclass(cls, Data):
+            return cls(data, dims, name=name, states_i0=states_i0)
+        else:
+            return cls(
+                data, dims, loop_dims=self.loop_dims, name=name, states_i0=states_i0
+            )
 
     @classmethod
     def from_dataset(cls, ds, *args, callback=None, s_states=None, copy=True, **kwargs):
@@ -360,7 +365,7 @@ class FData(Data):
             Arguments for the base class
 
         """
-        super().__init__(*args, name=name, **kwargs)
+        super().__init__(*args, loop_dims=[FC.STATE], name=name, **kwargs)
 
     def _run_entry_checks(self, name, data, dims):
         """Run entry checks on new data"""
@@ -453,7 +458,7 @@ class TData(Data):
             Arguments for the base class
 
         """
-        super().__init__(*args, name=name, **kwargs)
+        super().__init__(*args, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs)
 
     def _run_entry_checks(self, name, data, dims):
         """Run entry checks on new data"""
@@ -635,9 +640,7 @@ class TData(Data):
             for v in variables:
                 data[v] = np.full_like(points[:, :, None, 0], np.nan)
                 dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
-        return cls(
-            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
-        )
+        return cls(data=data, dims=dims, name=name, **kwargs)
 
     @classmethod
     def from_tpoints(
@@ -694,9 +697,7 @@ class TData(Data):
             for v in variables:
                 data[v] = np.full_like(tpoints[..., 0], np.nan)
                 dims[v] = (FC.STATE, FC.TARGET, FC.TPOINT)
-        return cls(
-            data=data, dims=dims, loop_dims=[FC.STATE, FC.TARGET], name=name, **kwargs
-        )
+        return cls(data=data, dims=dims, name=name, **kwargs)
 
     @classmethod
     def from_dataset(
@@ -764,7 +765,7 @@ class TData(Data):
                             FC.TPOINT,
                         ):
                             raise ValueError(
-                                f"Expecting coordinates '{ (FC.STATE, FC.TARGET, FC.TPOINT)}' at positions 0-2 for data variable '{v}', got {dims[v]}"
+                                f"Expecting coordinates '{(FC.STATE, FC.TARGET, FC.TPOINT)}' at positions 0-2 for data variable '{v}', got {dims[v]}"
                             )
                         else:
                             data[v] = d[:, s_targets]

foxes/core/engine.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from tqdm import tqdm
 from xarray import Dataset
 
-from foxes.core import MData, FData, TData
+from .data import MData, FData, TData
 from foxes.utils import new_instance
 from foxes.config import config
 import foxes.constants as FC
@@ -73,7 +73,7 @@ class Engine(ABC):
 
     def __enter__(self):
         if self.__entered:
-            raise ValueError(f"Enter called for already entered engine")
+            raise ValueError("Enter called for already entered engine")
         self.__entered = True
         if not self.initialized:
             self.initialize()
@@ -81,7 +81,7 @@ class Engine(ABC):
 
     def __exit__(self, *exit_args):
         if not self.__entered:
-            raise ValueError(f"Exit called for not entered engine")
+            raise ValueError("Exit called for not entered engine")
         self.__entered = False
         if self.initialized:
             self.finalize(*exit_args)
@@ -127,7 +127,6 @@ class Engine(ABC):
                 raise ValueError(
                     f"Cannot initialize engine '{type(self).__name__}', since engine already set to '{type(get_engine()).__name__}'"
                 )
-            global __global_engine_data__
             __global_engine_data__["engine"] = self
             self.__initialized = True
 
@@ -148,7 +147,6 @@ class Engine(ABC):
         if self.entered:
             self.__exit__(type, value, traceback)
         elif self.initialized:
-            global __global_engine_data__
             __global_engine_data__["engine"] = None
             self.__initialized = False
 
@@ -304,9 +302,9 @@ class Engine(ABC):
                 chunk_sizes_targets[-extra:] += 1
 
             s = np.sum(chunk_sizes_targets)
-            assert (
-                s == n_targets
-            ), f"Targets count mismatch: Expecting {n_targets}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_targets]}"
+            assert s == n_targets, (
+                f"Targets count mismatch: Expecting {n_targets}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_targets]}"
+            )
 
         chunk_sizes_states = np.full(n_chunks_states, chunk_size_states)
         extra = n_states - n_chunks_states * chunk_size_states
@@ -314,9 +312,9 @@ class Engine(ABC):
             chunk_sizes_states[-extra:] += 1
 
         s = np.sum(chunk_sizes_states)
-        assert (
-            s == n_states
-        ), f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
+        assert s == n_states, (
+            f"States count mismatch: Expecting {n_states}, chunks sum is {s}. Chunks: {[int(c) for c in chunk_sizes_states]}"
+        )
 
         return chunk_sizes_states, chunk_sizes_targets
 
@@ -389,7 +387,6 @@ class Engine(ABC):
             mdata=mdata,
             s_states=s_states,
             callback=cb,
-            loop_dims=[FC.STATE],
             states_i0=i0_states,
             copy=True,
         )
@@ -413,7 +410,6 @@ class Engine(ABC):
                 s_states=s_states,
                 s_targets=s_targets,
                 callback=cb,
-                loop_dims=[FC.STATE, FC.TARGET],
                 states_i0=i0_states,
                 copy=True,
             )

foxes/core/farm_controller.py

@@ -171,7 +171,7 @@ class FarmController(FarmDataModel):
         for ti, t in enumerate(algo.farm.turbines):
             if tmis[ti] != len(models[ti]):
                 raise ValueError(
-                    f"Turbine {ti}, {t.name}: Could not find turbine model order that includes all {mtype} turbine models, missing {t.models[tmis[ti]:]}"
+                    f"Turbine {ti}, {t.name}: Could not find turbine model order that includes all {mtype} turbine models, missing {t.models[tmis[ti] :]}"
                 )
 
         return [m.name for m in tmodels], tmsels
@@ -253,7 +253,7 @@ class FarmController(FarmDataModel):
                         prer = m.pre_rotor
                     elif not prer and m.pre_rotor:
                         raise ValueError(
-                            f"Turbine {ti}, {t.name}: Model is classified as pre-rotor, but following the post-rotor model '{t.models[mi-1]}'"
+                            f"Turbine {ti}, {t.name}: Model is classified as pre-rotor, but following the post-rotor model '{t.models[mi - 1]}'"
                         )
                     if m.pre_rotor:
                         prer_models[ti].append(m)

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

@@ -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,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]

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, 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)