degradation.py

"""Collection of functions for degradation calculations."""

import numpy as np
import pandas as pd
from numba import jit, njit
from rex import NSRDBX
from rex import Outputs
from pathlib import Path
from concurrent.futures import ProcessPoolExecutor, as_completed
from typing import Union

from . import temperature
from . import spectral
from . import weather

from typing import Optional
from pvdeg.decorators import geospatial_quick_shape, deprecated

# TODO: Clean up all those functions and add gaps functionality


def _deg_rate_env(poa_global, temp, temp_chamber, p, Tf):
    """
    Helper function. Find the rate of degradation kenetics using the Fischer model.
    Degradation kentics model interpolated 50 coatings with respect to
    color shift, cracking, gloss loss, fluorescense loss,
    retroreflectance loss, adhesive transfer, and shrinkage.

    (ADD IEEE reference)

    Parameters
    ------------
    poa_global : float
        (Global) Plan of Array irradiance [W/m²]
    temp : float
        Solar module temperature [°C]
    temp_chamber : float
        Reference temperature [°C] "Chamber Temperature"
    p : float
        Fit parameter
    Tf : float
        Multiplier for the increase in degradation
                                        for every 10[°C] temperature increase

    Returns
    -------/
    degradationrate : float
        rate of Degradation (NEED TO ADD METRIC)

    """

    # poa_global ** (p) * Tf ** ((temp - temp_chamber) / 10)
    return np.multiply(
        np.power(poa_global, p),
        np.power(Tf, np.divide(np.subtract(temp, temp_chamber), 10)),
    )


def _deg_rate_chamber(I_chamber, p):
    """
    Helper function. Find the rate of degradation kenetics of a simulated chamber. Mike Kempe's
    calculation of the rate of degradation inside a accelerated degradation chamber.

    (ADD IEEE reference)

    Parameters
    ----------
    I_chamber : float
        Irradiance of Controlled Condition W/m²
    p : float
        Fit parameter

    Returns
    --------
    chamberdegradationrate : float
        Degradation rate of chamber
    """
    # chamberdegradationrate = I_chamber ** (p)
    chamberdegradationrate = np.power(I_chamber, p)

    return chamberdegradationrate


def _acceleration_factor(numerator, denominator):
    """
    Helper Function. Find the acceleration factor

    (ADD IEEE reference)

    Parameters
    ----------
    numerator : float
        Typically the numerator is the chamber settings
    denominator : float
        Typically the TMY data summation

    Returns
    -------
    chamberAccelerationFactor : float
        Acceleration Factor of chamber (NEED TO ADD METRIC)
    """

    chamberAccelerationFactor = np.divide(numerator, denominator)
    # chamberAccelerationFactor = numerator / denominator

    return chamberAccelerationFactor


