foxes 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

foxes/models/wake_superpositions/ws_max.py

@@ -0,0 +1,173 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+import foxes.constants as FC
+
+class WSMax(WakeSuperposition):
+    """
+    Max supersposition of wind deficit results
+
+    Attributes
+    ----------
+    scale_amb: bool
+        Flag for scaling wind deficit with ambient wind speed
+        instead of waked wind speed
+    lim_low: float
+        Lower limit of the final waked wind speed
+    lim_high: float
+        Upper limit of the final waked wind speed
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, scale_amb=False, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        scale_amb: bool
+            Flag for scaling wind deficit with ambient wind speed
+            instead of waked wind speed
+        lim_low: float
+            Lower limit of the final waked wind speed
+        lim_high: float
+            Upper limit of the final waked wind speed
+
+        """
+        super().__init__()
+
+        self.scale_amb = scale_amb
+        self.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def input_farm_vars(self, algo):
+        """
+        The variables which are needed for running
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+            For each state, one turbine index for the
+            wake causing turbine. Shape: (n_states,)
+        sel_sp: numpy.ndarray of bool
+            The selection of points, shape: (n_states, n_points)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
+            raise ValueError(f"Superposition '{self.name}': Expecting wind speed variable, got {variable}")
+        
+        if np.any(sel_sp):
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_POINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                pdata=pdata,
+                upcast=True,
+                states_source_turbine=states_source_turbine,
+            )[sel_sp]
+
+            wake_model_result = np.abs(scale * wake_model_result)
+            odelta = wake_delta[sel_sp]
+            
+            wake_delta[sel_sp] = np.maximum(odelta, wake_model_result)
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        Returns
+        -------
+        final_wake_delta: numpy.ndarray
+            The final wake delta, which will be added to the ambient
+            results by simple plus operation. Shape: (n_states, n_points)
+
+        """
+        w = -wake_delta
+        if self.lim_low is not None:
+            w = np.maximum(w, self.lim_low - amb_results)
+        if self.lim_high is not None:
+            w = np.minimum(w, self.lim_high - amb_results)
+        return w

foxes/models/wake_superpositions/ws_pow.py

@@ -0,0 +1,175 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+import foxes.constants as FC
+
+class WSPow(WakeSuperposition):
+    """
+    Power supersposition of wind deficit results
+
+    Attributes
+    ----------
+    pow: float
+        The power to which to take the wake results
+    scale_amb: bool
+        Flag for scaling wind deficit with ambient wind speed
+        instead of waked wind speed
+    lim_low: float
+        Lower limit of the final waked wind speed
+    lim_high: float
+        Upper limit of the final waked wind speed
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, pow, scale_amb=False, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        pow: float
+            The power to which to take the wake results
+        scale_amb: bool
+            Flag for scaling wind deficit with ambient wind speed
+            instead of waked wind speed
+        lim_low: float
+            Lower limit of the final waked wind speed
+        lim_high: float
+            Upper limit of the final waked wind speed
+
+        """
+        super().__init__()
+
+        self.pow = pow
+        self.scale_amb = scale_amb
+        self.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def input_farm_vars(self, algo):
+        """
+        The variables which are needed for running
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+            For each state, one turbine index for the
+            wake causing turbine. Shape: (n_states,)
+        sel_sp: numpy.ndarray of bool
+            The selection of points, shape: (n_states, n_points)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
+            raise ValueError(f"Superposition '{self.name}': Expecting wind speed variable, got {variable}")
+        
+        if np.any(sel_sp):
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_POINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                pdata=pdata,
+                upcast=True,
+                states_source_turbine=states_source_turbine,
+            )[sel_sp]
+
+            wake_delta[sel_sp] += np.abs(scale * wake_model_result)**self.pow
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        Returns
+        -------
+        final_wake_delta: numpy.ndarray
+            The final wake delta, which will be added to the ambient
+            results by simple plus operation. Shape: (n_states, n_points)
+
+        """
+        w = -wake_delta**(1/self.pow)
+        if self.lim_low is not None:
+            w = np.maximum(w, self.lim_low - amb_results)
+        if self.lim_high is not None:
+            w = np.minimum(w, self.lim_high - amb_results)
+        return w

