addded some docs for indicators

docs/agro_indicators.py

@@ -0,0 +1,165 @@
+import numpy as np
+from pvlib.location import lookup_altitude
+from agroclimatic_indicators.pyeto import fao
+
+def et0(irradiance, T, Tmax, Tmin, RHmin, RHmax, WS, JJulien, latitude, longitude):
+    """
+    Calculate the daily reference evapotranspiration [ml/day] w.r.t. Penman-Monteith formula.
+
+    Parameters
+    ----------
+    irradiance : array_like
+        Daily global horizontal irradiance [MJ/m2/day].
+
+    T : array_like
+        Mean daily air temperature at 2 m height [deg Celsius].
+
+    Tmax : array_like
+        Maximum air temperature at 2 m height [deg Celsius].
+
+    Tmin : array_like
+        Minimum air temperature at 2 m height [deg Celsius].
+
+    RHmin : array_like
+        Minimum daily relative humidity [%].
+
+    RHmax : array_like
+        Maximum daily relative humidity [%].
+
+    WS : array_like
+        Wind speed at 10 m height [m s-1].
+
+    JJulien : array_like
+        Julian day.
+
+    latitude : array_like
+        Latitude in °.
+
+    longitude : array_like
+        Longitude in °.
+        
+    Returns
+    -------
+    array_like
+        Reference evapotranspiration (ETo) from a hypothetical grass reference surface [mm day-1].
+    """
+
+    latRad = (latitude * np.pi) / 180
+    ### VPD, SVP
+
+    svp_tmax = fao.svp_from_t(Tmax)
+    svp_tmin = fao.svp_from_t(Tmin)
+    svp = fao.svp_from_t(T)
+    avp = fao.avp_from_rhmin_rhmax(svp_tmin, svp_tmax, RHmin, RHmax)
+    delta_svp = fao.delta_svp(T)
+
+    ### IR
+
+    #sol_rad = irradiance * 36 / 10000   #Conversion W/m2 en MJ/m2/day
+    sol_rad = irradiance 
+
+    ### Radiation Nette
+
+    sol_dec = fao.sol_dec(JJulien)
+    sunset_hour_angle = fao.sunset_hour_angle(latRad, sol_dec)
+    inv_dist_earth_sun = fao.inv_rel_dist_earth_sun(JJulien)
+
+    et_rad = fao.et_rad(latRad, sol_dec, sunset_hour_angle, inv_dist_earth_sun)
+
+    T_kelvin = T + 273.15
+    Tmin_kelvin = Tmin + 273.15
+    Tmax_kelvin = Tmax + 273.15
+
+    altitude = np.array(lookup_altitude(latitude, longitude))
+
+    cs_rad = fao.cs_rad(altitude, et_rad)
+
+    net_out_lw_rad = fao.net_out_lw_rad(Tmin_kelvin, Tmax_kelvin, sol_rad, cs_rad, avp)
+
+    net_in_sol_rad = fao.net_in_sol_rad(sol_rad, 0.2)
+
+    net_rad = fao.net_rad(net_in_sol_rad, net_out_lw_rad)
+
+    atm_pressure = fao.atm_pressure(altitude)
+
+    psy = fao.psy_const_of_psychrometer(2, atm_pressure)
+
+    ws_2m = fao.wind_speed_2m(WS, 10)
+
+    et0 = fao.fao56_penman_monteith(net_rad, T_kelvin, ws_2m, svp, avp, delta_svp, psy)
+
+    return et0
+
+
+def gdd(Tmin, Tmax, Tbase):
+    """
+    Calculate the Growing Degree Days [Degrees Celsius].
+
+    Parameters
+    ----------
+    Tmax : float or numpy array
+        Maximum daily air temperature [deg Celsius].
+
+    Tmin : float or numpy array
+        Minimum daily air temperature [deg Celsius].
+
+    Tbase : float or numpy array
+        Base crop temperature (corresponding to zero vegetation) [deg Celsius].
+
+    Returns
+    -------
+    float
+        Growing Degree Days [deg Celsius].
+    """
+
+    return ((Tmax + Tmin) / 2) - Tbase
+
+
+def gelif(Tmin, Tfrost):
+    """
+    Define if the day is a frosting day.
+
+    Parameters
+    ----------
+    Tmin : float or numpy array
+        Minimum daily air temperature [deg Celsius].
+
+    Tfrost : float
+        Crop frost temperature (depends on the crop and phenophase) [deg Celsius].
+
+    Returns
+    -------
+    bool
+        True if it's a frosting day, else False.
+    """
+
+    if Tmin > Tfrost:
+        is_forst = False
+    elif Tmin <= Tfrost:
+        is_forst = True
+
+    return is_forst
+
+
+def vpd(T, RH):
+    """
+    Compute deficit vapor pressure.
+
+    Parameters
+    ----------
+    T : float or numpy array
+        Mean timestep air temperature [deg Celsius].
+
+    RH : float or numpy array
+        Mean timestep relative humidity [unitless %].
+
+    Returns
+    -------
+    float or numpy array
+        Vapor pressure deficit (VPD).
+    """
+
+    VPS = 0.6108 * np.exp((17.27 * T) / (T + 237.3))
+    VPD = VPS * (1 - RH / 100)
+
+    return VPD

docs/animal_indicators.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+def hli(irradiance : float, air_temperature : float, RH : float, wind_speed : float):
+    """
+    Compute Heat Load Index (HLI), a thermal stress indicator for animals.
+
+    Parameters
+    ----------
+    irradiance : float
+        Solar radiation [W.m-2]
+
+    air_temperature : float
+        Air temperature [°C]
+
+    RH : float
+        Relative humidity [%]
+        
+    wind_speed : float
+        Wind speed [m.s-1]
+
+    Returns
+    -------
+    float
+        Heat Load Index value.
+    """
+
+    BGT = 0.01498*irradiance + 1.184*air_temperature - 0.0789*RH - 2.739
+    HLI = np.where(BGT >= 25, 1.55*BGT- 0.5*wind_speed + np.exp(2.4 - wind_speed)+8.62 + 0.38*RH, 1.30*BGT - wind_speed+10.66 + 0.28*RH)
+    
+    return HLI

docs/climatic_indicators.py

@@ -0,0 +1,106 @@
+def frost_bool(Tmin,Tfrost):
+
+    """
+    Test if the day is a frost day (minimum daily temperature below frost threshold).
+
+    Parameters
+    ----------
+    Tmin : float
+        Minimum daily air temperature (deg Celsius).
+
+    Tfrost : float
+        Frost temperature (regular or strong frost) (deg Celsius).
+
+    Returns
+    -------
+    bool
+        True if it's a frost day, else False.
+    """
+
+    return Tmin <= Tfrost
+
+
+
+
+def scorch_bool(Tmax,Tscorch):
+
+    """
+    Test if the day is a scorching day (jour échaudant) (maximum daily temperature above scorch threshold).
+
+    Parameters
+    ----------
+    Tmax : float
+        Maximum daily air temperature (deg Celsius).
+
+    Tscorch : float
+        Temperature threshold above which the day is considered scorching (crop-dependent) (deg Celsius).
+
+    Returns
+    -------
+    bool
+        True if it's a scorching day, else False.
+    """
+    
+    return Tmax >= Tscorch
+
+
+
+def thermalstress_bool(Tmax, Tstress):
+
+    """
+    Define if the day is a source of thermal stress (maximum daily temperature above stress threshold).
+
+    Parameters
+    ----------
+    Tmax : float
+        Maximum daily air temperature (deg Celsius).
+
+    Tstress : float
+        Temperature threshold above which the day is considered stressful (deg Celsius).
+
+    Returns
+    -------
+    bool
+        True if the day is a source of thermal stress, else False.
+    """
+    return Tmax >= Tstress
+
+    
+
+def summerday_bool(Tmax):
+    """
+    Define if the day is a summer day (maximum daily temperature above 25°C).
+
+    Parameters
+    ----------
+    Tmax : float
+        Maximum daily air temperature (deg Celsius).
+
+    Returns
+    -------
+    bool
+        True if it's a summer day, else False.
+    """
+
+    return Tmax >= 25
+
+
+def tropicalnight_bool(Tmin):
+
+    """
+    Define if night is a tropical night (min night temperature above 20°).
+
+    Parameters
+    ----------
+    Tmin : float
+        Min Night Air temperature (degrees Celsius).
+
+    Returns
+    -------
+    bool
+        True if tropical night, else False.
+    """
+
+    return Tmin >= 20
+
+