def vantHoff_deg(
    weather_df,
    meta,
    I_chamber,
    temp_chamber,
    poa=None,
    temp=None,
    p=0.5,
    Tf=1.41,
    temp_model="sapm",
    conf="open_rack_glass_polymer",
    wind_factor=0.33,
    irradiance_kwarg={},
    model_kwarg={},
):
    """
    Van't Hoff Irradiance Degradation

    Parameters
    -----------
    weather_df : pd.dataframe
        Dataframe containing at least dni, dhi, ghi, temperature, wind_speed
    meta : dict
        Location meta-data containing at least latitude, longitude, altitude
    I_chamber : float
        Irradiance of Controlled Condition [W/m²]
    temp_chamber : float
        Reference temperature [°C] "Chamber Temperature"
    poa : series or data frame, optional
        dataframe containing 'poa_global', Global Plane of Array Irradiance [W/m²]
    temp : pandas series, optional
        Solar module temperature or Cell temperature [°C]. If no cell temperature is given, it will
        be generated using the default paramters of pvdeg.temperature.cell
    p : float
        fit parameter
    Tf : float
        Multiplier for the increase in degradation for every 10[°C] temperature increase
    temp_model : (str, optional)
        Specify which temperature model from pvlib to use. Current options:
    conf : (str)
        The configuration of the PV module architecture and mounting
        configuration. Currently only used for 'sapm' and 'pvsys'.
        With different options for each.

        'sapm' options: ``open_rack_glass_polymer`` (default),
        ``open_rack_glass_glass``, ``close_mount_glass_glass``,
        ``insulated_back_glass_polymer``

        'pvsys' options: ``freestanding``, ``insulated``

    wind_factor : float, optional
        Wind speed correction exponent to account for different wind speed measurement heights
        between weather database (e.g. NSRDB) and the tempeature model (e.g. SAPM)
        The NSRDB provides calculations at 2 m (i.e module height) but SAPM uses a 10 m height.
        It is recommended that a power-law relationship between height and wind speed of 0.33
        be used*. This results in a wind speed that is 1.7 times higher. It is acknowledged that
        this can vary significantly.
    irradiance_kwarg : (dict, optional)
        keyword argument dictionary used for the poa irradiance caluation.
        options: ``sol_position``, ``tilt``, ``azimuth``, ``sky_model``. See ``pvdeg.spectral.poa_irradiance``.
    model_kwarg : (dict, optional)
        keyword argument dictionary used for the pvlib temperature model calculation.
        See https://pvlib-python.readthedocs.io/en/stable/reference/pv_modeling/temperature.html for more.


    Returns
    -------
    accelerationFactor : float or series
        Degradation acceleration factor

    """

    if poa is None:
        poa = spectral.poa_irradiance(weather_df, meta, **irradiance_kwarg)

    if isinstance(poa, pd.DataFrame):
        poa_global = poa["poa_global"]

    if temp is None:
        # temp = temperature.cell(weather_df=weather_df, meta=meta, poa=poa)
        temp = temperature.temperature(
            cell_or_mod="cell",
            temp_model=temp_model,
            weather_df=weather_df,
            meta=meta,
            poa=poa,
            conf=conf,
            wind_factor=wind_factor,
            model_kwarg=model_kwarg,
        )

    rateOfDegEnv = _deg_rate_env(
        poa_global=poa_global, temp=temp, temp_chamber=temp_chamber, p=p, Tf=Tf
    )
    # sumOfDegEnv = rateOfDegEnv.sum(axis = 0, skipna = True)
    avgOfDegEnv = rateOfDegEnv.mean()

    rateOfDegChamber = _deg_rate_chamber(I_chamber, p)

    accelerationFactor = _acceleration_factor(rateOfDegChamber, avgOfDegEnv)

    return accelerationFactor


def _to_eq_vantHoff(temp, Tf=1.41):
    """
    Function to obtain the Vant Hoff temperature equivalent [°C]

    Parameters
    ----------
    Tf : float
        Multiplier for the increase in degradation for every 10[°C] temperature increase. Default value of 1.41.
    temp : pandas series
        Solar module surface or Cell temperature [°C]

    Returns
    -------
    Toeq : float
        Vant Hoff temperature equivalent [°C]

    """

    # toSum = Tf ** (temp / 10)
    toSum = np.power(Tf, np.divide(temp, 10))
    summation = toSum.sum(axis=0, skipna=True)

    Toeq = (10 / np.log(Tf)) * np.log(summation / len(temp))

    return Toeq


