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

foxes/models/partial_wakes/top_hat.py

@@ -1,13 +1,14 @@
 import numpy as np
 
-from foxes.core import PartialWakesModel, Data
 from foxes.models.wake_models.top_hat import TopHatWakeModel
 from foxes.utils.two_circles import calc_area
 import foxes.variables as FV
 import foxes.constants as FC
 
+from .centre import PartialCentre
 
-class PartialTopHat(PartialWakesModel):
+
+class PartialTopHat(PartialCentre):
     """
     Partial wakes for top-hat models.
 
@@ -23,21 +24,17 @@ class PartialTopHat(PartialWakesModel):
 
     """
 
-    def __init__(self, wake_models=None, wake_frame=None, rotor_model=None):
+    def __init__(self, rotor_model=None):
         """
         Constructor.
 
         Parameters
         ----------
-        wake_models: list of foxes.core.WakeModel, optional
-            The wake models, default are the ones from the algorithm
-        wake_frame: foxes.core.WakeFrame, optional
-            The wake frame, default is the one from the algorithm
         rotor_model: foxes.core.RotorModel, optional
             The rotor model, default is the one from the algorithm
 
         """
-        super().__init__(wake_models, wake_frame)
+        super().__init__()
         self.rotor_model = rotor_model
 
     def initialize(self, algo, verbosity=0):
@@ -57,12 +54,6 @@ class PartialTopHat(PartialWakesModel):
 
         super().initialize(algo, verbosity)
 
-        for w in self.wake_models:
-            if not isinstance(w, TopHatWakeModel):
-                raise TypeError(
-                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{w.name}', since not a TopHatWakeModel"
-                )
-
         self.WCOOS_ID = self.var("WCOOS_ID")
         self.WCOOS_X = self.var("WCOOS_X")
         self.WCOOS_R = self.var("WCOOS_R")
@@ -79,211 +70,112 @@ class PartialTopHat(PartialWakesModel):
         """
         return super().sub_models() + [self.rotor_model]
 
-    def new_wake_deltas(self, algo, mdata, fdata):
-        """
-        Creates new initial wake deltas, filled
-        with zeros.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-
-        Returns
-        -------
-        wake_deltas: dict
-            Keys: Variable name str, values: any
-        pdata: foxes.core.Data
-            The evaluation point data
-
-        """
-        pdata = Data.from_points(points=fdata[FV.TXYH])
-
-        wake_deltas = {}
-        for w in self.wake_models:
-            w.init_wake_deltas(algo, mdata, fdata, pdata, wake_deltas)
-
-        return wake_deltas, pdata
-
-    def contribute_to_wake_deltas(
+    def contribute(
         self,
         algo,
         mdata,
         fdata,
-        pdata,
-        states_source_turbine,
+        tdata,
+        downwind_index,
         wake_deltas,
+        wmodel,
     ):
         """
-        Modifies wake deltas by contributions from the
-        specified wake source turbines.
+        Modifies wake deltas at target points by
+        contributions from the specified wake source turbines.
 
         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 of int
