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

foxes/models/partial_wakes/axiwake.py

@@ -1,13 +1,14 @@
 import numpy as np
 
-from foxes.core import PartialWakesModel, Data
 from foxes.models.wake_models.axisymmetric import AxisymmetricWakeModel
 from foxes.utils.two_circles import calc_area
 import foxes.variables as FV
 import foxes.constants as FC
 
+from .centre import PartialCentre
 
-class PartialAxiwake(PartialWakesModel):
+
+class PartialAxiwake(PartialCentre):
     """
     Partial wake calculation for axial wake models.
 
@@ -22,14 +23,12 @@ class PartialAxiwake(PartialWakesModel):
     ----------
     n: int
         The number of radial evaluation points
-    rotor_model: foxes.core.RotorModel
-        The rotor model, default is the one from the algorithm
 
     :group: models.partial_wakes
 
     """
 
-    def __init__(self, n, wake_models=None, wake_frame=None, rotor_model=None):
+    def __init__(self, n=6):
         """
         Constructor.
 
@@ -37,147 +36,93 @@ class PartialAxiwake(PartialWakesModel):
         ----------
         n: int
             The number of radial evaluation points
-        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.n = n
-        self.rotor_model = rotor_model
 
     def __repr__(self):
-        return super().__repr__() + f"(n={self.n})"
-
-    def initialize(self, algo, verbosity=0):
-        """
-        Initializes the model.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        verbosity: int
-            The verbosity level, 0 = silent
-
-        """
-        if self.rotor_model is None:
-            self.rotor_model = algo.rotor_model
-        super().initialize(algo, verbosity)
-
-        for w in self.wake_models:
-            if not isinstance(w, AxisymmetricWakeModel):
-                raise TypeError(
-                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{w.name}', since not an AxisymmetricWakeModel"
-                )
-
-    def sub_models(self):
-        """
-        List of all sub-models
-
-        Returns
-        -------
-        smdls: list of foxes.core.Model
-            All sub models
-
-        """
-        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])
+        return f"{type(self).__name__}(n={self.n})"
 
-        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
 
         """
+        if not isinstance(wmodel, AxisymmetricWakeModel):
+            raise TypeError(
+                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not an AxisymmetricWakeModel"
+            )
+
         # prepare:
         n_states = mdata.n_states
-        n_turbines = algo.n_turbines
-        D = fdata[FV.D]
+        n_targets = tdata.n_targets
+
+        # get D:
+        D = self.get_data(
+            FV.D,
+            FC.STATE_TARGET,
+            lookup="w",
+            algo=algo,
+            fdata=fdata,
+            tdata=tdata,
+            downwind_index=downwind_index,
+            upcast=True,
+        )
 
         # calc coordinates to rotor centres:
-        wcoos = self.wake_frame.get_wake_coos(
-            algo, mdata, fdata, pdata, states_source_turbine
-        )
+        wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
 
         # prepare x and r coordinates:
-        x = wcoos[:, :, 0]
-        n = wcoos[:, :, 1:3]
+        x = np.round(wcoos[..., 0, 0], 12)
+        n = wcoos[..., 0, 1:3]
         R = np.linalg.norm(n, axis=-1)
-        r = np.zeros((n_states, n_turbines, self.n), dtype=FC.DTYPE)
+        r = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
         del wcoos
 
         # prepare circle section area calculation:
-        A = np.zeros((n_states, n_turbines, self.n), dtype=FC.DTYPE)
+        A = np.zeros((n_states, n_targets, self.n), dtype=FC.DTYPE)
         weights = np.zeros_like(A)
 
         # get normalized 2D vector between rotor and wake centres:
-        sel = R > 0.0
+        sel = R > 0
         if np.any(sel):
             n[sel] /= R[sel][:, None]
         if np.any(~sel):
             n[:, :, 0][~sel] = 1
 
         # case wake centre outside rotor disk:
-        sel = (x > 1e-5) & (R > D / 2)
+        sel = (x > 0) & (R > D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
             Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
@@ -199,7 +144,7 @@ class PartialAxiwake(PartialWakesModel):
             del hA, Rsel, Dsel, R1, R2
 
         # case wake centre inside rotor disk:
-        sel = (x > 1e-5) & (R < D / 2)
+        sel = (x > 0) & (R < D / 2)
         if np.any(sel):
             n_sel = np.sum(sel)
             Rsel = np.zeros((n_sel, self.n + 1), dtype=FC.DTYPE)
@@ -225,101 +170,29 @@ class PartialAxiwake(PartialWakesModel):
             weights[sel] = hA / np.sum(hA, axis=-1)[:, None]
             del hA, hr, Rsel, Dsel, R1, R2
 
-        # evaluate wake models:
-        for w in self.wake_models:
-            wdeltas, sp_sel = w.calc_wakes_spsel_x_r(
-                algo, mdata, fdata, pdata, states_source_turbine, x, r
-            )
-
-            for v, wdel in wdeltas.items():
-                d = np.einsum("ps,ps->p", wdel, weights[sp_sel])
-
-                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,
-                    sp_sel,
-                    v,
-                    wake_deltas[v],
-                    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)
+        # evaluate wake model:
+        wdeltas, st_sel = wmodel.calc_wakes_x_r(
+            algo, mdata, fdata, tdata, downwind_index, x, r
+        )
 
-        """
+        for v, wdel in wdeltas.items():
+            d = np.einsum("sn,sn->s", wdel, weights[st_sel])
 
-        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
+            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()))}"
+                )
 
-        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
+            wake_deltas[v] = superp.add_wake(
+                algo,
+                mdata,
+                fdata,
+                tdata,
+                downwind_index,
+                st_sel,
+                v,
+                wake_deltas[v],
+                d[:, None],
             )
-
-        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/partial_wakes/centre.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+import foxes.variables as FV
+import foxes.constants as FC
+from .rotor_points import RotorPoints
+
+
+class PartialCentre(RotorPoints):
+    """
+    Partial wakes calculated only at the
+    rotor centre point.
+
+    :group: models.partial_wakes
+
+    """
+
+    def get_wake_points(self, algo, mdata, fdata):
+        """
+        Get the wake calculation points, and their
+        weights.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+        mdata: foxes.core.MData
+            The model data
+        fdata: foxes.core.FData
+            The farm data
+
+        Returns
+        -------
+        rpoints: numpy.ndarray
+            The wake calculation points, shape:
+            (n_states, n_turbines, n_tpoints, 3)
+        rweights: numpy.ndarray
+            The target point weights, shape: (n_tpoints,)
+
+        """
+        return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=FC.DTYPE)

foxes/models/partial_wakes/grid.py

@@ -1,8 +1,8 @@
-from foxes.models.partial_wakes.distsliced import PartialDistSlicedWake
+from .segregated import PartialSegregated
 from foxes.models.rotor_models.grid import GridRotor
 
 
-class PartialGrid(PartialDistSlicedWake):
+class PartialGrid(PartialSegregated):
     """
     Partial wakes on a grid rotor that may
     differ from the one in the algorithm.
@@ -11,72 +11,16 @@ class PartialGrid(PartialDistSlicedWake):
 
     """
 
-    def __init__(
-        self, n, wake_models=None, wake_frame=None, rotor_model=None, **kwargs
-    ):
+    def __init__(self, *args, **kwargs):
         """
         Constructor.
 
         Parameters
         ----------
-        n: int, optional
-            The `GridRotor`'s `n` parameter
-        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
+        args: tuple, optional
+            Parameters for GridRotor
         kwargs: dict, optional
-            Additional parameters for the `GridRotor`
+            Parameters for GridRotor
 
         """
-        super().__init__(n, wake_models, wake_frame, rotor_model, **kwargs)
-
-        if not isinstance(self.grotor, GridRotor):
-            raise ValueError(
-                f"Wrong grotor type, expecting {GridRotor.__name__}, got {type(self.grotor).__name__}"
-            )
-
-    def contribute_to_wake_deltas(
-        self,
-        algo,
-        mdata,
-        fdata,
-        pdata,
-        states_source_turbine,
-        wake_deltas,
-    ):
-        """
-        Modifies wake deltas by contributions from the
-        specified wake source turbines.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.Data
-            The model data
-        fdata: foxes.core.Data
-            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
-
-        """
-
-        # evaluate grid rotor:
-        wcoos = self.wake_frame.get_wake_coos(
-            algo, mdata, fdata, pdata, states_source_turbine
-        )
-
-        # evaluate wake models:
-        for w in self.wake_models:
-            w.contribute_to_wake_deltas(
-                algo, mdata, fdata, pdata, states_source_turbine, wcoos, wake_deltas
-            )
+        super().__init__(GridRotor(*args, calc_vars=[], **kwargs))