@geospatial_quick_shape(0, ["Iwa"])
def IwaVantHoff(
    weather_df,
    meta,
    poa=None,
    temp=None,
    Teq=None,
    p=0.5,
    Tf=1.41,
    temp_model="sapm",
    conf="open_rack_glass_polymer",
    wind_factor=0.33,
    model_kwarg={},
    irradiance_kwarg={},
):
    """
    IWa : Environment Characterization [W/m²]
    For one year of degredation the controlled environmnet lamp settings will
    need to be set to IWa.

    Parameters
    -----------
    weather_df : pd.dataframe
        Dataframe containing at least dni, dhi, ghi, temperature, wind_speed
    meta : dict
        Location meta-data containing at least latitude, longitude, altitude
    poa : float series or dataframe
        Series or dataframe containing 'poa_global', Global Plane of Array Irradiance W/m²
    temp : float series
        Solar module temperature or Cell temperature [°C]
    Teq : series
        VantHoff equivalent temperature [°C]
    p : float
        Fit parameter
    Tf : float
        Multiplier for the increase in degradation for every 10[°C] temperature increase
    temp_model : (str, optional)
        Specify which temperature model from pvlib to use. Current options:
    conf : (str)
        The configuration of the PV module architecture and mounting
        configuration. Currently only used for 'sapm' and 'pvsys'.
        With different options for each.

        'sapm' options: ``open_rack_glass_polymer`` (default),
        ``open_rack_glass_glass``, ``close_mount_glass_glass``,
        ``insulated_back_glass_polymer``

        'pvsys' options: ``freestanding``, ``insulated``

    wind_factor : float, optional
        Wind speed correction exponent to account for different wind speed measurement heights
        between weather database (e.g. NSRDB) and the tempeature model (e.g. SAPM)
        The NSRDB provides calculations at 2 m (i.e module height) but SAPM uses a 10 m height.
        It is recommended that a power-law relationship between height and wind speed of 0.33
        be used*. This results in a wind speed that is 1.7 times higher. It is acknowledged that
        this can vary significantly.
    irradiance_kwarg : (dict, optional)
        keyword argument dictionary used for the poa irradiance caluation.
        options: ``sol_position``, ``tilt``, ``azimuth``, ``sky_model``. See ``pvdeg.spectral.poa_irradiance``.
    model_kwarg : (dict, optional)
        keyword argument dictionary used for the pvlib temperature model calculation.
        See https://pvlib-python.readthedocs.io/en/stable/reference/pv_modeling/temperature.html for more.


    Returns
    --------
    Iwa : float
        Environment Characterization [W/m²[]

    """
    if poa is None:
        poa = spectral.poa_irradiance(weather_df, meta, **irradiance_kwarg)

    if temp is None:
        # temp = temperature.cell(weather_df, meta, poa)
        temp = temperature.temperature(
            cell_or_mod="cell",
            temp_model=temp_model,
            weather_df=weather_df,
            meta=meta,
            poa=poa,
            conf=conf,
            wind_factor=wind_factor,
            model_kwarg=model_kwarg,
        )

    if Teq is None:
        Teq = _to_eq_vantHoff(temp, Tf)

    if isinstance(poa, pd.DataFrame):
        poa_global = poa["poa_global"]
    else:
        poa_global = poa

    # toSum = (poa_global**p) * (Tf ** ((temp - Teq) / 10))
    toSum = np.multiply(
        np.power(poa_global, p), np.power(Tf, np.divide(np.subtract(temp, Teq), 10))
    )

    summation = toSum.sum(axis=0, skipna=True)

    # Iwa = (summation / len(poa_global)) ** (1 / p)
    Iwa = np.power(np.divide(summation, len(poa_global)), np.divide(1, p))

    return Iwa


def _arrhenius_denominator(poa_global, rh_outdoor, temp, Ea, p, n):
    """
    Helper function. Calculates the rate of degredation of the Environmnet

    Parameters
    ----------
    poa_global : float series
        (Global) Plan of Array irradiance [W/m²]
    p : float
        Fit parameter
    rh_outdoor : pandas series
        Relative Humidity of material of interest. Acceptable relative
        humiditys can be calculated from these functions: rh_backsheet(),
        rh_back_encap(); rh_front_encap();  rh_surface_outside()
    n : float
        Fit parameter for relative humidity
    temp : pandas series
        Solar module temperature or Cell temperature [°C]
    Ea : float
        Degredation Activation Energy [kJ/mol]

    Returns
    -------
    environmentDegradationRate : pandas series
        Degradation rate of environment
    """

    # environmentDegradationRate = (
    #     poa_global ** (p)
    #     * rh_outdoor ** (n)
    #     * np.exp(-(Ea / (0.00831446261815324 * (temp + 273.15))))
    # )

    environmentDegradationRate = np.multiply(
        np.multiply(np.power(poa_global, p), np.power(rh_outdoor, n)),
        np.exp(
            np.negative(
                np.divide(Ea, np.multiply(0.00831446261815324, np.add(temp, 273.15)))
            )
        ),
    )

    return environmentDegradationRate