-            For each state, one turbine index corresponding
-            to the wake causing turbine. Shape: (n_states,)
-        wake_deltas: Any
-            The wake deltas object created by the
-            `new_wake_deltas` function
+        tdata: foxes.core.TData
+            The target point data
+        downwind_index: int
+            The index of the wake causing turbine
+            in the downwnd order
+        wake_deltas: dict
+            The wake deltas. Key: variable name,
+            value: numpy.ndarray with shape
+            (n_states, n_targets, n_tpoints, ...)
+        wmodel: foxes.core.WakeModel
+            The wake model
 
         """
-        n_states = mdata.n_states
-        n_points = fdata.n_turbines
-        stsel = (np.arange(n_states), states_source_turbine)
-
-        if (
-            self.WCOOS_ID not in mdata
-            or mdata[self.WCOOS_ID] != states_source_turbine[0]
-        ):
-            wcoos = self.wake_frame.get_wake_coos(
-                algo, mdata, fdata, pdata, states_source_turbine
+        if not isinstance(wmodel, TopHatWakeModel):
+            raise TypeError(
+                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not a TopHatWakeModel"
             )
-            mdata[self.WCOOS_ID] = states_source_turbine[0]
-            mdata[self.WCOOS_X] = wcoos[:, :, 0]
-            mdata[self.WCOOS_R] = np.linalg.norm(wcoos[:, :, 1:3], axis=-1)
-            wcoos[:, :, 1:3] = 0
-        else:
-            wcoos = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-            wcoos[:, :, 0] = mdata[self.WCOOS_X]
-
-        ct = np.zeros((n_states, n_points), dtype=FC.DTYPE)
-        ct[:] = fdata[FV.CT][stsel][:, None]
-        x = mdata[self.WCOOS_X]
-
-        sel0 = (ct > 0.0) & (x > 0.0)
+
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
+        x = wcoos[:, :, 0, 0]
+        yz = wcoos[:, :, 0, 1:3]
+        del wcoos
+
+        ct = self.get_data(
+            FV.CT,
+            FC.STATE_TARGET,
+            lookup="w",
+            fdata=fdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
+            algo=algo,
+            upcast=True,
+        )
+
+        sel0 = (ct > 0) & (x > 0)
         if np.any(sel0):
-            R = mdata[self.WCOOS_R]
-            r = np.zeros_like(R)
-            D = fdata[FV.D]
+            R = np.linalg.norm(yz, axis=-1)
+            del yz
+
+            D = self.get_data(
+                FV.D,
+                FC.STATE_TARGET,
+                lookup="w",
+                fdata=fdata,
+                tdata=tdata,
+                downwind_index=downwind_index,
+                algo=algo,
+                upcast=True,
+            )
 
-            for w in self.wake_models:
-                wr = w.calc_wake_radius(
-                    algo, mdata, fdata, pdata, states_source_turbine, x, ct
+            wr = wmodel.calc_wake_radius(
+                algo, mdata, fdata, tdata, downwind_index, x, ct
+            )
+
+            st_sel = sel0 & (wr > R - D / 2)
+            if np.any(st_sel):
+                x = x[st_sel]
+                ct = ct[st_sel]
+                wr = wr[st_sel]
+                R = R[st_sel]
+                D = D[st_sel]
+
+                clw = wmodel.calc_centreline(
+                    algo, mdata, fdata, tdata, downwind_index, st_sel, x, wr, ct
                 )
 
-                sel_sp = sel0 & (wr > R - D / 2)
-                if np.any(sel_sp):
-                    hx = x[sel_sp]
-                    hct = ct[sel_sp]
-                    hwr = wr[sel_sp]
+                weights = calc_area(D / 2, wr, R) / (np.pi * (D / 2) ** 2)
+
+                for v, d in clw.items():
+                    try:
+                        superp = wmodel.superp[v]
+                    except KeyError:
+                        raise KeyError(
+                            f"Model '{self.name}': Missing wake superposition entry for variable '{v}' in wake model '{wmodel.name}', found {sorted(list(wmodel.superp.keys()))}"
+                        )
 
-                    clw = w.calc_centreline_wake_deltas(
+                    wake_deltas[v] = superp.add_wake(
                         algo,
                         mdata,
                         fdata,
-                        pdata,
-                        states_source_turbine,
-                        sel_sp,
-                        hx,
-                        hwr,
-                        hct,
+                        tdata,
+                        downwind_index,
+                        st_sel,
+                        v,
+                        wake_deltas[v],
+                        weights[:, None] * d[:, None],
                     )
-                    del hx, hct
-
-                    hR = R[sel_sp]
-                    hD = D[sel_sp]
-                    weights = calc_area(hD / 2, hwr, hR) / (np.pi * (hD / 2) ** 2)
-                    del hD, hwr, hR
-
-                    for v, d in clw.items():
-                        try:
-                            superp = w.superp[v]
-                        except KeyError:
-                            raise KeyError(
-                                f"Model '{self.name}': Missing wake superposition entry for variable '{v}' in wake model '{w.name}', found {sorted(list(w.superp.keys()))}"
-                            )
-
-                        wake_deltas[v] = superp.calc_wakes_plus_wake(
-                            algo,
-                            mdata,
-                            fdata,
-                            pdata,
-                            states_source_turbine,
-                            sel_sp,
-                            v,
-                            wake_deltas[v],
-                            weights * d,
-                        )
-
-    def evaluate_results(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        wake_deltas,
-        states_turbine,
-        amb_res=None,
-    ):
-        """
-        Updates the farm data according to the wake
-        deltas.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            The farm data
-            Modified in-place by this function
-        pdata: foxes.core.Data
-            The evaluation point data
-        wake_deltas: Any
-            The wake deltas object, created by the
-            `new_wake_deltas` function and filled
-            by `contribute_to_wake_deltas`
-        states_turbine: numpy.ndarray of int
-            For each state, the index of one turbine
-            for which to evaluate the wake deltas.
-            Shape: (n_states,)
-        amb_res: dict, optional
-            Ambient states results. Keys: var str, values:
-            numpy.ndarray of shape (n_states, n_points)
-
-        """
-        weights = algo.rotor_model.from_data_or_store(FC.RWEIGHTS, algo, mdata)
-        rpoints = algo.rotor_model.from_data_or_store(FC.RPOINTS, algo, mdata)
-        n_states, n_turbines, n_rpoints, __ = rpoints.shape
-
-        amb_res_in = amb_res is not None
-        if not amb_res_in:
-            amb_res = algo.rotor_model.from_data_or_store(
-                FC.AMB_RPOINT_RESULTS, algo, mdata
-            )
-
-        wres = {}
-        st_sel = (np.arange(n_states), states_turbine)
-        for v, ares in amb_res.items():
-            wres[v] = ares.reshape(n_states, n_turbines, n_rpoints)[st_sel]
-
-        wdel = {}
-        for v, d in wake_deltas.items():
-            wdel[v] = d.reshape(n_states, n_turbines, 1)[st_sel]
-        for w in self.wake_models:
-            w.finalize_wake_deltas(algo, mdata, fdata, pdata, wres, wdel)
-
-        for v in wres.keys():
-            if v in wake_deltas:
-                wres[v] += wdel[v]
-                if amb_res_in:
-                    amb_res[v][st_sel] = wres[v]
-            wres[v] = wres[v][:, None]
-
-        self.rotor_model.eval_rpoint_results(
-            algo, mdata, fdata, wres, weights, states_turbine=states_turbine
-        )

foxes/models/point_models/set_uniform_data.py

@@ -129,12 +129,12 @@ class SetUniformData(PointDataModel):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------

foxes/models/point_models/tke2ti.py

@@ -40,12 +40,12 @@ class TKE2TI(PointDataModel):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------

foxes/models/point_models/wake_deltas.py

@@ -62,12 +62,12 @@ class WakeDeltas(PointDataModel):
         ----------
         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 point data
+        tdata: foxes.core.TData
+            The target point data
 
         Returns
         -------

foxes/models/rotor_models/centre.py

@@ -69,9 +69,9 @@ class CentreRotor(RotorModel):
         ----------
         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
@@ -90,7 +90,7 @@ class CentreRotor(RotorModel):
         fdata,
         rpoint_results,
         weights,
-        states_turbine=None,
+        downwind_index=None,
         copy_to_ambient=False,
     ):
         """
