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

foxes/models/partial_wakes/centre.py

@@ -39,3 +39,50 @@ class PartialCentre(RotorPoints):
 
         """
         return fdata[FV.TXYH][:, :, None], np.ones(1, dtype=config.dtype_double)
+
+    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 rotor_res.shape[2] > 1:
+            return np.einsum(
+                "str,r->st",
+                rotor_res,
+                rotor_weights,
+            )[:, :, None]
+        else:
+            return rotor_res

foxes/models/partial_wakes/rotor_points.py

@@ -39,13 +39,52 @@ class RotorPoints(PartialWakesModel):
             algo.get_from_chunk_store(FC.ROTOR_WEIGHTS, mdata=mdata),
         )
 
+    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)
+
+        """
+        return rotor_res
+
     def finalize_wakes(
         self,
         algo,
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -67,11 +106,6 @@ class RotorPoints(PartialWakesModel):
             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
@@ -91,14 +125,10 @@ class RotorPoints(PartialWakesModel):
             of shape (n_states, n_rotor_points)
 
         """
-        ares = {
-            v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
-            for v, d in amb_res.items()
-        }
         wdel = {
             v: d[:, downwind_index, None].copy() if d.shape[1] > 1 else d[:, 0, None]
             for v, d in wake_deltas.items()
         }
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, tdata, wdel)
 
         return {v: d[:, 0] for v, d in wdel.items()}

foxes/models/partial_wakes/segregated.py

@@ -87,7 +87,6 @@ class PartialSegregated(PartialWakesModel):
         mdata,
         fdata,
         tdata,
-        amb_res,
         rpoint_weights,
         wake_deltas,
         wmodel,
@@ -109,11 +108,6 @@ class PartialSegregated(PartialWakesModel):
             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
@@ -138,25 +132,8 @@ class PartialSegregated(PartialWakesModel):
         gweights = tdata[FC.TWEIGHTS]
 
         wdel = {v: d[:, downwind_index, None].copy() for v, d in wake_deltas.items()}
-
-        if n_rotor_points == tdata.n_tpoints:
-            ares = {
-                v: d[:, downwind_index, None] if d.shape[1] > 1 else d[:, 0, None]
-                for v, d in amb_res.items()
-            }
-        else:
-            ares = {}
-            for v, d in amb_res.items():
-                ares[v] = np.zeros(
-                    (n_states, 1, tdata.n_tpoints), dtype=config.dtype_double
-                )
-                ares[v][:] = np.einsum(
-                    "sp,p->s",
-                    d[:, downwind_index] if d.shape[1] > 1 else d[:, 0],
-                    rpoint_weights,
-                )[:, None, None]
-
-        wmodel.finalize_wake_deltas(algo, mdata, fdata, ares, wdel)
+        htdata = tdata.get_slice([FC.TURBINE], np.s_[downwind_index])
+        wmodel.finalize_wake_deltas(algo, mdata, fdata, htdata, wdel)
 
         for v in wdel.keys():
             hdel = np.zeros((n_states, n_rotor_points), dtype=config.dtype_double)

foxes/models/partial_wakes/top_hat.py

@@ -126,8 +126,6 @@ class PartialTopHat(PartialCentre):
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
             (n_states, n_targets, n_tpoints, ...)
-        wmodel: foxes.core.WakeModel
-            The wake model
 
         """
         self.check_wmodel(wmodel, error=True)
@@ -182,6 +180,33 @@ class PartialTopHat(PartialCentre):
 
                 weights = calc_area(D / 2, wr, R) / (np.pi * (D / 2) ** 2)
 
+                # run superposition models:
+                if wmodel.affects_ws and wmodel.has_uv:
+                    assert wmodel.has_vector_wind_superp, (
+                        f"{self.name}: Expecting vector wind superposition in wake model '{wmodel.name}', got '{wmodel.wind_superposition}'"
+                    )
+                    if FV.UV in clw:
+                        duv = clw.pop(FV.UV)
+                    else:
+                        clwe = {v: d[:, None] for v, d in clw.items()}
+                        wmodel.vec_superp.wdeltas_ws2uv(
+                            algo, fdata, tdata, downwind_index, clwe, st_sel
+                        )
+                        duv = np.einsum("sd,s->sd", clwe.pop(FV.UV)[:, 0], weights)
+                        del clwe, clw[FV.WS]
+                        if FV.WD in clw:
+                            del clw[FV.WD]
+                    wake_deltas[FV.UV] = wmodel.vec_superp.add_wake_vector(
+                        algo,
+                        mdata,
+                        fdata,
+                        tdata,
+                        downwind_index,
+                        st_sel,
+                        wake_deltas[FV.UV],
+                        duv[:, None],
+                    )
+
                 for v, d in clw.items():
                     try:
                         superp = wmodel.superp[v]

foxes/models/point_models/__init__.py

@@ -2,7 +2,7 @@
 Point models.
 """
 
-from .wake_deltas import WakeDeltas
-from .set_uniform_data import SetUniformData
-from .tke2ti import TKE2TI
-from .ustar2ti import Ustar2TI
+from .wake_deltas import WakeDeltas as WakeDeltas
+from .set_uniform_data import SetUniformData as SetUniformData
+from .tke2ti import TKE2TI as TKE2TI
+from .ustar2ti import Ustar2TI as Ustar2TI

foxes/models/rotor_models/__init__.py

@@ -2,6 +2,6 @@
 Rotor models.
 """
 
-from .centre import CentreRotor
-from .grid import GridRotor
-from .levels import LevelRotor
+from .centre import CentreRotor as CentreRotor
+from .grid import GridRotor as GridRotor
+from .levels import LevelRotor as LevelRotor

foxes/models/turbine_models/__init__.py

@@ -2,14 +2,14 @@
 Turbine models.
 """
 
-from .kTI_model import kTI
-from .set_farm_vars import SetFarmVars
-from .thrust2ct import Thrust2Ct
-from .power_mask import PowerMask
-from .sector_management import SectorManagement
-from .table_factors import TableFactors
-from .yaw2yawm import YAW2YAWM
-from .yawm2yaw import YAWM2YAW
-from .calculator import Calculator
-from .rotor_centre_calc import RotorCentreCalc
-from .lookup_table import LookupTable
+from .kTI_model import kTI as kTI
+from .set_farm_vars import SetFarmVars as SetFarmVars
+from .thrust2ct import Thrust2Ct as Thrust2Ct
+from .power_mask import PowerMask as PowerMask
+from .sector_management import SectorManagement as SectorManagement
+from .table_factors import TableFactors as TableFactors
+from .yaw2yawm import YAW2YAWM as YAW2YAWM
+from .yawm2yaw import YAWM2YAW as YAWM2YAW
+from .calculator import Calculator as Calculator
+from .rotor_centre_calc import RotorCentreCalc as RotorCentreCalc
+from .lookup_table import LookupTable as LookupTable

foxes/models/turbine_models/set_farm_vars.py

@@ -270,7 +270,6 @@ class SetFarmVars(TurbineModel):
         """
         i0 = mdata.states_i0(counter=True)
         if not self.once or i0 not in self.__once_done:
-
             if self.pre_rotor:
                 order = np.s_[:]
                 ssel = np.s_[:]

foxes/models/turbine_types/PCt_file.py

@@ -1,6 +1,5 @@
 import numpy as np
 import pandas as pd
-from pathlib import Path
 
 from foxes.core import TurbineType
 from foxes.utils import PandasFileHelper
@@ -232,7 +231,6 @@ class PCtFile(TurbineType):
 
         """
         if modify_ct or modify_P:
-
             ws = self.data_ws
             ct = self.data_ct
             P = self.data_P

foxes/models/turbine_types/PCt_from_two.py

@@ -263,7 +263,6 @@ class PCtFromTwo(TurbineType):
 
         """
         if modify_ct:
-
             ws = self._data_ws_ct
             ct = self._data_ct
 
@@ -291,7 +290,6 @@ class PCtFromTwo(TurbineType):
                 self._data_ct = np.concatenate([new_ct[:-1], ct], axis=0)
 
         if modify_P:
-
             ws = self._data_ws_P
             P = self._data_P
 

foxes/models/turbine_types/__init__.py

@@ -2,12 +2,12 @@
 Turbine type models.
 """
 
-from .PCt_file import PCtFile
-from .PCt_from_two import PCtFromTwo
-from .CpCt_file import CpCtFile
-from .CpCt_from_two import CpCtFromTwo
-from .null_type import NullType
-from .wsrho2PCt_from_two import WsRho2PCtFromTwo
-from .wsti2PCt_from_two import WsTI2PCtFromTwo
-from .lookup import FromLookupTable
-from .TBL_file import TBLFile
+from .PCt_file import PCtFile as PCtFile
+from .PCt_from_two import PCtFromTwo as PCtFromTwo
+from .CpCt_file import CpCtFile as CpCtFile
+from .CpCt_from_two import CpCtFromTwo as CpCtFromTwo
+from .null_type import NullType as NullType
+from .wsrho2PCt_from_two import WsRho2PCtFromTwo as WsRho2PCtFromTwo
+from .wsti2PCt_from_two import WsTI2PCtFromTwo as WsTI2PCtFromTwo
+from .lookup import FromLookupTable as FromLookupTable
+from .TBL_file import TBLFile as TBLFile

foxes/models/vertical_profiles/__init__.py

@@ -2,10 +2,10 @@
 Vertical profile models.
 """
 
-from .uniform import UniformProfile
-from .abl_log_neutral_ws import ABLLogNeutralWsProfile
-from .abl_log_stable_ws import ABLLogStableWsProfile
-from .abl_log_unstable_ws import ABLLogUnstableWsProfile
-from .abl_log_ws import ABLLogWsProfile
-from .sheared_ws import ShearedProfile
-from .data_profile import DataProfile
+from .uniform import UniformProfile as UniformProfile
+from .abl_log_neutral_ws import ABLLogNeutralWsProfile as ABLLogNeutralWsProfile
+from .abl_log_stable_ws import ABLLogStableWsProfile as ABLLogStableWsProfile
+from .abl_log_unstable_ws import ABLLogUnstableWsProfile as ABLLogUnstableWsProfile
+from .abl_log_ws import ABLLogWsProfile as ABLLogWsProfile
+from .sheared_ws import ShearedProfile as ShearedProfile
+from .data_profile import DataProfile as DataProfile

foxes/models/wake_deflections/__init__.py

@@ -0,0 +1,3 @@
+from .no_deflection import NoDeflection as NoDeflection
+from .bastankhah2016 import Bastankhah2016Deflection as Bastankhah2016Deflection
+from .jimenez import JimenezDeflection as JimenezDeflection

foxes/models/{wake_frames/yawed_wakes.py → wake_deflections/bastankhah2016.py}

@@ -1,18 +1,17 @@
 import numpy as np
 
-from foxes.core import WakeFrame, WakeK, TData
+from foxes.config import config
+from foxes.core.wake_deflection import WakeDeflection
+from foxes.core.wake_model import WakeK
 from foxes.models.wake_models.wind.bastankhah16 import (
     Bastankhah2016Model,
     Bastankhah2016,
 )
-from foxes.config import config
-import foxes.variables as FV
 import foxes.constants as FC
-
-from .rotor_wd import RotorWD
+import foxes.variables as FV
 
 
-class YawedWakes(WakeFrame):
+class Bastankhah2016Deflection(WakeDeflection):
     """
     Bend the wakes for yawed turbines, based on the
     Bastankhah 2016 wake model
@@ -28,25 +27,26 @@ class YawedWakes(WakeFrame):
     ----------
     model: Bastankhah2016Model
         The model for computing common data
-    model_pars: dict
-        Model parameters
-    YAWM: float
-        The yaw misalignment YAWM. If not given here
-        it will be searched in the farm data.
-    base_frame: foxes.core.WakeFrame
-        The wake frame from which to start
-
-    :group: models.wake_frames
+    alpha: float
+        model parameter used to determine onset of far wake region,
+        if not found in wake model
+    beta: float
+        model parameter used to determine onset of far wake region,
+        if not found in wake model
+    wake_k: dict
+        Parameters for the WakeK class, if not found in wake model
+    induction: foxes.core.AxialInductionModel
+        The induction model, if not found in wake model
+
+    :group: models.wake_deflections
 
     """
 
     def __init__(
         self,
-        base_frame=RotorWD(),
         alpha=0.58,
         beta=0.07,
         induction="Madsen",
-        max_length_km=30,
         **wake_k,
     ):
         """
@@ -54,8 +54,6 @@ class YawedWakes(WakeFrame):
 
         Parameters
         ----------
-        base_frame: foxes.core.WakeFrame
-            The wake frame from which to start
         alpha: float
             model parameter used to determine onset of far wake region,
             if not found in wake model
@@ -66,13 +64,10 @@ class YawedWakes(WakeFrame):
             The induction model, if not found in wake model
         wake_k: dict, optional
             Parameters for the WakeK class, if not found in wake model
-        max_length_km: float
-            The maximal wake length in km
 
         """
-        super().__init__(max_length_km=max_length_km)
+        super().__init__()
 
-        self.base_frame = base_frame
         self.model = None
         self.alpha = alpha
         self.beta = beta
@@ -98,7 +93,7 @@ class YawedWakes(WakeFrame):
             Names of all sub models
 
         """
-        return [self.wake_k, self.base_frame, self.model]
+        return [self.wake_k, self.model]
 
     def initialize(self, algo, verbosity=0, force=False):
         """
@@ -138,30 +133,6 @@ class YawedWakes(WakeFrame):
 
         super().initialize(algo, verbosity, force)
 
-    def calc_order(self, algo, mdata, fdata):
-        """
-        Calculates the order of turbine evaluation.
-
-        This function is executed on a single chunk of data,
-        all computations should be based on numpy arrays.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.MData
-            The model data
-        fdata: foxes.core.FData
-            The farm data
-
-        Returns
-        -------
-        order: numpy.ndarray
-            The turbine order, shape: (n_states, n_turbines)
-
-        """
-        return self.base_frame.calc_order(algo, mdata, fdata)
-
     def _update_y(self, algo, mdata, fdata, tdata, downwind_index, x, y):
         """
         Helper function for y deflection
@@ -227,16 +198,20 @@ class YawedWakes(WakeFrame):
             # apply deflection:
             y[st_sel] -= ydef
 
-    def get_wake_coos(
+    def calc_deflection(
         self,
         algo,
         mdata,
         fdata,
         tdata,
         downwind_index,
+        coos,
     ):
         """
-        Calculate wake coordinates of rotor points.
+        Calculates the wake deflection.
+
+        This function optionally adds FC.WDEFL_ROT_ANGLE or
+        FC.WDEFL_DWS_FACTOR to the tdata.
 
         Parameters
         ----------
@@ -251,79 +226,25 @@ class YawedWakes(WakeFrame):
         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
         -------
-        wake_coos: numpy.ndarray
+        coos: numpy.ndarray
             The wake frame coordinates of the evaluation
             points, shape: (n_states, n_targets, n_tpoints, 3)
 
         """
-        # get unyawed results:
-        xyz = self.base_frame.get_wake_coos(
-            algo,
-            mdata,
-            fdata,
-            tdata,
-            downwind_index,
-        )
 
         # take rotor average:
-        xy = np.einsum("stpd,p->std", xyz[..., :2], tdata[FC.TWEIGHTS])
+        xy = np.einsum("stpd,p->std", coos[..., :2], tdata[FC.TWEIGHTS])
         x = xy[:, :, 0]
         y = xy[:, :, 1]
 
         # apply deflection:
         self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
-        xyz[..., 1] = y[:, :, None]
-
-        return xyz
-
-    def get_centreline_points(self, algo, mdata, fdata, downwind_index, x):
-        """
-        Gets the points along the centreline for given
-        values of x.
-
-        Parameters
-        ----------
-        algo: foxes.core.Algorithm
-            The calculation algorithm
-        mdata: foxes.core.MData
-            The model data
-        fdata: foxes.core.FData
-            The farm data
-        downwind_index: int
-            The index in the downwind order
-        x: numpy.ndarray
-            The wake frame x coordinates, shape: (n_states, n_points)
-
-        Returns
-        -------
-        points: numpy.ndarray
-            The centreline points, shape: (n_states, n_points, 3)
-
-        """
-        points = self.base_frame.get_centreline_points(
-            algo, mdata, fdata, downwind_index, x
-        )
-        tdata = TData.from_points(points)
-
-        nx = np.zeros_like(points)
-        nx[:, 0] = points[:, 1] - points[:, 0]
-        nx[:, -1] = points[:, -1] - points[:, -2]
-        nx[:, 1:-1] = 0.5 * (points[:, 1:-1] - points[:, :-2]) + 0.5 * (
-            points[:, 2:] - points[:, 1:-1]
-        )
-        nx /= np.linalg.norm(nx, axis=-1)[:, :, None]
-
-        nz = np.zeros_like(nx)
-        nz[:, :, 2] = 1
-        ny = np.cross(nz, nx, axis=-1)
-        del nx, nz
-
-        y = np.zeros_like(x)
-        self._update_y(algo, mdata, fdata, tdata, downwind_index, x, y)
-
-        points += y[:, :, None] * ny
+        coos[..., 1] = y[:, :, None]
 
-        return points
+        return coos