def _arrhenius_numerator(I_chamber, rh_chamber, temp_chamber, Ea, p, n):
    """
    Helper function. Find the rate of degradation of a simulated chamber.

    Parameters
    ----------
    I_chamber : float
        Irradiance of Controlled Condition [W/m²]
    Rhchamber : float
        Relative Humidity of Controlled Condition [%]
        EXAMPLE: "50 = 50% NOT .5 = 50%"
    temp_chamber : float
        Reference temperature [°C] "Chamber Temperature"
    Ea : float
        Degredation Activation Energy [kJ/mol]
    p : float
        Fit parameter
    n : float
        Fit parameter for relative humidity

    Returns
    --------
    arrheniusNumerator : float
        Degradation rate of the chamber
    """

    # arrheniusNumerator = (
    #     I_chamber ** (p)
    #     * rh_chamber ** (n)
    #     * np.exp(-(Ea / (0.00831446261815324 * (temp_chamber + 273.15))))
    # )

    arrheniusNumerator = np.multiply(
        np.multiply(np.power(I_chamber, p), np.power(rh_chamber, n)),
        np.exp(
            np.negative(
                np.divide(
                    Ea, np.multiply(0.00831446261815324, np.add(temp_chamber, 273.15))
                )
            )
        ),
    )

    return arrheniusNumerator


def arrhenius_deg(
    weather_df: pd.DataFrame,
    meta: dict,
    rh_outdoor,
    I_chamber,
    rh_chamber,
    Ea,
    temp_chamber,
    poa=None,
    temp=None,
    p=0.5,
    n=1,
    temp_model="sapm",
    conf="open_rack_glass_polymer",
    wind_factor=0.33,
    model_kwarg={},
    irradiance_kwarg={},
):
    """
    Calculate the Acceleration Factor between the rate of degredation of a
    modeled environmnet versus a modeled controlled environmnet. Example: "If the AF=25 then 1 year
    of Controlled Environment exposure is equal to 25 years in the field"

    Parameters
    ----------
    weather_df : pd.dataframe
        Dataframe containing at least dni, dhi, ghi, temperature, wind_speed
    meta : dict
        Location meta-data containing at least latitude, longitude, altitude
    rh_outdoor : float series
        Relative Humidity of material of interest
        Acceptable relative humiditys can be calculated
        from these functions: rh_backsheet(), rh_back_encap(), rh_front_encap(),
        rh_surface_outside()
    I_chamber : float
        Irradiance of Controlled Condition [W/m²]
    rh_chamber : float
        Relative Humidity of Controlled Condition [%].
        EXAMPLE: "50 = 50% NOT .5 = 50%"
    temp_chamber : float
        Reference temperature [°C] "Chamber Temperature"
    Ea : float
        Degredation Activation Energy [kJ/mol]
        if Ea=0 is used there will be not dependence on temperature and degradation will proceed according to the amount of light and humidity.
    poa : pd.dataframe, optional
        Global Plane of Array Irradiance [W/m²]
    temp : pd.series, optional
        Solar module temperature or Cell temperature [°C]. If no cell temperature is given, it will
        be generated using the default parameters from pvdeg.temperature.cell
    p : float
        Fit parameter
        When p=0 the dependence on light will be ignored and degradation will happen both day an night. As a caution or a feature, a very small value of p (e.g. p=0.0001) will provide very little degradation dependence on irradiance, but degradation will only be accounted for during daylight. i.e. averages will be computed over half of the time only.
    n : float
        Fit parameter for relative humidity
        When n=0 the degradation rate will not be dependent on humidity.
    temp_model : (str, optional)
        Specify which temperature model from pvlib to use. Current options:
    conf : (str)
        The configuration of the PV module architecture and mounting
        configuration. Currently only used for 'sapm' and 'pvsys'.
        With different options for each.

        'sapm' options: ``open_rack_glass_polymer`` (default),
        ``open_rack_glass_glass``, ``close_mount_glass_glass``,
        ``insulated_back_glass_polymer``

        'pvsys' options: ``freestanding``, ``insulated``

    wind_factor : float, optional
        Wind speed correction exponent to account for different wind speed measurement heights
        between weather database (e.g. NSRDB) and the tempeature model (e.g. SAPM)
        The NSRDB provides calculations at 2 m (i.e module height) but SAPM uses a 10 m height.
        It is recommended that a power-law relationship between height and wind speed of 0.33
        be used*. This results in a wind speed that is 1.7 times higher. It is acknowledged that
        this can vary significantly.
    irradiance_kwarg : (dict, optional)
        keyword argument dictionary used for the poa irradiance caluation.
        options: ``sol_position``, ``tilt``, ``azimuth``, ``sky_model``. See ``pvdeg.spectral.poa_irradiance``.
    model_kwarg : (dict, optional)
        keyword argument dictionary used for the pvlib temperature model calculation.
        See https://pvlib-python.readthedocs.io/en/stable/reference/pv_modeling/temperature.html for more.

    Returns
    --------
    accelerationFactor : pandas series
        Degradation acceleration factor

    """

    if poa is None:
        poa = spectral.poa_irradiance(weather_df, meta, **irradiance_kwarg)

    if temp is None:
        # temp = temperature.cell(weather_df, meta, poa)
        temp = temperature.temperature(
            cell_or_mod="cell",
            temp_model=temp_model,
            weather_df=weather_df,
            meta=meta,
            poa=poa,
            conf=conf,
            wind_factor=wind_factor,
            model_kwarg=model_kwarg,
        )

    if isinstance(poa, pd.DataFrame):
        poa_global = poa["poa_global"]
    else:
        poa_global = poa

    arrheniusDenominator = _arrhenius_denominator(
        poa_global=poa_global, rh_outdoor=rh_outdoor, temp=temp, Ea=Ea, p=p, n=n
    )

    AvgOfDenominator = arrheniusDenominator.mean()

    arrheniusNumerator = _arrhenius_numerator(
        I_chamber=I_chamber,
        rh_chamber=rh_chamber,
        temp_chamber=temp_chamber,
        Ea=Ea,
        p=p,
        n=n,
    )

    accelerationFactor = _acceleration_factor(arrheniusNumerator, AvgOfDenominator)

    return accelerationFactor