@@ -106,9 +106,9 @@ class CentreRotor(RotorModel):
         ----------
         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
         rpoint_results: dict
             The results at rotor points. Keys: variable str.
@@ -117,25 +117,21 @@ class CentreRotor(RotorModel):
             Else: (n_states, 1, n_rpoints)
         weights: numpy.ndarray
             The rotor point weights, shape: (n_rpoints,)
-        states_turbine: numpy.ndarray of int, optional
-            The turbine indices, one per state. Shape: (n_states,)
-        copy_to_ambient: bool, optional
+        downwind_index: int, optional
+            The index in the downwind order
+        copy_to_ambient: bool
             If `True`, the fdata results are copied to ambient
             variables after calculation
 
         """
         if len(weights) > 1:
             return super().eval_rpoint_results(
-                algo, mdata, fdata, rpoint_results, weights, states_turbine
+                algo, mdata, fdata, rpoint_results, weights, downwind_index
             )
 
         n_states = mdata.n_states
         n_turbines = algo.n_turbines
 
-        stsel = None
-        if states_turbine is not None:
-            stsel = (np.arange(n_states), states_turbine)
-
         uvp = None
         uv = None
         if (
@@ -160,11 +156,11 @@ class CentreRotor(RotorModel):
             if v == FV.WD or v == FV.YAW:
                 if wd is None:
                     wd = uv2wd(uv, axis=-1)
-                self._set_res(fdata, v, wd, stsel)
+                self._set_res(fdata, v, wd, downwind_index)
                 vdone.append(v)
 
             elif v == FV.WS:
-                self._set_res(fdata, v, ws[:, :, 0], stsel)
+                self._set_res(fdata, v, ws[:, :, 0], downwind_index)
                 del ws
                 vdone.append(v)
         del uv, wd
@@ -174,17 +170,17 @@ class CentreRotor(RotorModel):
             or FV.REWS2 in self.calc_vars
             or FV.REWS3 in self.calc_vars
         ):
-            if stsel is None:
+            if downwind_index is None:
                 yaw = fdata[FV.YAW]
             else:
-                yaw = fdata[FV.YAW][stsel][:, None]
+                yaw = fdata[FV.YAW][:, downwind_index, None]
             nax = wd2uv(yaw, axis=-1)
             wsp = np.einsum("stpd,std->stp", uvp, nax)
 
             for v in self.calc_vars:
                 if v == FV.REWS or v == FV.REWS2 or v == FV.REWS3:
                     rews = wsp[:, :, 0]
-                    self._set_res(fdata, v, rews, stsel)
+                    self._set_res(fdata, v, rews, downwind_index)
                     del rews
                     vdone.append(v)
 
@@ -194,7 +190,7 @@ class CentreRotor(RotorModel):
         for v in self.calc_vars:
             if v not in vdone:
                 res = rpoint_results[v][:, :, 0]
-                self._set_res(fdata, v, res, stsel)
+                self._set_res(fdata, v, res, downwind_index)
                 del res
             if copy_to_ambient and v in FV.var2amb:
                 fdata[FV.var2amb[v]] = fdata[v].copy()

foxes/models/rotor_models/grid.py

@@ -54,7 +54,8 @@ class GridRotor(RotorModel):
         self.nint = nint
 
     def __repr__(self):
-        return super().__repr__() + f"(n={self.n})"
+        r = "" if self.reduce else ", reduce=False"
+        return f"{type(self).__name__}(n={self.n}){r}"
 
     def initialize(self, algo, verbosity=0):
         """