docs/compute.py

@@ -0,0 +1,319 @@
+import numpy as np
+import pandas as pd
+from pvlib.solarposition import sun_rise_set_transit_spa
+from agroclimatic_indicators import (
+    agro_indicators,
+    animal_indicators,
+    climatic_indicators,
+)
+
+
+## Compute Agronomics
+def compute_vpd(df: pd.DataFrame):
+    """
+    Compute VPD.
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing sensor data.
+
+    Returns
+    -------
+    arraylike
+        VPD at df's timestep
+    """
+    return agro_indicators.vpd(df.air_temperature, df.relative_humidity)
+
+
+
+def compute_et0(
+    df: pd.DataFrame,
+    latitude: float,
+    longitude: float
+):
+    """
+    Compute reference evapotranspiration.
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing sensor data.
+
+    latitude : float
+        Latitude of the location.
+    longitude : float
+        Longitude of the location
+
+    Returns
+    -------
+    arraylike
+        Daily reference evapotranspiration.
+    """
+
+    irradiance = (
+        (df.photon_flux_density.resample("1h").mean() / 2.1).resample("1d").sum()
+    )
+    T = df.air_temperature.resample("1d").mean()
+    Tmin = df.air_temperature.resample("1d").min()
+    Tmax = df.air_temperature.resample("1d").max()
+    RHmin = df.relative_humidity.resample("1d").min()
+    RHmax = df.relative_humidity.resample("1d").max()
+    WS = df.wind_speed.resample("1d").mean()
+    JJulien = np.unique(df.index.day_of_year)
+
+    l = [
+        agro_indicators.et0(
+            irradiance.iloc[i],
+            T.iloc[i],
+            Tmax.iloc[i],
+            Tmin.iloc[i],
+            RHmin.iloc[i],
+            RHmax.iloc[i],
+            WS.iloc[i],
+            JJulien[i],
+            latitude,
+            np.array([longitude]),
+        )
+        for i in range(len(JJulien))
+    ]
+
+    if len(JJulien) == 1:
+        et0 = l[0]
+    else:
+        et0 = l
+
+    return et0
+
+
+## Compute Climatics
+
+
+def compute_frostday(df: pd.DataFrame):
+    """
+    Define if day is a frost day (min temperature below 0°C).
+
+    Parameters
+    ----------
+    df : DataFrame
+        Air sensors data.
+
+    Returns
+    -------
+    bool
+        True if day is a frost day, else False.
+    """
+
+    T = df.air_temperature.resample("1d").min()
+
+    ind = climatic_indicators.frost_bool(T, 0)
+    if ind.shape[0] == 1:
+        ind = ind.iloc[0]
+    return ind
+
+
+def compute_strongfrostday(df: pd.DataFrame):
+    """
+    Define if day is a strong frost day (min temperature below -3°C).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing temperature data.
+
+    Returns
+    -------
+    bool
+        True if day is a strong frost day, else False.
+    """
+
+    T = df.air_temperature.resample("1d").min()
+
+    ind = climatic_indicators.frost_bool(T, -3)
+    if ind.shape[0] == 1:
+        ind = ind.iloc[0]
+
+    return ind
+
+
+def compute_thermalstressday(df: pd.DataFrame, stress_threshold: float = 35):
+    """
+    Define if daily temperature is a source of thermal stress (max temperature above stress threshold).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    stress_threshold : float
+        Threshold temperature of stress (degrees Celsius).
+
+    Returns
+    -------
+    bool
+        True if day is a day with thermal stress, else False.
+    """
+
+    T = df.air_temperature.resample("1d").max()
+
+    ind = climatic_indicators.thermalstress_bool(T, stress_threshold)
+    if ind.shape[0] == 1:
+        ind = ind.iloc[0]
+
+    return ind
+
+
+def compute_summerday(df: pd.DataFrame):
+    """
+    Define if day is a summer day (max temperature above 25°C).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    Returns
+    -------
+    bool
+        True if day is a summer day, else False.
+    """
+    T = df.air_temperature.resample("1d").max()
+
+    ind = climatic_indicators.summerday_bool(T)
+    if ind.shape[0] == 1:
+        ind = ind.iloc[0]
+
+    return ind
+
+
+def compute_scorchday(df: pd.DataFrame, scorch_threshold: float = 25):
+    """
+    Define if day is a scorching day (jour échaudant) (max temperature above scorch threshold).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    scorch_threshold : float
+        Temperature threshold above which the day is considered scorching (degrees Celsius).
+
+    Returns
+    -------
+    bool
+        True if day is a scorching day, else False.
+    """
+    T = df.air_temperature.resample("1d").max()
+
+    ind = climatic_indicators.scorch_bool(T, scorch_threshold)
+
+    if ind.shape[0] == 1:
+        ind = ind.iloc[0]
+
+    return ind
+
+
+def compute_tropicalnight(df: pd.DataFrame, latitude: float, longitude: float):
+    """
+    Define if night is a tropical night (min temperature above 20°C).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    latitude : float
+        Latitude of the location.
+
+    longitude : float
+        Longitude of the location.
+
+    Returns
+    -------
+    bool
+        True if night is a tropical night, else False.
+    """
+    if len(df) == 0:
+        return None
+
+    df = sun_rise_set_transit_spa(
+        times=df.index, latitude=latitude, longitude=longitude
+    ).merge(df["air_temperature"], left_index=True, right_index=True)
+    df = df.loc[(df.index < df["sunrise"]) | (df.index > df["sunset"])]
+
+    df_minnight = df.resample("24h", offset="12h")["air_temperature"].min()
+
+    tropicalnight = climatic_indicators.tropicalnight_bool(df_minnight)
+
+    if tropicalnight.shape[0] == 1:
+        tropicalnight = tropicalnight.iloc[0]
+
+    return tropicalnight
+
+
+def compute_mintempnight(df: pd.DataFrame, latitude: float, longitude: float):
+    """
+    Return minimal night temperature.
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    latitude : float
+        Latitude of the location.
+
+    longitude : float
+        Longitude of the location.
+
+    Returns
+    -------
+    float
+        Min night temperature (degrees Celsius).
+    """
+    if len(df) == 0:
+        return None
+
+    df = sun_rise_set_transit_spa(df.index, latitude, longitude).merge(
+        df["air_temperature"], left_index=True, right_index=True
+    )
+    df = df.loc[(df.index < df["sunrise"]) | (df.index > df["sunset"])]
+
+    df_minnight = df.resample("24h", offset="12h")["air_temperature"].min()
+
+    if df_minnight.shape[0] == 1:
+        df_minnight = df_minnight.iloc[0]
+
+    return df_minnight
+
+
+def compute_hli(
+    df: pd.DataFrame,
+):
+    """
+    Computes HLI (heat load index).
+
+    Parameters
+    ----------
+    df : DataFrame
+        The input dataframe containing air temperature data.
+
+    Returns
+    -------
+    float
+        HLI value.
+    """
+
+    ind = animal_indicators.hli(
+        irradiance=df.photon_flux_density,
+        air_temperature=df.air_temperature,
+        RH=df.relative_humidity,
+        wind_speed=df.wind_speed,
+    )
+
+    if ind.size == 1:
+        df_ind = float(ind)
+    else:
+        df_ind = pd.Series(ind, index=df.index)
+
+    return df_ind