def _T_eq_arrhenius(temp, Ea):
    """
    Get the Temperature equivalent required for the settings of the controlled environment
    Calculation is used in determining Arrhenius Environmental Characterization

    Parameters
    -----------
    temp : pandas series
        Solar module temperature or Cell temperature [°C]
    Ea : float
        Degredation Activation Energy [kJ/mol]

    Returns
    -------
    Teq : float
        Temperature equivalent (Celsius) required
        for the settings of the controlled environment

    """

    summationFrame = np.exp(-(Ea / (0.00831446261815324 * (temp + 273.15))))
    sumForTeq = summationFrame.sum(axis=0, skipna=True)
    Teq = -((Ea) / (0.00831446261815324 * np.log(sumForTeq / len(temp))))
    # Convert to celsius
    Teq = Teq - 273.15

    return Teq


def _RH_wa_arrhenius(rh_outdoor, temp, Ea, Teq=None, n=1):
    """
    NOTE

    Get the Relative Humidity Weighted Average.
    Calculation is used in determining Arrhenius Environmental Characterization

    Parameters
    -----------
    rh_outdoor : pandas series
        Relative Humidity of material of interest. Acceptable relative
        humiditys can be calculated from the below functions:
        rh_backsheet(), rh_back_encap(), rh_front_encap(), rh_surface_outside()
    temp : pandas series
        solar module temperature or Cell temperature [°C]
    Ea : float
        Degredation Activation Energy [kJ/mol]
    Teq : series
        Equivalent Arrhenius temperature [°C]
    n : float
        Fit parameter for relative humidity

    Returns
    --------
    RHwa : float
        Relative Humidity Weighted Average [%]

    """

    if Teq is None:
        Teq = _T_eq_arrhenius(temp, Ea)

    summationFrame = (rh_outdoor**n) * np.exp(
        -(Ea / (0.00831446261815324 * (temp + 273.15)))
    )
    sumForRHwa = summationFrame.sum(axis=0, skipna=True)
    RHwa = (
        sumForRHwa
        / (len(summationFrame) * np.exp(-(Ea / (0.00831446261815324 * (Teq + 273.15)))))
    ) ** (1 / n)

    return RHwa