foxes/models/rotor_models/levels.py

@@ -51,7 +51,8 @@ class LevelRotor(RotorModel):
         self.nint = nint
 
     def __repr__(self):
-        return super().__repr__() + f"(n={self.n})"
+        r = "" if self.reduce else ", reduce=False"
+        return f"{type(self).__name__}(n={self.n}){r}"
 
     def initialize(self, algo, verbosity=0):
         """

foxes/models/turbine_models/__init__.py

@@ -2,7 +2,6 @@
 Turbine models.
 """
 
-from .set_XYHD import SetXYHD
 from .kTI_model import kTI
 from .set_farm_vars import SetFarmVars
 from .thrust2ct import Thrust2Ct

foxes/models/turbine_models/calculator.py

@@ -16,7 +16,7 @@ class Calculator(TurbineModel):
     func: Function
         The function: f(in0, in1, ..., stsel) -> (out0, ou1, ...)
         where inX and outY are numpy.ndarrays and
-        st_sel is the boolean state-turbine selection.
+        st_sel is the state-turbine selection slice or array.
         All arrays have shape (n_states, n_turbines).
 
     :group: models.turbine_models
@@ -36,7 +36,7 @@ class Calculator(TurbineModel):
         func: Function
             The function: f(in0, in1, ..., stsel) -> (out0, ou1, ...)
             where inX and outY are numpy.ndarrays and
-            st_sel is the boolean state-turbine selection.
+            st_sel is the state-turbine selection slice or array.
             All arrays have shape (n_states, n_turbines).
         kwargs: dict, optional
             Additional arguments for TurbineModel
@@ -47,6 +47,10 @@ class Calculator(TurbineModel):
         self.out_vars = out_vars
         self.func = func
 
+    def __repr__(self):
+        a = f"{self.in_vars}, {self.out_vars}"
+        return f"{type(self).__name__}({a})"
+
     def output_farm_vars(self, algo):
         """
         The variables which are being modified by the model.
@@ -65,7 +69,7 @@ class Calculator(TurbineModel):
         return self.out_vars
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -75,13 +79,13 @@ class Calculator(TurbineModel):
         ----------
         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
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------

foxes/models/turbine_models/kTI_model.py

@@ -51,10 +51,12 @@ class kTI(TurbineModel):
         setattr(self, FV.KB, 0 if kb is None else kb)
 
     def __repr__(self):
-        return (
-            super().__repr__()
-            + f"({self.k_var}, kTI={getattr(self, FV.KTI)}, ti={self.ti_var})"
-        )
+        kti = getattr(self, FV.KTI)
+        kb = getattr(self, FV.KB)
+        ti = getattr(self, self.ti_var)
+        tiv = f", ti_val={ti}" if ti is not None else ""
+        a = f"kTI={kti}, kb={kb}, ti_var={self.ti_var}{tiv}, k_var={self.k_var}"
+        return f"{type(self).__name__}({a})"
 
     def output_farm_vars(self, algo):
         """
@@ -74,7 +76,7 @@ class kTI(TurbineModel):
         return [self.k_var]
 
     def calculate(self, algo, mdata, fdata, st_sel):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,
@@ -84,13 +86,13 @@ class kTI(TurbineModel):
         ----------
         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
-        st_sel: numpy.ndarray of bool
+        st_sel: slice or numpy.ndarray of bool
             The state-turbine selection,
-            shape: (n_states, n_turbines)
+            for shape: (n_states, n_turbines)
 
         Returns
         -------
@@ -99,7 +101,7 @@ class kTI(TurbineModel):
             Values: numpy.ndarray with shape (n_states, n_turbines)
 
         """
-        kTI = self.get_data(
+        kti = self.get_data(
             FV.KTI, FC.STATE_TURBINE, lookup="sf", fdata=fdata, upcast=True
         )[st_sel]
         kb = self.get_data(
@@ -113,6 +115,6 @@ class kTI(TurbineModel):
             self.k_var, np.zeros((fdata.n_states, fdata.n_turbines), dtype=FC.DTYPE)
         )
 
-        k[st_sel] = kTI * ti + kb
+        k[st_sel] = kti * ti + kb
 
         return {self.k_var: k}