docs/pyeto/__init__.py

@@ -0,0 +1,94 @@
+from .convert import (
+    celsius2kelvin,
+    kelvin2celsius,
+    deg2rad,
+    rad2deg,
+)
+
+from .fao import (
+    atm_pressure,
+    avp_from_tmin,
+    avp_from_rhmin_rhmax,
+    avp_from_rhmax,
+    avp_from_rhmean,
+    avp_from_tdew,
+    avp_from_twet_tdry,
+    cs_rad,
+    daily_mean_t,
+    daylight_hours,
+    delta_svp,
+    energy2evap,
+    et_rad,
+    fao56_penman_monteith,
+    hargreaves,
+    inv_rel_dist_earth_sun,
+    mean_svp,
+    monthly_soil_heat_flux,
+    monthly_soil_heat_flux2,
+    net_in_sol_rad,
+    net_out_lw_rad,
+    net_rad,
+    psy_const,
+    psy_const_of_psychrometer,
+    rh_from_avp_svp,
+    SOLAR_CONSTANT,
+    sol_dec,
+    sol_rad_from_sun_hours,
+    sol_rad_from_t,
+    sol_rad_island,
+    STEFAN_BOLTZMANN_CONSTANT,
+    sunset_hour_angle,
+    svp_from_t,
+    wind_speed_2m,
+)
+
+from .thornthwaite import (
+    thornthwaite,
+    monthly_mean_daylight_hours,
+)
+
+__all__ = [
+    # Unit conversions
+    "celsius2kelvin",
+    "deg2rad",
+    "kelvin2celsius",
+    "rad2deg",
+    # FAO equations
+    "atm_pressure",
+    "avp_from_tmin",
+    "avp_from_rhmin_rhmax",
+    "avp_from_rhmax",
+    "avp_from_rhmean",
+    "avp_from_tdew",
+    "avp_from_twet_tdry",
+    "cs_rad",
+    "daily_mean_t",
+    "daylight_hours",
+    "delta_svp",
+    "energy2evap",
+    "et_rad",
+    "fao56_penman_monteith",
+    "hargreaves",
+    "inv_rel_dist_earth_sun",
+    "mean_svp",
+    "monthly_soil_heat_flux",
+    "monthly_soil_heat_flux2",
+    "net_in_sol_rad",
+    "net_out_lw_rad",
+    "net_rad",
+    "psy_const",
+    "psy_const_of_psychrometer",
+    "rh_from_avp_svp",
+    "SOLAR_CONSTANT",
+    "sol_dec",
+    "sol_rad_from_sun_hours",
+    "sol_rad_from_t",
+    "sol_rad_island",
+    "STEFAN_BOLTZMANN_CONSTANT",
+    "sunset_hour_angle",
+    "svp_from_t",
+    "wind_speed_2m",
+    # Thornthwaite method
+    "thornthwaite",
+    "monthly_mean_daylight_hours",
+]

docs/pyeto/_check.py

@@ -0,0 +1,76 @@
+"""
+Internal validation functions.
+
+:copyright: (c) 2015 by Mark Richards.
+:license: BSD 3-Clause, see LICENSE.txt for more details.
+"""
+from .convert import deg2rad
+import numpy as np
+
+# Internal constants
+# Latitude
+_MINLAT_RADIANS = deg2rad(-90.0)
+_MAXLAT_RADIANS = deg2rad(90.0)
+
+# Solar declination
+_MINSOLDEC_RADIANS = deg2rad(-23.5)
+_MAXSOLDEC_RADIANS = deg2rad(23.5)
+
+# Sunset hour angle
+_MINSHA_RADIANS = 0.0
+_MAXSHA_RADIANS = deg2rad(180)
+
+
+def check_day_hours(hours, arg_name):
+    """
+    Check that *hours* is in the range 1 to 24.
+    """
+    if not np.all((0 <= hours) & (hours <= 24)):
+        raise ValueError("{0} should be in range 0-24: {1!r}".format(arg_name, hours))
+
+
+def check_doy(doy):
+    """
+    Check day of the year is valid.
+    """
+    if not np.all((1 <= doy) & (doy <= 366)):
+        raise ValueError(
+            "Day of the year (doy) must be in range 1-366."
+        )
+
+
+def check_latitude_rad(latitude):
+    if not np.all((_MINLAT_RADIANS <= latitude) & (latitude <= _MAXLAT_RADIANS)):
+        raise ValueError(
+            "latitude outside valid range {0!r} to {1!r} rad: {2!r}".format(
+                _MINLAT_RADIANS, _MAXLAT_RADIANS, latitude
+            )
+        )
+
+
+def check_sol_dec_rad(sd):
+    """
+    Solar declination can vary between -23.5 and +23.5 degrees.
+
+    See http://mypages.iit.edu/~maslanka/SolarGeo.pdf
+    """
+    if not np.all((_MINSOLDEC_RADIANS <= sd) & (sd <= _MAXSOLDEC_RADIANS)):
+        raise ValueError(
+            "solar declination outside valid range {0!r} to {1!r} rad: {2!r}".format(
+                _MINSOLDEC_RADIANS, _MAXSOLDEC_RADIANS, sd
+            )
+        )
+
+
+def check_sunset_hour_angle_rad(sha):
+    """
+    Sunset hour angle has the range 0 to 180 degrees.
+
+    See http://mypages.iit.edu/~maslanka/SolarGeo.pdf
+    """
+    if not np.all((_MINSHA_RADIANS <= sha) & (sha <= _MAXSHA_RADIANS)):
+        raise ValueError(
+            "sunset hour angle outside valid range {0!r} to {1!r} rad: {2!r}".format(
+                _MINSHA_RADIANS, _MAXSHA_RADIANS, sha
+            )
+        )

docs/pyeto/convert.py

@@ -0,0 +1,52 @@
+"""
+Unit conversion functions.
+
+:copyright: (c) 2015 by Mark Richards.
+:license: BSD 3-Clause, see LICENSE.txt for more details.
+"""
+
+import numpy as np
+
+
+def celsius2kelvin(celsius):
+    """
+    Convert temperature in degrees Celsius to degrees Kelvin.
+
+    :param celsius: Degrees Celsius
+    :return: Degrees Kelvin
+    :rtype: float
+    """
+    return celsius + 273.15
+
+
+def kelvin2celsius(kelvin):
+    """
+    Convert temperature in degrees Kelvin to degrees Celsius.
+
+    :param kelvin: Degrees Kelvin
+    :return: Degrees Celsius
+    :rtype: float
+    """
+    return kelvin - 273.15
+
+
+def deg2rad(degrees):
+    """
+    Convert angular degrees to radians
+
+    :param degrees: Value in degrees to be converted.
+    :return: Value in radians
+    :rtype: float
+    """
+    return degrees * (np.pi / 180.0)
+
+
+def rad2deg(radians):
+    """
+    Convert radians to angular degrees
+
+    :param radians: Value in radians to be converted.
+    :return: Value in angular degrees
+    :rtype: float
+    """
+    return radians * (180.0 / np.pi)