# TODO:   CHECK
# STANDARDIZE
def IwaArrhenius(
    weather_df: pd.DataFrame,
    meta: dict,
    rh_outdoor: pd.Series,
    Ea: float,
    poa: pd.DataFrame = None,
    temp: pd.Series = None,
    RHwa: float = None,
    Teq: float = None,
    p: float = 0.5,
    n: float = 1,
    temp_model="sapm",
    conf="open_rack_glass_polymer",
    wind_factor=0.33,
    model_kwarg={},
    irradiance_kwarg={},
) -> float:
    """
    Function to calculate IWa, the Environment Characterization [W/m²].
    For one year of degredation the controlled environmnet lamp settings will
    need to be set at IWa.

    Parameters
    ----------
    weather_df : pd.dataframe
        Dataframe containing at least dni, dhi, ghi, temperature, wind_speed
    meta : dict
        Location meta-data containing at least latitude, longitude, altitude
    rh_outdoor : pd.series
        Relative Humidity of material of interest
        Acceptable relative humiditys include: rh_backsheet(), rh_back_encap(), rh_front_encap(),
        rh_surface_outside()
    Ea : float
        Degradation Activation Energy [kJ/mol]
    poa : pd.dataframe, optional
        must contain 'poa_global', Global Plan of Array irradiance [W/m²]
    temp : pd.series, optional
        Solar module temperature or Cell temperature [°C]
    RHwa : float, optional
        Relative Humidity Weighted Average [%]
    Teq : float, optional
        Temperature equivalent (Celsius) required
        for the settings of the controlled environment
    p : float
        Fit parameter
    n : float
        Fit parameter for relative humidity
    temp_model : (str, optional)
        Specify which temperature model from pvlib to use. Current options:
    conf : (str)
        The configuration of the PV module architecture and mounting
        configuration. Currently only used for 'sapm' and 'pvsys'.
        With different options for each.

        'sapm' options: ``open_rack_glass_polymer`` (default),
        ``open_rack_glass_glass``, ``close_mount_glass_glass``,
        ``insulated_back_glass_polymer``

        'pvsys' options: ``freestanding``, ``insulated``

    wind_factor : float, optional
        Wind speed correction exponent to account for different wind speed measurement heights
        between weather database (e.g. NSRDB) and the tempeature model (e.g. SAPM)
        The NSRDB provides calculations at 2 m (i.e module height) but SAPM uses a 10 m height.
        It is recommended that a power-law relationship between height and wind speed of 0.33
        be used*. This results in a wind speed that is 1.7 times higher. It is acknowledged that
        this can vary significantly.
    irradiance_kwarg : (dict, optional)
        keyword argument dictionary used for the poa irradiance caluation.
        options: ``sol_position``, ``tilt``, ``azimuth``, ``sky_model``. See ``pvdeg.spectral.poa_irradiance``.
    model_kwarg : (dict, optional)
        keyword argument dictionary used for the pvlib temperature model calculation.
        See https://pvlib-python.readthedocs.io/en/stable/reference/pv_modeling/temperature.html for more.



    Returns
    --------
    Iwa : float
        Environment Characterization [W/m²]
    """
    if poa is None:
        poa = spectral.poa_irradiance(weather_df, meta, **irradiance_kwarg)

    if temp is None:
        # temp = temperature.cell(weather_df, meta, poa)
        temp = temperature.temperature(
            cell_or_mod="cell",
            temp_model=temp_model,
            weather_df=weather_df,
            meta=meta,
            poa=poa,
            conf=conf,
            wind_factor=wind_factor,
            model_kwarg=model_kwarg,
        )

    if Teq is None:
        Teq = _T_eq_arrhenius(temp, Ea)

    if RHwa is None:
        RHwa = _RH_wa_arrhenius(rh_outdoor, temp, Ea)

    if isinstance(poa, pd.DataFrame):
        poa_global = poa["poa_global"]
    else:
        poa_global = poa

    numerator = (
        poa_global ** (p)
        * rh_outdoor ** (n)
        * np.exp(-(Ea / (0.00831446261815324 * (temp + 273.15))))
    )
    sumOfNumerator = numerator.sum(axis=0, skipna=True)

    denominator = (
        (len(numerator))
        * ((RHwa) ** n)
        * (np.exp(-(Ea / (0.00831446261815324 * (Teq + 273.15)))))
    )

    IWa = (sumOfNumerator / denominator) ** (1 / p)

    return IWa


