Merge branch 'features/multi_turbine_power_curve' into features/wind_farms_and_clusters

Author: SabineHaas

windpowerlib/power_output.py

@@ -9,6 +9,9 @@
 
 import numpy as np
 import pandas as pd
+from windpowerlib import tools
+from matplotlib import pyplot as plt
+import os
 
 
 def power_coefficient_curve(wind_speed, power_coefficient_curve_wind_speeds,
@@ -242,3 +245,305 @@ def power_curve_density_correction(wind_speed, power_curve_wind_speeds,
     else:
         power_output = np.array(power_output)
     return power_output
+
+
+def smooth_power_curve(power_curve_wind_speeds, power_curve_values,
+                       block_width=0.5,
+                       standard_deviation_method='turbulence_intensity',
+                       mean_gauss=0, **kwargs):
+    r"""
+    Smoothes the input power curve values by using a gaussian distribution.
+
+    Parameters
+    ----------
+    power_curve_wind_speeds : pandas.Series
+        Wind speeds in m/s for which the power curve values are provided in
+        `power_curve_values`.
+    power_curve_values : pandas.Series or numpy.array
+        Power curve values corresponding to wind speeds in
+        `power_curve_wind_speeds`.
+    block_width : Float
+        Width of the moving block. Default: 0.5.
+    standard_deviation_method : String
+        Method for calculating the standard deviation for the gaussian
+        distribution. Options: 'turbulence_intensity', 'Norgaard', 'Staffell'.
+        Default: 'turbulence_intensity'.
+
+    Other Parameters
+    ----------------
+    turbulence intensity : Float, optional
+        Turbulence intensity at hub height of the wind turbine the power curve
+        is smoothed for.
+
+    Returns
+    -------
+    smoothed_power_curve_df : pd.DataFrame
+        Smoothed power curve. DataFrame has 'wind_speed' and
+        'power' columns with wind speeds in m/s and the corresponding power
+        curve value in W.
+
+    Notes
+    -----
+    The following equation is used [1]_:
+        # TODO: add equations
+
+    References
+    ----------
+    .. [1]  Knorr, K.: "Modellierung von raum-zeitlichen Eigenschaften der
+             Windenergieeinspeisung für wetterdatenbasierte
+             Windleistungssimulationen". Universität Kassel, Diss., 2016,
+             p. 106
+
+    # TODO: add references
+    """
+    # Specify normalized standard deviation
+    if standard_deviation_method == 'turbulence_intensity':
+        if 'turbulence_intensity' in kwargs:
+            normalized_standard_deviation = kwargs['turbulence_intensity']
+        else:
+            raise ValueError("Turbulence intensity must be defined for " +
+                             "using 'turbulence_intensity' as " +
+                             "`standard_deviation_method`")
+    elif standard_deviation_method == 'Norgaard':
+        pass # TODO add
+    elif standard_deviation_method == 'Staffell':
+        normalized_standard_deviation = 0.2
+    # Initialize list for power curve values
+    smoothed_power_curve_values = []
+    # Step of power curve wind speeds
+    step = power_curve_wind_speeds.iloc[-5] - power_curve_wind_speeds.iloc[-6]
+    # Append wind speeds to `power_curve_wind_speeds` until 40 m/s
+    while (power_curve_wind_speeds.values[-1] < 40.0):
+        power_curve_wind_speeds = power_curve_wind_speeds.append(
+            pd.Series(power_curve_wind_speeds.iloc[-1] + step,
+                      index=[power_curve_wind_speeds.index[-1] + 1]))
+        power_curve_values = power_curve_values.append(
+            pd.Series(0.0, index=[power_curve_values.index[-1] + 1]))
+    for power_curve_wind_speed in power_curve_wind_speeds:
+        # Create array of wind speeds for the moving block
+        wind_speeds_block = (
+            np.arange(-15.0, 15.0 + block_width, block_width) +
+            power_curve_wind_speed)
+        # Get standard deviation for gaussian filter
+        standard_deviation = (
+            (power_curve_wind_speed * normalized_standard_deviation + 0.6)
+            if standard_deviation_method is 'Staffell'
+            else power_curve_wind_speed * normalized_standard_deviation)
+        # Get the smoothed value of the power output
+        smoothed_value = sum(
+            block_width * np.interp(wind_speed, power_curve_wind_speeds,
+                                    power_curve_values, left=0, right=0) *
+            tools.gaussian_distribution(
+                power_curve_wind_speed - wind_speed,
+                standard_deviation, mean_gauss)
+            for wind_speed in wind_speeds_block)
+        # Add value to list - add 0 if `smoothed_value` is nan. This occurs
+        # because the gaussian distribution is not defined for 0.
+        smoothed_power_curve_values.append(0 if np.isnan(smoothed_value)
+                                           else smoothed_value)
+    # Create smoothed power curve DataFrame
+    smoothed_power_curve_df = pd.DataFrame(
+        data=[list(power_curve_wind_speeds.values),
+              smoothed_power_curve_values]).transpose()
+    # Rename columns of DataFrame
+    smoothed_power_curve_df.columns = ['wind_speed', 'power']
+#    # Plot power curves
+#    fig = plt.figure()
+#    plt.plot(power_curve_wind_speeds.values, power_curve_values.values)
+#    plt.plot(power_curve_wind_speeds.values, smoothed_power_curve_values)
+#    fig.savefig(os.path.abspath(os.path.join(
+#        os.path.dirname(__file__), '../Plots/power_curves',
+#        '{0}_{1}_{2}.png'.format(kwargs['object_name'],
+#                                 standard_deviation_method, block_width))))
+#    plt.close()
+    return smoothed_power_curve_df
+
+
+def wake_losses_to_power_curve(power_curve_wind_speeds, power_curve_values,
+                               wake_losses_method='constant_efficiency',
+                               wind_farm_efficiency=None):
+    r"""
+    Applies wake losses depending on the method to a power curve.
+
+    Parameters
+    ----------
+    power_curve_wind_speeds : pandas.Series
+        Wind speeds in m/s for which the power curve values are provided in
+        `power_curve_values`.
+    power_curve_values : pandas.Series or numpy.array
+        Power curve values corresponding to wind speeds in
+        `power_curve_wind_speeds`.
+    wake_losses_method : String
+        Defines the method for talking wake losses within the farm into
+        consideration. Default: 'constant_efficiency'.
+    wind_farm_efficiency : Float or pd.DataFrame or Dictionary
+        Efficiency of the wind farm. Either constant (float) or wind efficiency
+        curve (pd.DataFrame or Dictionary) contianing 'wind_speed' and
+        'efficiency' columns/keys with wind speeds in m/s and the
+        corresponding dimensionless wind farm efficiency. Default: None.
+
+    Returns
+    -------
+    power_curve_df : pd.DataFrame
+        With wind farm efficiency reduced power curve. DataFrame power curve
+        values in W with the corresponding wind speeds in m/s.
+
+    Notes
+    -----
+    TODO add
+
+    """
+    # Create power curve DataFrame
+    power_curve_df = pd.DataFrame(
+        data=[list(power_curve_wind_speeds),
+              list(power_curve_values)]).transpose()
+    # Rename columns of DataFrame
+    power_curve_df.columns = ['wind_speed', 'power']
+    if wake_losses_method == 'constant_efficiency':
+        if not isinstance(wind_farm_efficiency, float):
+            raise TypeError("'wind_farm_efficiency' must be float if " +
+                            "`wake_losses_method´ is '{0}'")
+        power_curve_df['power'] = power_curve_values * wind_farm_efficiency
+    elif wake_losses_method == 'wind_efficiency_curve':
+        if (not isinstance(wind_farm_efficiency, dict) and
+                not isinstance(wind_farm_efficiency, pd.DataFrame)):
+            raise TypeError(
+                "'wind_farm_efficiency' must be a dictionary or " +
+                "pd.DataFrame if `wake_losses_method´ is '{0}'")
+        df = pd.concat([power_curve_df.set_index('wind_speed'),
+                        wind_farm_efficiency.set_index('wind_speed')], axis=1)
+        # Add by efficiency reduced power column (nan values of efficiency
+        # are interpolated)
+        df['reduced_power'] = df['power'] * df['efficiency'].interpolate(
+            method='index')
+        reduced_power = df['reduced_power'].dropna()
+        power_curve_df = pd.DataFrame([reduced_power.index,
+                                       reduced_power.values]).transpose()
+        power_curve_df.columns = ['wind_speed', 'power']
+    else:
+        raise ValueError(
+            "`wake_losses_method` is {0} but should be None, ".format(
+                wake_losses_method) +
+            "'constant_efficiency' or 'wind_efficiency_curve'")
+    return power_curve_df
+
+
+def summarized_power_curve(wind_turbine_fleet, smoothing=True,
+                           density_correction=False, wake_losses_method=None,
+                           **kwargs):
+    r"""
+    Creates a summarized power curve for a wind turbine fleet.
+
+    Power curve is created by summing up all power curves. Depending on the
+    input paramters the power cuvers are smoothed before the summation and/or
+    a wind farm efficiency is applied after the summation.
+
+    Parameters
+    ----------
+    wind_turbine_fleet : List of Dictionaries
+        Dictionaries with the keys 'wind_turbine' (contains
+        :class:`~.wind_turbine.WindTurbine` object) and 'number_of_turbines'
+        (contains number of turbine type in 'wind_turbine' key).
+    smoothing : Boolean
+        If True the power curves will be smoothed before the summation.
+        Default: True.
+    density_correction : Boolean
+        If True a density correction will be applied to the power curves
+        before the summation. Default: False.
+    wake_losses_method : String
+        Defines the method for talking wake losses within the farm into
+        consideration. Default: None.
+
+    Other Parameters
+    ----------------
+    block_width : Float, optional
+        Width of the moving block.
+        Default in :py:func:`~.smooth_power_curve`: 0.5.
+    standard_deviation_method : String, optional
+        Method for calculating the standard deviation for the gaussian
+        distribution. Options: 'turbulence_intensity', 'Norgaard', 'Staffell'.
+        Default in :py:func:`~.smooth_power_curve`:  'turbulence_intensity'.
+    turbulence_intensity : Float, optional
+        Turbulence intensity at hub height of the wind turbine the power curve
+        is smoothed for. If this parameter is not given the turbulence
+        intensity is calculated via the `roughness_length`.
+    roughness_length : Float, optional
+        Roughness length. Only needed if `turbulence_intensity` is not given
+        and `standard_deviation_method` is 'turbulence_intensity' or not given.
+    wind_farm_efficiency : Float or pd.DataFrame or Dictionary, optional
+        Efficiency of the wind farm. Either constant (float) or wind efficiency
+        curve (pd.DataFrame or Dictionary) contianing 'wind_speed' and
+        'efficiency' columns/keys with wind speeds in m/s and the
+        corresponding dimensionless wind farm efficiency.
+
+    Returns
+    -------
+    summarized_power_curve_df : pd.DataFrame
+        Summarized power curve. DataFrame has 'wind_speed' and
+        'power' columns with wind speeds in m/s and the corresponding power
+        curve value in W.
+
+    """
+    # Initialize data frame for power curve values
+    df = pd.DataFrame()
+    for turbine_type_dict in wind_turbine_fleet:
+        # Start power curve
+        power_curve = pd.DataFrame(
+            turbine_type_dict['wind_turbine'].power_curve)
+        if smoothing:
+            if ('standard_deviation_method' not in kwargs or
+                    kwargs['standard_deviation_method'] ==
+                    'turbulence_intensity'):
+                if 'turbulence_intensity' not in kwargs:
+                    if 'roughness_length' in kwargs:
+                        # Calculate turbulence intensity and write to kwargs
+                        turbulence_intensity = (
+                            tools.estimate_turbulence_intensity(
+                                turbine_type_dict['wind_turbine'].hub_height,
+                                kwargs['roughness_length']))
+                        kwargs['turbulence_intensity'] = turbulence_intensity
+                    else:
+                        raise ValueError(
+                            "`roughness_length` must be defined for using" +
+                            "'turbulence_intensity' as " +
+                            "`standard_deviation_method`")
+            # Get smoothed power curve
+            power_curve = smooth_power_curve(power_curve['wind_speed'],
+                                             power_curve['power'], **kwargs)
+        if density_correction:
+            pass  # TODO: add
+        # Add power curves of all turbines of same type to data frame after
+        # renaming columns
+        power_curve.columns = ['wind_speed',
+                               turbine_type_dict['wind_turbine'].object_name]
+        df = pd.concat([df, pd.DataFrame(
+            power_curve.set_index(['wind_speed']) *
+            turbine_type_dict['number_of_turbines'])], axis=1)
+        # Rename back TODO: copy()
+        power_curve.columns = ['wind_speed', 'power']
+    # Sum up power curves of all turbine types
+    summarized_power_curve = pd.DataFrame(
+        sum(df[item].interpolate(method='index') for item in list(df)))
+    summarized_power_curve.columns = ['power']
+    # Take wake losses into consideration if `wake_losses_method` not None
+    if wake_losses_method is None:
+        # Create DataFrame of the above power curve data
+        summarized_power_curve_df = pd.DataFrame(
+            data=[list(summarized_power_curve.index),
+                  list(summarized_power_curve['power'].values)]).transpose()
+        # Rename columns of DataFrame
+        summarized_power_curve_df.columns = ['wind_speed', 'power']
+    elif (wake_losses_method == 'constant_efficiency' or
+          wake_losses_method == 'wind_efficiency_curve'):
+        try:
+            kwargs['wind_farm_efficiency']
+        except KeyError:
+            raise KeyError("'wind_farm_efficiency' must be in kwargs when " +
+                           "`wake_losses_method´ is '{0}'".format(
+                               wake_losses_method))
+        summarized_power_curve_df = wake_losses_to_power_curve(
+            summarized_power_curve.index,
+            summarized_power_curve['power'].values,
+            wake_losses_method=wake_losses_method,
+            wind_farm_efficiency=kwargs['wind_farm_efficiency'])
+    return summarized_power_curve_df

windpowerlib/tools.py

@@ -71,3 +71,53 @@ def linear_interpolation_extrapolation(df, target_height):
     return ((df[heights_sorted[1]] - df[heights_sorted[0]]) /
             (heights_sorted[1] - heights_sorted[0]) *
             (target_height - heights_sorted[0]) + df[heights_sorted[0]])
+
+
+def gaussian_distribution(function_variable, standard_deviation, mean=0):
+    r"""
+    Normal distribution or gaussian distribution.
+
+    Parameters
+    ----------
+    function_variable : Float
+        Variable of the gaussian distribution.
+    standard_deviation : Float
+        Standard deviation of the gaussian distribution.
+    mean : Float
+        Defines the offset of the gaussian distribution function. Default: 0.
+
+    Returns
+    -------
+    pandas.Series or numpy.array
+        Wind speed at hub height. Data type depends on type of `wind_speed`.
+
+    Notes
+    -----
+    The following equation is used [1]_:
+
+    .. math:: f(x) = \frac{1}{\sigma \sqrt{2 \pi}} exp
+                     \left[ -\frac{(x-\mu)^2}{2 \sigma^2}  \right]
+
+    with:
+        # TODO: add variables
+
+    References
+    ----------
+    .. [1] Berendsen, H.: "A Student's Guide to Data and Error Analysis".
+             New York, Cambridge University Press, 2011, p. 37
+    
+    # TODO: add references
+
+    """
+    return (1 / (standard_deviation * np.sqrt(2 * np.pi)) *
+            np.exp(-(function_variable - mean)**2 /
+                   (2 * standard_deviation**2)))
+
+
+def estimate_turbulence_intensity(height, roughness_length):
+    """
+    Calculate turbulence intensity.
+
+    """
+    # TODO: Search other possibilities for TI.
+    return 1 / (np.log(height / roughness_length))