docs/pyeto/fao.py

@@ -0,0 +1,735 @@
+"""
+Library of functions for estimating reference evapotransporation (ETo) for
+a grass reference crop using the FAO-56 Penman-Monteith and Hargreaves
+equations. The library includes numerous functions for estimating missing
+meteorological data.
+
+:copyright: (c) 2015 by Mark Richards.
+:license: BSD 3-Clause, see LICENSE.txt for more details.
+"""
+
+import numpy as np
+
+from ._check import (
+    check_day_hours as _check_day_hours,
+    check_doy as _check_doy,
+    check_latitude_rad as _check_latitude_rad,
+    check_sol_dec_rad as _check_sol_dec_rad,
+    check_sunset_hour_angle_rad as _check_sunset_hour_angle_rad,
+)
+
+#: Solar constant [ MJ m-2 min-1]
+SOLAR_CONSTANT = 0.0820
+
+# Stefan Boltzmann constant [MJ K-4 m-2 day-1]
+STEFAN_BOLTZMANN_CONSTANT = 0.000000004903  #
+"""Stefan Boltzmann constant [MJ K-4 m-2 day-1]"""
+
+
+def atm_pressure(altitude):
+    """
+    Estimate atmospheric pressure from altitude.
+
+    Calculated using a simplification of the ideal gas law, assuming 20 degrees
+    Celsius for a standard atmosphere. Based on equation 7, page 62 in Allen
+    et al (1998).
+
+    :param altitude: Elevation/altitude above sea level [m]
+    :return: atmospheric pressure [kPa]
+    :rtype: float
+    """
+    tmp = (293.0 - (0.0065 * altitude)) / 293.0
+    return np.power(tmp, 5.26) * 101.3
+
+
+def avp_from_tmin(tmin):
+    """
+    Estimate actual vapour pressure (*ea*) from minimum temperature.
+
+    This method is to be used where humidity data are lacking or are of
+    questionable quality. The method assumes that the dewpoint temperature
+    is approximately equal to the minimum temperature (*tmin*), i.e. the
+    air is saturated with water vapour at *tmin*.
+
+    **Note**: This assumption may not hold in arid/semi-arid areas.
+    In these areas it may be better to subtract 2 deg C from the
+    minimum temperature (see Annex 6 in FAO paper).
+
+    Based on equation 48 in Allen et al (1998).
+
+    :param tmin: Daily minimum temperature [deg C]
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    return 0.611 * np.exp((17.27 * tmin) / (tmin + 237.3))
+
+
+def avp_from_rhmin_rhmax(svp_tmin, svp_tmax, rh_min, rh_max):
+    """
+    Estimate actual vapour pressure (*ea*) from saturation vapour pressure and
+    relative humidity.
+
+    Based on FAO equation 17 in Allen et al (1998).
+
+    :param svp_tmin: Saturation vapour pressure at daily minimum temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param svp_tmax: Saturation vapour pressure at daily maximum temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param rh_min: Minimum relative humidity [%]
+    :param rh_max: Maximum relative humidity [%]
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    tmp1 = svp_tmin * (rh_max / 100.0)
+    tmp2 = svp_tmax * (rh_min / 100.0)
+    return (tmp1 + tmp2) / 2.0
+
+
+def avp_from_rhmax(svp_tmin, rh_max):
+    """
+    Estimate actual vapour pressure (*e*a) from saturation vapour pressure at
+    daily minimum temperature and maximum relative humidity
+
+    Based on FAO equation 18 in Allen et al (1998).
+
+    :param svp_tmin: Saturation vapour pressure at daily minimum temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param rh_max: Maximum relative humidity [%]
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    return svp_tmin * (rh_max / 100.0)
+
+
+def avp_from_rhmean(svp_tmin, svp_tmax, rh_mean):
+    """
+    Estimate actual vapour pressure (*ea*) from saturation vapour pressure at
+    daily minimum and maximum temperature, and mean relative humidity.
+
+    Based on FAO equation 19 in Allen et al (1998).
+
+    :param svp_tmin: Saturation vapour pressure at daily minimum temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param svp_tmax: Saturation vapour pressure at daily maximum temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param rh_mean: Mean relative humidity [%] (average of RH min and RH max).
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    return (rh_mean / 100.0) * ((svp_tmax + svp_tmin) / 2.0)
+
+
+def avp_from_tdew(tdew):
+    """
+    Estimate actual vapour pressure (*ea*) from dewpoint temperature.
+
+    Based on equation 14 in Allen et al (1998). As the dewpoint temperature is
+    the temperature to which air needs to be cooled to make it saturated, the
+    actual vapour pressure is the saturation vapour pressure at the dewpoint
+    temperature.
+
+    This method is preferable to calculating vapour pressure from
+    minimum temperature.
+
+    :param tdew: Dewpoint temperature [deg C]
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    return 0.6108 * np.exp((17.27 * tdew) / (tdew + 237.3))
+
+
+def avp_from_twet_tdry(twet, tdry, svp_twet, psy_const):
+    """
+    Estimate actual vapour pressure (*ea*) from wet and dry bulb temperature.
+
+    Based on equation 15 in Allen et al (1998). As the dewpoint temperature
+    is the temperature to which air needs to be cooled to make it saturated, the
+    actual vapour pressure is the saturation vapour pressure at the dewpoint
+    temperature.
+
+    This method is preferable to calculating vapour pressure from
+    minimum temperature.
+
+    Values for the psychrometric constant of the psychrometer (*psy_const*)
+    can be calculated using ``psyc_const_of_psychrometer()``.
+
+    :param twet: Wet bulb temperature [deg C]
+    :param tdry: Dry bulb temperature [deg C]
+    :param svp_twet: Saturated vapour pressure at the wet bulb temperature
+        [kPa]. Can be estimated using ``svp_from_t()``.
+    :param psy_const: Psychrometric constant of the pyschrometer [kPa deg C-1].
+        Can be estimated using ``psy_const()`` or
+        ``psy_const_of_psychrometer()``.
+    :return: Actual vapour pressure [kPa]
+    :rtype: float
+    """
+    return svp_twet - (psy_const * (tdry - twet))
+
+
+def cs_rad(altitude, et_rad):
+    """
+    Estimate clear sky radiation from altitude and extraterrestrial radiation.
+
+    Based on equation 37 in Allen et al (1998) which is recommended when
+    calibrated Angstrom values are not available.
+
+    :param altitude: Elevation above sea level [m]
+    :param et_rad: Extraterrestrial radiation [MJ m-2 day-1]. Can be
+        estimated using ``et_rad()``.
+    :return: Clear sky radiation [MJ m-2 day-1]
+    :rtype: float
+    """
+    return (0.00002 * altitude + 0.75) * et_rad
+
+
+def daily_mean_t(tmin, tmax):
+    """
+    Estimate mean daily temperature from the daily minimum and maximum
+    temperatures.
+
+    :param tmin: Minimum daily temperature [deg C]
+    :param tmax: Maximum daily temperature [deg C]
+    :return: Mean daily temperature [deg C]
+    :rtype: float
+    """
+    return (tmax + tmin) / 2.0
+
+
+def daylight_hours(sha):
+    """
+    Calculate daylight hours from sunset hour angle.
+
+    Based on FAO equation 34 in Allen et al (1998).
+
+    :param sha: Sunset hour angle [rad]. Can be calculated using
+        ``sunset_hour_angle()``.
+    :return: Daylight hours.
+    :rtype: float
+    """
+    _check_sunset_hour_angle_rad(sha)
+    return (24.0 / np.pi) * sha
+
+
+def delta_svp(t):
+    """
+    Estimate the slope of the saturation vapour pressure curve at a given
+    temperature.
+
+    Based on equation 13 in Allen et al (1998). If using in the Penman-Monteith
+    *t* should be the mean air temperature.
+
+    :param t: Air temperature [deg C]. Use mean air temperature for use in
+        Penman-Monteith.
+    :return: Saturation vapour pressure [kPa degC-1]
+    :rtype: float
+    """
+    tmp = 4098 * (0.6108 * np.exp((17.27 * t) / (t + 237.3)))
+    return tmp / np.power((t + 237.3), 2)
+
+
+def energy2evap(energy):
+    """
+    Convert energy (e.g. radiation energy) in MJ m-2 day-1 to the equivalent
+    evaporation, assuming a grass reference crop.
+
+    Energy is converted to equivalent evaporation using a conversion
+    factor equal to the inverse of the latent heat of vapourisation
+    (1 / lambda = 0.408).
+
+    Based on FAO equation 20 in Allen et al (1998).
+
+    :param energy: Energy e.g. radiation or heat flux [MJ m-2 day-1].
+    :return: Equivalent evaporation [mm day-1].
+    :rtype: float
+    """
+    return 0.408 * energy
+
+
+def et_rad(latitude, sol_dec, sha, ird):
+    """
+    Estimate daily extraterrestrial radiation (*Ra*, 'top of the atmosphere
+    radiation').
+
+    Based on equation 21 in Allen et al (1998). If monthly mean radiation is
+    required make sure *sol_dec*. *sha* and *irl* have been calculated using
+    the day of the year that corresponds to the middle of the month.
+
+    **Note**: From Allen et al (1998): "For the winter months in latitudes
+    greater than 55 degrees (N or S), the equations have limited validity.
+    Reference should be made to the Smithsonian Tables to assess possible
+    deviations."
+
+    :param latitude: Latitude [radians]
+    :param sol_dec: Solar declination [radians]. Can be calculated using
+        ``sol_dec()``.
+    :param sha: Sunset hour angle [radians]. Can be calculated using
+        ``sunset_hour_angle()``.
+    :param ird: Inverse relative distance earth-sun [dimensionless]. Can be
+        calculated using ``inv_rel_dist_earth_sun()``.
+    :return: Daily extraterrestrial radiation [MJ m-2 day-1]
+    :rtype: float
+    """
+    _check_latitude_rad(latitude)
+    _check_sol_dec_rad(sol_dec)
+    _check_sunset_hour_angle_rad(sha)
+
+    tmp1 = (24.0 * 60.0) / np.pi
+    tmp2 = sha * np.sin(latitude) * np.sin(sol_dec)
+    tmp3 = np.cos(latitude) * np.cos(sol_dec) * np.sin(sha)
+    return tmp1 * SOLAR_CONSTANT * ird * (tmp2 + tmp3)
+
+
+def fao56_penman_monteith(net_rad, t, ws, svp, avp, delta_svp, psy, shf=0.0):
+    """
+    Estimate reference evapotranspiration (ETo) from a hypothetical
+    short grass reference surface using the FAO-56 Penman-Monteith equation.
+
+    Based on equation 6 in Allen et al (1998).
+
+    :param net_rad: Net radiation at crop surface [MJ m-2 day-1]. If
+        necessary this can be estimated using ``net_rad()``.
+    :param t: Air temperature at 2 m height [deg Kelvin].
+    :param ws: Wind speed at 2 m height [m s-1]. If not measured at 2m,
+        convert using ``wind_speed_at_2m()``.
+    :param svp: Saturation vapour pressure [kPa]. Can be estimated using
+        ``svp_from_t()''.
+    :param avp: Actual vapour pressure [kPa]. Can be estimated using a range
+        of functions with names beginning with 'avp_from'.
+    :param delta_svp: Slope of saturation vapour pressure curve [kPa degC-1].
+        Can be estimated using ``delta_svp()``.
+    :param psy: Psychrometric constant [kPa deg C]. Can be estimatred using
+        ``psy_const_of_psychrometer()`` or ``psy_const()``.
+    :param shf: Soil heat flux (G) [MJ m-2 day-1] (default is 0.0, which is
+        reasonable for a daily or 10-day time steps). For monthly time steps
+        *shf* can be estimated using ``monthly_soil_heat_flux()`` or
+        ``monthly_soil_heat_flux2()``.
+    :return: Reference evapotranspiration (ETo) from a hypothetical
+        grass reference surface [mm day-1].
+    :rtype: float
+    """
+    a1 = (0.408 * (net_rad - shf) * delta_svp /
+          (delta_svp + (psy * (1 + 0.34 * ws))))
+    a2 = (900 * ws / t * (svp - avp) * psy /
+          (delta_svp + (psy * (1 + 0.34 * ws))))
+    return a1 + a2
+
+
+def hargreaves(tmin, tmax, tmean, et_rad):
+    """
+    Estimate reference evapotranspiration over grass (ETo) using the Hargreaves
+    equation.
+
+    Generally, when solar radiation data, relative humidity data
+    and/or wind speed data are missing, it is better to estimate them using
+    the functions available in this module, and then calculate ETo
+    the FAO Penman-Monteith equation. However, as an alternative, ETo can be
+    estimated using the Hargreaves ETo equation.
+
+    Based on equation 52 in Allen et al (1998).
+
+    :param tmin: Minimum daily temperature [deg C]
+    :param tmax: Maximum daily temperature [deg C]
+    :param tmean: Mean daily temperature [deg C]. If emasurements not
+        available it can be estimated as (*tmin* + *tmax*) / 2.
+    :param et_rad: Extraterrestrial radiation (Ra) [MJ m-2 day-1]. Can be
+        estimated using ``et_rad()``.
+    :return: Reference evapotranspiration over grass (ETo) [mm day-1]
+    :rtype: float
+    """
+    # Note, multiplied by 0.408 to convert extraterrestrial radiation could
+    # be given in MJ m-2 day-1 rather than as equivalent evaporation in
+    # mm day-1
+    return 0.0023 * (tmean + 17.8) * (tmax - tmin) ** 0.5 * 0.408 * et_rad
+
+
+def inv_rel_dist_earth_sun(day_of_year):
+    """
+    Calculate the inverse relative distance between earth and sun from
+    day of the year.
+
+    Based on FAO equation 23 in Allen et al (1998).
+
+    :param day_of_year: Day of the year [1 to 366]
+    :return: Inverse relative distance between earth and the sun
+    :rtype: float
+    """
+    _check_doy(day_of_year)
+    return 1 + (0.033 * np.cos((2.0 * np.pi / 365.0) * day_of_year))
+
+
+def mean_svp(tmin, tmax):
+    """
+    Estimate mean saturation vapour pressure, *es* [kPa] from minimum and
+    maximum temperature.
+
+    Based on equations 11 and 12 in Allen et al (1998).
+
+    Mean saturation vapour pressure is calculated as the mean of the
+    saturation vapour pressure at tmax (maximum temperature) and tmin
+    (minimum temperature).
+
+    :param tmin: Minimum temperature [deg C]
+    :param tmax: Maximum temperature [deg C]
+    :return: Mean saturation vapour pressure (*es*) [kPa]
+    :rtype: float
+    """
+    return (svp_from_t(tmin) + svp_from_t(tmax)) / 2.0
+
+
+def monthly_soil_heat_flux(t_month_prev, t_month_next):
+    """
+    Estimate monthly soil heat flux (Gmonth) from the mean air temperature of
+    the previous and next month, assuming a grass crop.
+
+    Based on equation 43 in Allen et al (1998). If the air temperature of the
+    next month is not known use ``monthly_soil_heat_flux2()`` instead. The
+    resulting heat flux can be converted to equivalent evaporation [mm day-1]
+    using ``energy2evap()``.
+
+    :param t_month_prev: Mean air temperature of the previous month
+        [deg Celsius]
+    :param t_month2_next: Mean air temperature of the next month [deg Celsius]
+    :return: Monthly soil heat flux (Gmonth) [MJ m-2 day-1]
+    :rtype: float
+    """
+    return 0.07 * (t_month_next - t_month_prev)
+
+
+def monthly_soil_heat_flux2(t_month_prev, t_month_cur):
+    """
+    Estimate monthly soil heat flux (Gmonth) [MJ m-2 day-1] from the mean
+    air temperature of the previous and current month, assuming a grass crop.
+
+    Based on equation 44 in Allen et al (1998). If the air temperature of the
+    next month is available, use ``monthly_soil_heat_flux()`` instead. The
+    resulting heat flux can be converted to equivalent evaporation [mm day-1]
+    using ``energy2evap()``.
+
+    Arguments:
+    :param t_month_prev: Mean air temperature of the previous month
+        [deg Celsius]
+    :param t_month_cur: Mean air temperature of the current month [deg Celsius]
+    :return: Monthly soil heat flux (Gmonth) [MJ m-2 day-1]
+    :rtype: float
+    """
+    return 0.14 * (t_month_cur - t_month_prev)
+
+
+def net_in_sol_rad(sol_rad, albedo=0.23):
+    """
+    Calculate net incoming solar (or shortwave) radiation from gross
+    incoming solar radiation, assuming a grass reference crop.
+
+    Net incoming solar radiation is the net shortwave radiation resulting
+    from the balance between incoming and reflected solar radiation. The
+    output can be converted to equivalent evaporation [mm day-1] using
+    ``energy2evap()``.
+
+    Based on FAO equation 38 in Allen et al (1998).
+
+    :param sol_rad: Gross incoming solar radiation [MJ m-2 day-1]. If
+        necessary this can be estimated using functions whose name
+        begins with 'sol_rad_from'.
+    :param albedo: Albedo of the crop as the proportion of gross incoming solar
+        radiation that is reflected by the surface. Default value is 0.23,
+        which is the value used by the FAO for a short grass reference crop.
+        Albedo can be as high as 0.95 for freshly fallen snow and as low as
+        0.05 for wet bare soil. A green vegetation over has an albedo of
+        about 0.20-0.25 (Allen et al, 1998).
+    :return: Net incoming solar (or shortwave) radiation [MJ m-2 day-1].
+    :rtype: float
+    """
+    return (1 - albedo) * sol_rad
+
+
+def net_out_lw_rad(tmin, tmax, sol_rad, cs_rad, avp):
+    """
+    Estimate net outgoing longwave radiation.
+
+    This is the net longwave energy (net energy flux) leaving the
+    earth's surface. It is proportional to the absolute temperature of
+    the surface raised to the fourth power according to the Stefan-Boltzmann
+    law. However, water vapour, clouds, carbon dioxide and dust are absorbers
+    and emitters of longwave radiation. This function corrects the Stefan-
+    Boltzmann law for humidity (using actual vapor pressure) and cloudiness
+    (using solar radiation and clear sky radiation). The concentrations of all
+    other absorbers are assumed to be constant.
+
+    The output can be converted to equivalent evaporation [mm day-1] using
+    ``energy2evap()``.
+
+    Based on FAO equation 39 in Allen et al (1998).
+
+    :param tmin: Absolute daily minimum temperature [degrees Kelvin]
+    :param tmax: Absolute daily maximum temperature [degrees Kelvin]
+    :param sol_rad: Solar radiation [MJ m-2 day-1]. If necessary this can be
+        estimated using ``sol+rad()``.
+    :param cs_rad: Clear sky radiation [MJ m-2 day-1]. Can be estimated using
+        ``cs_rad()``.
+    :param avp: Actual vapour pressure [kPa]. Can be estimated using functions
+        with names beginning with 'avp_from'.
+    :return: Net outgoing longwave radiation [MJ m-2 day-1]
+    :rtype: float
+    """
+    tmp1 = (STEFAN_BOLTZMANN_CONSTANT *
+        ((np.power(tmax, 4) + np.power(tmin, 4)) / 2))
+    tmp2 = (0.34 - (0.14 * np.sqrt(avp)))
+    tmp3 = 1.35 * (sol_rad / cs_rad) - 0.35
+    return tmp1 * tmp2 * tmp3
+
+
+def net_rad(ni_sw_rad, no_lw_rad):
+    """
+    Calculate daily net radiation at the crop surface, assuming a grass
+    reference crop.
+
+    Net radiation is the difference between the incoming net shortwave (or
+    solar) radiation and the outgoing net longwave radiation. Output can be
+    converted to equivalent evaporation [mm day-1] using ``energy2evap()``.
+
+    Based on equation 40 in Allen et al (1998).
+
+    :param ni_sw_rad: Net incoming shortwave radiation [MJ m-2 day-1]. Can be
+        estimated using ``net_in_sol_rad()``.
+    :param no_lw_rad: Net outgoing longwave radiation [MJ m-2 day-1]. Can be
+        estimated using ``net_out_lw_rad()``.
+    :return: Daily net radiation [MJ m-2 day-1].
+    :rtype: float
+    """
+    return ni_sw_rad - no_lw_rad
+
+
+def psy_const(atmos_pres):
+    """
+    Calculate the psychrometric constant.
+
+    This method assumes that the air is saturated with water vapour at the
+    minimum daily temperature. This assumption may not hold in arid areas.
+
+    Based on equation 8, page 95 in Allen et al (1998).
+
+    :param atmos_pres: Atmospheric pressure [kPa]. Can be estimated using
+        ``atm_pressure()``.
+    :return: Psychrometric constant [kPa degC-1].
+    :rtype: float
+    """
+    return 0.000665 * atmos_pres
+
+
+def psy_const_of_psychrometer(psychrometer, atmos_pres):
+    """
+    Calculate the psychrometric constant for different types of
+    psychrometer at a given atmospheric pressure.
+
+    Based on FAO equation 16 in Allen et al (1998).
+
+    :param psychrometer: Integer between 1 and 3 which denotes type of
+        psychrometer:
+        1. ventilated (Asmann or aspirated type) psychrometer with
+           an air movement of approximately 5 m/s
+        2. natural ventilated psychrometer with an air movement
+           of approximately 1 m/s
+        3. non ventilated psychrometer installed indoors
+    :param atmos_pres: Atmospheric pressure [kPa]. Can be estimated using
+        ``atm_pressure()``.
+    :return: Psychrometric constant [kPa degC-1].
+    :rtype: float
+    """
+    # Select coefficient based on type of ventilation of the wet bulb
+    if psychrometer == 1:
+        psy_coeff = 0.000662
+    elif psychrometer == 2:
+        psy_coeff = 0.000800
+    elif psychrometer == 3:
+        psy_coeff = 0.001200
+    else:
+        raise ValueError(
+            'psychrometer should be in range 1 to 3: {0!r}'.format(psychrometer))
+
+    return psy_coeff * atmos_pres
+
+
+def rh_from_avp_svp(avp, svp):
+    """
+    Calculate relative humidity as the ratio of actual vapour pressure
+    to saturation vapour pressure at the same temperature.
+
+    See Allen et al (1998), page 67 for details.
+
+    :param avp: Actual vapour pressure [units do not matter so long as they
+        are the same as for *svp*]. Can be estimated using functions whose
+        name begins with 'avp_from'.
+    :param svp: Saturated vapour pressure [units do not matter so long as they
+        are the same as for *avp*]. Can be estimated using ``svp_from_t()``.
+    :return: Relative humidity [%].
+    :rtype: float
+    """
+    return 100.0 * avp / svp
+
+
+def sol_dec(day_of_year):
+    """
+    Calculate solar declination from day of the year.
+
+    Based on FAO equation 24 in Allen et al (1998).
+
+    :param day_of_year: Day of year integer between 1 and 365 or 366).
+    :return: solar declination [radians]
+    :rtype: float
+    """
+    _check_doy(day_of_year)
+    return 0.409 * np.sin(((2.0 * np.pi / 365.0) * day_of_year - 1.39))
+
+
+def sol_rad_from_sun_hours(daylight_hours, sunshine_hours, et_rad):
+    """
+    Calculate incoming solar (or shortwave) radiation, *Rs* (radiation hitting
+    a horizontal plane after scattering by the atmosphere) from relative
+    sunshine duration.
+
+    If measured radiation data are not available this method is preferable
+    to calculating solar radiation from temperature. If a monthly mean is
+    required then divide the monthly number of sunshine hours by number of
+    days in the month and ensure that *et_rad* and *daylight_hours* was
+    calculated using the day of the year that corresponds to the middle of
+    the month.
+
+    Based on equations 34 and 35 in Allen et al (1998).
+
+    :param dl_hours: Number of daylight hours [hours]. Can be calculated
+        using ``daylight_hours()``.
+    :param sunshine_hours: Sunshine duration [hours].
+    :param et_rad: Extraterrestrial radiation [MJ m-2 day-1]. Can be
+        estimated using ``et_rad()``.
+    :return: Incoming solar (or shortwave) radiation [MJ m-2 day-1]
+    :rtype: float
+    """
+    _check_day_hours(sunshine_hours, 'sun_hours')
+    _check_day_hours(daylight_hours, 'daylight_hours')
+
+    # 0.5 and 0.25 are default values of regression constants (Angstrom values)
+    # recommended by FAO when calibrated values are unavailable.
+    return (0.5 * sunshine_hours / daylight_hours + 0.25) * et_rad
+
+
+def sol_rad_from_t(et_rad, cs_rad, tmin, tmax, coastal):
+    """
+    Estimate incoming solar (or shortwave) radiation, *Rs*, (radiation hitting
+    a horizontal plane after scattering by the atmosphere) from min and max
+    temperature together with an empirical adjustment coefficient for
+    'interior' and 'coastal' regions.
+
+    The formula is based on equation 50 in Allen et al (1998) which is the
+    Hargreaves radiation formula (Hargreaves and Samani, 1982, 1985). This
+    method should be used only when solar radiation or sunshine hours data are
+    not available. It is only recommended for locations where it is not
+    possible to use radiation data from a regional station (either because
+    climate conditions are heterogeneous or data are lacking).
+
+    **NOTE**: this method is not suitable for island locations due to the
+    moderating effects of the surrounding water.
+
+    :param et_rad: Extraterrestrial radiation [MJ m-2 day-1]. Can be
+        estimated using ``et_rad()``.
+    :param cs_rad: Clear sky radiation [MJ m-2 day-1]. Can be estimated
+        using ``cs_rad()``.
+    :param tmin: Daily minimum temperature [deg C].
+    :param tmax: Daily maximum temperature [deg C].
+    :param coastal: ``True`` if site is a coastal location, situated on or
+        adjacent to coast of a large land mass and where air masses are
+        influenced by a nearby water body, ``False`` if interior location
+        where land mass dominates and air masses are not strongly influenced
+        by a large water body.
+    :return: Incoming solar (or shortwave) radiation (Rs) [MJ m-2 day-1].
+    :rtype: float
+    """
+    # Determine value of adjustment coefficient [deg C-0.5] for
+    # coastal/interior locations
+    if coastal:
+        adj = 0.19
+    else:
+        adj = 0.16
+
+    sol_rad = adj * np.sqrt(tmax - tmin) * et_rad
+
+    # The solar radiation value is constrained by the clear sky radiation
+    return np.minimum(sol_rad, cs_rad)
+
+
+def sol_rad_island(et_rad):
+    """
+    Estimate incoming solar (or shortwave) radiation, *Rs* (radiation hitting
+    a horizontal plane after scattering by the atmosphere) for an island
+    location.
+
+    An island is defined as a land mass with width perpendicular to the
+    coastline <= 20 km. Use this method only if radiation data from
+    elsewhere on the island is not available.
+
+    **NOTE**: This method is only applicable for low altitudes (0-100 m)
+    and monthly calculations.
+
+    Based on FAO equation 51 in Allen et al (1998).
+
+    :param et_rad: Extraterrestrial radiation [MJ m-2 day-1]. Can be
+        estimated using ``et_rad()``.
+    :return: Incoming solar (or shortwave) radiation [MJ m-2 day-1].
+    :rtype: float
+    """
+    return (0.7 * et_rad) - 4.0
+
+
+def sunset_hour_angle(latitude, sol_dec):
+    """
+    Calculate sunset hour angle (*Ws*) from latitude and solar
+    declination.
+
+    Based on FAO equation 25 in Allen et al (1998).
+
+    :param latitude: Latitude [radians]. Note: *latitude* should be negative
+        if it in the southern hemisphere, positive if in the northern
+        hemisphere.
+    :param sol_dec: Solar declination [radians]. Can be calculated using
+        ``sol_dec()``.
+    :return: Sunset hour angle [radians].
+    :rtype: float
+    """
+    _check_latitude_rad(latitude)
+    _check_sol_dec_rad(sol_dec)
+
+    cos_sha = -np.tan(latitude) * np.tan(sol_dec)
+    # If tmp is >= 1 there is no sunset, i.e. 24 hours of daylight
+    # If tmp is <= 1 there is no sunrise, i.e. 24 hours of darkness
+    # See http://www.itacanet.org/the-sun-as-a-source-of-energy/
+    # part-3-calculating-solar-angles/
+    # Domain of acos is -1 <= x <= 1 radians (this is not mentioned in FAO-56!)
+    return np.arccos(np.minimum(np.maximum(cos_sha, -1.0), 1.0))
+
+
+def svp_from_t(t):
+    """
+    Estimate saturation vapour pressure (*es*) from air temperature.
+
+    Based on equations 11 and 12 in Allen et al (1998).
+
+    :param t: Temperature [deg C]
+    :return: Saturation vapour pressure [kPa]
+    :rtype: float
+    """
+    return 0.6108 * np.exp((17.27 * t) / (t + 237.3))
+
+
+def wind_speed_2m(ws, z):
+    """
+    Convert wind speed measured at different heights above the soil
+    surface to wind speed at 2 m above the surface, assuming a short grass
+    surface.
+
+    Based on FAO equation 47 in Allen et al (1998).
+
+    :param ws: Measured wind speed [m s-1]
+    :param z: Height of wind measurement above ground surface [m]
+    :return: Wind speed at 2 m above the surface [m s-1]
+    :rtype: float
+    """
+    return ws * (4.87 / np.log((67.8 * z) - 5.42))

docs/pyeto/thornthwaite.py

@@ -0,0 +1,119 @@
+"""
+Calculate potential evapotranspiration using the Thornthwaite (1948 method)
+
+:copyright: (c) 2015 by Mark Richards.
+:license: BSD 3-Clause, see LICENSE.txt for more details.
+
+References
+----------
+Thornthwaite CW (1948) An approach toward a rational classification of
+    climate. Geographical Review, 38, 55-94.
+"""
+
+import calendar
+
+from . import fao
+from ._check import check_latitude_rad as _check_latitude_rad
+
+_MONTHDAYS = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+_LEAP_MONTHDAYS = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+
+
+def thornthwaite(monthly_t, monthly_mean_dlh, year=None):
+    """
+    Estimate monthly potential evapotranspiration (PET) using the
+    Thornthwaite (1948) method.
+
+    Thornthwaite equation:
+
+        *PET* = 1.6 (*L*/12) (*N*/30) (10*Ta* / *I*)***a*
+
+    where:
+
+    * *Ta* is the mean daily air temperature [deg C, if negative use 0] of the
+      month being calculated
+    * *N* is the number of days in the month being calculated
+    * *L* is the mean day length [hours] of the month being calculated
+    * *a* = (6.75 x 10-7)*I***3 - (7.71 x 10-5)*I***2 + (1.792 x 10-2)*I* + 0.49239
+    * *I* is a heat index which depends on the 12 monthly mean temperatures and
+      is calculated as the sum of (*Tai* / 5)**1.514 for each month, where
+      Tai is the air temperature for each month in the year
+
+    :param monthly_t: Iterable containing mean daily air temperature for each
+        month of the year [deg C].
+    :param monthly_mean_dlh: Iterable containing mean daily daylight
+        hours for each month of the year (hours]. These can be calculated
+        using ``monthly_mean_daylight_hours()``.
+    :param year: Year for which PET is required. The only effect of year is
+        to change the number of days in February to 29 if it is a leap year.
+        If it is left as the default (None), then the year is assumed not to
+        be a leap year.
+    :return: Estimated monthly potential evaporation of each month of the year
+        [mm/month]
+    :rtype: List of floats
+    """
+    if len(monthly_t) != 12:
+        raise ValueError(
+            'monthly_t should be length 12 but is length {0}.'
+            .format(len(monthly_t)))
+    if len(monthly_mean_dlh) != 12:
+        raise ValueError(
+            'monthly_mean_dlh should be length 12 but is length {0}.'
+            .format(len(monthly_mean_dlh)))
+
+    if year is None or not calendar.isleap(year):
+        month_days = _MONTHDAYS
+    else:
+        month_days = _LEAP_MONTHDAYS
+
+    # Negative temperatures should be set to zero
+    adj_monthly_t = [t * (t >= 0) for t in monthly_t]
+
+    # Calculate the heat index (I)
+    I = 0.0
+    for Tai in adj_monthly_t:
+        if Tai / 5.0 > 0.0:
+            I += (Tai / 5.0) ** 1.514
+
+    a = (6.75e-07 * I ** 3) - (7.71e-05 * I ** 2) + (1.792e-02 * I) + 0.49239
+
+    pet = []
+    for Ta, L, N in zip(adj_monthly_t, monthly_mean_dlh, month_days):
+        # Multiply by 10 to convert cm/month --> mm/month
+        pet.append(
+            1.6 * (L / 12.0) * (N / 30.0) * ((10.0 * Ta / I) ** a) * 10.0)
+
+    return pet
+
+
+def monthly_mean_daylight_hours(latitude, year=None):
+    """
+    Calculate mean daylight hours for each month of the year for a given
+    latitude.
+
+    :param latitude: Latitude [radians]
+    :param year: Year for the daylight hours are required. The only effect of
+        *year* is to change the number of days in Feb to 29 if it is a leap
+        year. If left as the default, None, then a normal (non-leap) year is
+        assumed.
+    :return: Mean daily daylight hours of each month of a year [hours]
+    :rtype: List of floats.
+    """
+    _check_latitude_rad(latitude)
+
+    if year is None or not calendar.isleap(year):
+        month_days = _MONTHDAYS
+    else:
+        month_days = _LEAP_MONTHDAYS
+    monthly_mean_dlh = []
+    doy = 1         # Day of the year
+    for mdays in month_days:
+        dlh = 0.0   # Cumulative daylight hours for the month
+        for daynum in range(1, mdays + 1):
+            sd = fao.sol_dec(doy)
+            sha = fao.sunset_hour_angle(latitude, sd)
+            dlh += fao.daylight_hours(sha)
+            doy += 1
+        # Calc mean daylight hours of the month
+        monthly_mean_dlh.append(dlh / mdays)
+    return monthly_mean_dlh

docs/request_data.py

@@ -0,0 +1,65 @@
+import requests
+import io
+import logging
+import xarray as xr
+from datetime import date, timedelta
+import json
+
+
+with open('credentials.txt') as f:
+    pwd = f.readlines()
+
+response = requests.post(
+    "https://api.ombreapp.fr/api/v1.0/links/token/",
+    data={"email": "[email protected]", "password": pwd, "permission": True},
+)
+
+token = response.json()["access"]
+
+def get_air_sensors_data(plot_id, position,date_from = False, date_to= False, night=False): 
+    
+    if not date_from:
+
+        # Get Yesterday data by default
+        
+        if night :
+            date_from = (date.today() - timedelta(2)).strftime("%Y-%m-%dT%H:%M:%S")[0:11] + "12:00:00"
+            date_to = (date.today() - timedelta(1)).strftime("%Y-%m-%dT%H:%M:%S")[0:11] + "11:50:00"
+        else :
+            date_from = (date.today() - timedelta(1)).strftime("%Y-%m-%dT%H:%M:%S")
+            date_to = date_from[0:11] + "23:50:00"
+    
+    headers = {'Authorization': f"Bearer {token}", "Accept": "application/x-netcdf"}
+    # Get Climatic dataset as netcdf file
+    response = requests.get(
+        f"https://api.ombreapp.fr/api/v2.0/plots/{plot_id}/climatic_dataset/",
+        params={
+            "start_time": date_from,
+            "end_time": date_to,
+            "position": position
+        },
+        headers=headers
+    )
+
+    if response.status_code == 200:
+        # Open Dataset
+        ds_out = xr.open_dataset(io.BytesIO(response.content))
+    else:
+        logging.error(f"Error {response.status_code}: {response.content}")
+    ds_out
+    
+    df_air = ds_out[['air_temperature','relative_humidity','photon_flux_density','wind_speed']].to_dataframe()
+    return df_air
+
+def get_lat_lon(plot_id):
+    headers = {'Authorization': f"Bearer {token}"}
+
+    response = requests.get(
+    "https://api.ombreapp.fr/api/v2.0/plots/",
+    headers=headers
+    )
+
+    plots = json.loads(response.content)
+    plot = [plots[i] for i in range(len(plots)) if plots[i]['id'] == plot_id][0]
+    
+    return (plot['zone']['coordinates'][0][0][1],plot['zone']['coordinates'][0][0][0])