foxes/models/wake_superpositions/{product.py → ws_product.py}

@@ -2,11 +2,11 @@ import numpy as np
 
 from foxes.core import WakeSuperposition
 import foxes.variables as FV
+import foxes.constants as FC
 
-
-class ProductSuperposition(WakeSuperposition):
+class WSProduct(WakeSuperposition):
     """
-    Product wind wake superposition.
+    Product supersposition of wind deficit results
 
     This is based on the idea that the dimensionless
     wind deficit should be rescaled with the wake
@@ -18,12 +18,10 @@ class ProductSuperposition(WakeSuperposition):
 
     Attributes
     ----------
-    lim_low: dict
-        Lower limits of the final wake deltas. Key: variable str,
-        value: float
-    lim_high: dict
-        Higher limits of the final wake deltas. Key: variable str,
-        value: float
+    lim_low: float
+        Lower limit of the final waked wind speed
+    lim_high: float
+        Upper limit of the final waked wind speed
 
     :group: models.wake_superpositions
 
@@ -35,18 +33,35 @@ class ProductSuperposition(WakeSuperposition):
 
         Parameters
         ----------
-        lim_low: dict, optional
-            Lower limits of the final wake deltas. Key: variable str,
-            value: float
-        lim_high: dict, optional
-            Higher limits of the final wake deltas. Key: variable str,
-            value: float
+        lim_low: float
+            Lower limit of the final waked wind speed
+        lim_high: float
+            Upper limit of the final waked wind speed
 
         """
         super().__init__()
+
         self.lim_low = lim_low
         self.lim_high = lim_high
 
+    def input_farm_vars(self, algo):
+        """
+        The variables which are needed for running
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
+
     def calc_wakes_plus_wake(
         self,
         algo,
@@ -91,10 +106,16 @@ class ProductSuperposition(WakeSuperposition):
             The updated wake deltas, shape: (n_states, n_points)
 
         """
+        if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
+            raise ValueError(f"Superposition '{self.name}': Expecting wind speed variable, got {variable}")
+        
+        if np.any(sel_sp):
+
+            if np.max(np.abs(wake_delta)) < 1e-14:
+                wake_delta[:] = 1
+
+            wake_delta[sel_sp] *= 1 + wake_model_result
 