############
# Misc. Functions for Energy Calcs
############


def _rh_Above85(rh):
    """
    Helper function. Determines if the relative humidity is above 85%.

    Parameters
    ----------
    rh : float
        Relative Humidity %

    Returns
    --------
    rhabove85 : boolean
        True if the relative humidity is above 85% or False if the relative
        humidity is below 85%

    """

    if rh > 85:
        rhabove85 = True

    else:
        rhabove85 = False

    return rhabove85


def _hoursRH_Above85(df):
    """
    Helper Function. Count the number of hours relative humidity is above 85%.

    Parameters
    ----------
    df : dataframe
        DataFrame, dataframe containing Relative Humidity %

    Returns
    -------
    numhoursabove85 : int
        Number of hours relative humidity is above 85%

    """
    booleanDf = df.apply(lambda x: _rh_Above85(x))
    numhoursabove85 = booleanDf.sum()

    return numhoursabove85


def _whToGJ(wh):
    """
    NOTE: unused, remove?

    Helper Function to convert Wh/m² to GJ/m²

    Parameters
    -----------
    wh : float
        Input Value in Wh/m²

    Returns
    -------
    gj : float
        Value in GJ/m²

    """

    gj = 0.0000036 * wh

    return gj


def _gJtoMJ(gJ):
    """
    NOTE: unused, remove?

    Helper Function to convert GJ/m² to MJ/y

    Parameters
    -----------
    gJ : float
        Value in GJ/m^-2

    Returns
    -------
    MJ : float
        Value in MJ/m^-2

    """
    MJ = gJ * 1000

    return MJ


# new version of degradation
def degradation(
    spectra_df: pd.DataFrame,
    conditions_df: pd.DataFrame = None,
    temp_module: pd.Series = None,
    rh_module: pd.Series = None,
    Ea: float = 40.0,
    n: float = 1.0,
    p: float = 0.5,
    C2: float = 0.07,
    C: float = 1.0,
)-> float:
    """
    Compute degredation as double integral of Arrhenius (Activation
    Energy, RH, Temperature) and spectral (wavelength, irradiance)
    functions over wavelength and time.

    .. math::

        D = C \\int_{0}^{t} RH(t)^n \\cdot e^{\\frac{-E_a}{RT(t)}} \\int_{\\lambda} [e^{-C_2 \\lambda} \\cdot G(\\lambda, t)]^p d\\lambda dt

    Parameters
    ----------
    spectra_df : pd.DataFrame
        front or rear irradiance data in dataframe format

        - `data`: Spectral irradiance values for each wavelength [W/m^2 nm].
        - `index`: pd.DateTimeIndex
        - `columns`: Wavelengths as floats (e.g., 280, 300, etc.) [nm].

        Example::

            timestamp                 280     300     320     340     360     380     400
            2021-03-09 10:00:00    0.6892  0.4022  0.6726  0.0268  0.3398  0.9432  0.7411
            2021-03-09 11:00:00    0.1558  0.5464  0.6896  0.7828  0.5050  0.9336  0.4652
            2021-03-09 12:00:00    0.2278  0.9057  0.2639  0.0572  0.9906  0.9370  0.1800
            2021-03-09 13:00:00    0.3742  0.0358  0.4052  0.9578  0.1044  0.8917  0.4876

    conditions_df : pd.DataFrame, optional
        Environmental conditions including temperature and relative humidity.

        - `index`: pd.DateTimeIndex
        - `columns`:  (required)
            - "temperature" [°C or K]
            - "relative_humidity" [%]

        Example::

            timestamp                 temperature  relative_humidity
            2021-03-09 10:00:00         298.0               45.0
            2021-03-09 11:00:00         303.0               50.0
            2021-03-09 12:00:00         310.0               55.0
            2021-03-09 13:00:00         315.0               60.0

    temp_module : pd.Series, optional
        Module temperatures [°C]. Required if `conditions_df` is not provided. Time indexed same as spectra_df

    rh_module : pd.Series, optional
        Relative humidity values [%]. Required if `conditions_df` is not provided. Time indexed same as spectra_df

        Example::

            30 = 30%

    Ea : float
        Arrhenius activation energy. The default is 40. [kJ/mol]
    n : float
        Fit paramter for RH sensitivity. The default is 1.
    p : float
        Fit parameter for irradiance sensitivity. Typically
        0.6 +- 0.22
    C2 : float
        Fit parameter for sensitivity to wavelength exponential.
        Typically 0.07
    C : float
        Fit parameter for the Degradation equaiton
        Typically 1.0

    Returns
    -------
    degradation : float
        Total degredation factor over time and wavelength.
    """


    if conditions_df is not None and (temp_module is not None or rh_module is not None):
        raise ValueError("Provide either conditions_df or temp_module and rh_module")

    if conditions_df is not None:
        rh = conditions_df["relative_humidity"].values
        temps = conditions_df["temperature"].values
    else:
        rh = rh_module.values
        temps = temp_module.values

    wavelengths = spectra_df.columns.values.astype(float)
    irr = spectra_df.values  # irradiance as array

    # call numba compiled function
    return deg(
        wavelengths=wavelengths, 
        irr=irr,
        rh=rh, 
        temps=temps, 
        Ea=Ea, 
        C2=C2, 
        p=p, 
        n=n, 
        C=C
    )