-        if np.max(np.abs(wake_delta)) < 1e-14:
-            wake_delta[:] = 1
-        wake_delta[sel_sp] *= 1 + wake_model_result
         return wake_delta
 
     def calc_final_wake_delta(
@@ -136,8 +157,8 @@ class ProductSuperposition(WakeSuperposition):
 
         """
         w = amb_results * (wake_delta - 1)
-        if self.lim_low is not None and variable in self.lim_low:
-            w = np.maximum(w, self.lim_low[variable] - amb_results)
-        if self.lim_high is not None and variable in self.lim_high:
-            w = np.minimum(w, self.lim_high[variable] - amb_results)
+        if self.lim_low is not None:
+            w = np.maximum(w, self.lim_low - amb_results)
+        if self.lim_high is not None:
+            w = np.minimum(w, self.lim_high - amb_results)
         return w

foxes/models/wake_superpositions/ws_quadratic.py

@@ -0,0 +1,170 @@
+import numpy as np
+
+from foxes.core import WakeSuperposition
+import foxes.variables as FV
+import foxes.constants as FC
+
+class WSQuadratic(WakeSuperposition):
+    """
+    Quadratic supersposition of wind deficit results
+
+    Attributes
+    ----------
+    scale_amb: bool
+        Flag for scaling wind deficit with ambient wind speed
+        instead of waked wind speed
+    lim_low: float
+        Lower limit of the final waked wind speed
+    lim_high: float
+        Upper limit of the final waked wind speed
+
+    :group: models.wake_superpositions
+
+    """
+
+    def __init__(self, scale_amb=False, lim_low=None, lim_high=None):
+        """
+        Constructor.
+
+        Parameters
+        ----------
+        scale_amb: bool
+            Flag for scaling wind deficit with ambient wind speed
+            instead of waked wind speed
+        lim_low: float
+            Lower limit of the final waked wind speed
+        lim_high: float
+            Upper limit of the final waked wind speed
+
+        """
+        super().__init__()
+
+        self.scale_amb = scale_amb
+        self.lim_low = lim_low
+        self.lim_high = lim_high
+
+    def input_farm_vars(self, algo):
+        """
+        The variables which are needed for running
+        the model.
+
+        Parameters
+        ----------
+        algo: foxes.core.Algorithm
+            The calculation algorithm
+
+        Returns
+        -------
+        input_vars: list of str
+            The input variable names
+
+        """
+        return [FV.AMB_REWS] if self.scale_amb else [FV.REWS]
+
+    def calc_wakes_plus_wake(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        states_source_turbine,
+        sel_sp,
+        variable,
+        wake_delta,
+        wake_model_result,
+    ):
+        """
+        Add a wake delta to previous wake deltas.
+
+        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
+            For each state, one turbine index for the
+            wake causing turbine. Shape: (n_states,)
+        sel_sp: numpy.ndarray of bool
+            The selection of points, shape: (n_states, n_points)
+        variable: str
+            The variable name for which the wake deltas applies
+        wake_delta: numpy.ndarray
+            The original wake deltas, shape: (n_states, n_points)
+        wake_model_result: numpy.ndarray
+            The new wake deltas of the selected points,
+            shape: (n_sel_sp,)
+
+        Returns
+        -------
+        wdelta: numpy.ndarray
+            The updated wake deltas, shape: (n_states, n_points)
+
+        """
+        if variable not in [FV.REWS, FV.REWS2, FV.REWS3, FV.WS]:
+            raise ValueError(f"Superposition '{self.name}': Expecting wind speed variable, got {variable}")
+        
+        if np.any(sel_sp):
+            scale = self.get_data(
+                FV.AMB_REWS if self.scale_amb else FV.REWS,
+                FC.STATE_POINT,
+                lookup="w",
+                algo=algo,
+                fdata=fdata,
+                pdata=pdata,
+                upcast=True,
+                states_source_turbine=states_source_turbine,
+            )[sel_sp]
+
+            wake_delta[sel_sp] += (scale * wake_model_result)**2
+
+        return wake_delta
+
+    def calc_final_wake_delta(
+        self,
+        algo,
+        mdata,
+        fdata,
+        pdata,
+        variable,
+        amb_results,
+        wake_delta,
+    ):
+        """
+        Calculate the final wake delta after adding all
+        contributions.
+
+        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
+        variable: str
+            The variable name for which the wake deltas applies
+        amb_results: numpy.ndarray
+            The ambient results, shape: (n_states, n_points)
+        wake_delta: numpy.ndarray
+            The wake deltas, shape: (n_states, n_points)
+
+        Returns
+        -------
+        final_wake_delta: numpy.ndarray
+            The final wake delta, which will be added to the ambient
+            results by simple plus operation. Shape: (n_states, n_points)
+
+        """
+        w = -np.sqrt(wake_delta)
+        if self.lim_low is not None:
+            w = np.maximum(w, self.lim_low - amb_results)
+        if self.lim_high is not None:
+            w = np.minimum(w, self.lim_high - amb_results)
+        return w

foxes/output/__init__.py

@@ -1,6 +1,7 @@
 """
 Output tools and functions.
 """
+from .round import round_defaults
 from .output import Output
 from .farm_layout import FarmLayoutOutput
 from .farm_results_eval import FarmResultsEval
@@ -9,5 +10,8 @@ from .results_writer import ResultsWriter
 from .state_turbine_map import StateTurbineMap
 from .turbine_type_curves import TurbineTypeCurves
 from .animation import Animator
+from .calc_points import PointCalculator
+from .slice_data import SliceData
 
 from .flow_plots_2d import FlowPlots2D, SeqFlowAnimationPlugin
+from . import grids