@njit 
def deg(
    wavelengths: np.ndarray, 
    irr: np.ndarray, 
    rh: np.ndarray, 
    temps: np.ndarray, 
    Ea: float, 
    C2: float, 
    p: float, 
    n: float, 
    C: float
) -> float:

    R = 0.0083145  # Gas Constant in [kJ/mol*K]

    wav_bin = np.diff(wavelengths)
    wav_bin = np.append(wav_bin, wav_bin[-1])  # Extend last bin
    
    # inner integral
    # wavelength d lambda
    irr_weighted = irr * np.exp(-C2 * wavelengths) # weight irradiances
    irr_weighted *= wav_bin                       
    irr_pow = irr_weighted ** p
    wavelength_integral = np.sum(irr_pow, axis=1) # sum over wavelengths

    # outer integral
    # arrhenius integral dt
    time_integrand = (rh ** n) * np.exp(-Ea / (R * temps))

    dD = wavelength_integral * time_integrand
    degradation = C * np.sum(dD)

    return degradation


# change it to take pd.DataFrame? instead of np.ndarray
@njit
def vecArrhenius(
    poa_global: np.ndarray, module_temp: np.ndarray, ea: float, x: float, lnr0: float
) -> float:
    """
    Calculate arrhenius degradation using vectorized operations. To eliminate the irradiance term set the irradiance sensitivity to 0.
    
    .. math::

        R_D = R_0 \\cdot I^X \\cdot e^{\\frac{-E_a}{kT}}

    Parameters
    ----------
    poa_global : numpy.ndarray
        Plane of array irradiance [W/m^2]

    module_temp : numpy.ndarray
        Cell temperature [C].

    ea : float
        Activation energy [kJ/mol]

    x : float
        Irradiance sensitivity [unitless]

    lnR0 : float
        prefactor [ln(%/h)]

    Returns
    ----------
    degredation : float
        Degradation Rate [%/h]

    """

    mask = poa_global >= 25
    poa_global = poa_global[mask]
    module_temp = module_temp[mask]

    ea_scaled = ea / 8.31446261815324e-03
    R0 = np.exp(lnr0)
    poa_global_scaled = poa_global / 1000

    degredation = 0
    for entry in range(
        len(poa_global_scaled)
    ):  # list comprehension not supported by numba
        degredation += (
            R0
            * np.exp(-ea_scaled / (273.15 + module_temp[entry]))
            * np.power(poa_global_scaled[entry], x)
        )

    return degredation / len(poa_global)