PM-JPL 1.2.0__py3-none-any.whl

PMJPL/downscaling/downscaling.py

@@ -0,0 +1,271 @@
+from datetime import datetime
+from dateutil import parser
+import numpy as np
+from rasters import Raster, RasterGeometry, RasterGrid
+import rasters as rt
+
+DEFAULT_UPSAMPLING = "average"
+DEFAULT_DOWNSAMPLING = "linear"
+
+def bias_correct(
+        coarse_image: Raster,
+        fine_image: Raster,
+        upsampling: str = "average",
+        downsampling: str = "linear",
+        return_bias: bool = False):
+    fine_geometry = fine_image.geometry
+    coarse_geometry = coarse_image.geometry
+    upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+    bias_coarse = upsampled - coarse_image
+    bias_fine = bias_coarse.to_geometry(fine_geometry, resampling=downsampling)
+    bias_corrected_fine = fine_image - bias_fine
+
+    if return_bias:
+        return bias_corrected_fine, bias_fine
+    else:
+        return bias_corrected_fine
+
+def linear_downscale(
+        coarse_image: Raster,
+        fine_image: Raster,
+        upsampling: str = "average",
+        downsampling: str = "linear",
+        use_gap_filling: bool = False,
+        apply_scale: bool = True,
+        apply_bias: bool = True,
+        return_scale_and_bias: bool = False) -> Raster:
+    if upsampling is None:
+        upsampling = DEFAULT_UPSAMPLING
+
+    if downsampling is None:
+        downsampling = DEFAULT_DOWNSAMPLING
+
+    coarse_geometry = coarse_image.geometry
+    fine_geometry = fine_image.geometry
+    upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+
+    if apply_scale:
+        scale_coarse = coarse_image / upsampled
+        scale_coarse = rt.where(coarse_image == 0, 0, scale_coarse)
+        scale_coarse = rt.where(upsampled == 0, 0, scale_coarse)
+        scale_fine = scale_coarse.to_geometry(fine_geometry, resampling=downsampling)
+        scale_corrected_fine = fine_image * scale_fine
+        fine_image = scale_corrected_fine
+    else:
+        scale_fine = fine_image * 0 + 1
+
+    if apply_bias:
+        upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+        bias_coarse = upsampled - coarse_image
+        bias_fine = bias_coarse.to_geometry(fine_geometry, resampling=downsampling)
+        bias_corrected_fine = fine_image - bias_fine
+        fine_image = bias_corrected_fine
+    else:
+        bias_fine = fine_image * 0
+
+    if use_gap_filling:
+        gap_fill = coarse_image.to_geometry(fine_geometry, resampling=downsampling)
+        fine_image = fine_image.fill(gap_fill)
+
+    if return_scale_and_bias:
+        fine_image["scale"] = scale_fine
+        fine_image["bias"] = bias_fine
+
+    return fine_image
+
+def NDVI_to_FVC(NDVI: Raster) -> Raster:
+    NDVIv = 0.52  # +- 0.03
+    NDVIs = 0.04  # +- 0.03
+    FVC = rt.clip((NDVI - NDVIs) / (NDVIv - NDVIs), 0, 1)
+
+    return FVC
+
+def downscale_air_temperature(
+        time_UTC: datetime,
+        Ta_K_coarse: Raster,
+        ST_K: Raster,
+        water: Raster = None,
+        fine_geometry: RasterGeometry = None,
+        coarse_geometry: RasterGeometry = None,
+        resampling: str = None,
+        upsampling: str = None,
+        downsampling: str = None,
+        apply_scale: bool = True,
+        apply_bias: bool = True,
+        return_scale_and_bias: bool = False) -> Raster:
+    """
+    near-surface air temperature (Ta) in Kelvin
+    :param time_UTC: date/time in UTC
+    :param geometry: optional target geometry
+    :param resampling: optional sampling method for resampling to target geometry
+    :return: raster of Ta
+    """
+
+    if isinstance(time_UTC, str):
+        time_UTC = parser.parse(time_UTC)
+
+    if fine_geometry is None:
+        fine_geometry = ST_K.geometry
+
+    if coarse_geometry is None:
+        coarse_geometry = Ta_K_coarse.geometry
+
+    ST_K_water = None
+
+    if water is not None:
+        ST_K_water = rt.where(water, ST_K, np.nan)
+        ST_K = rt.where(water, np.nan, ST_K)
+
+    scale = None
+    bias = None
+
+    Ta_K = linear_downscale(
+        coarse_image=Ta_K_coarse,
+        fine_image=ST_K,
+        upsampling=upsampling,
+        downsampling=downsampling,
+        apply_scale=apply_scale,
+        apply_bias=apply_bias,
+        return_scale_and_bias=return_scale_and_bias
+    )
+
+    if water is not None:
+        Ta_K_water = linear_downscale(
+            coarse_image=Ta_K_coarse,
+            fine_image=ST_K_water,
+            upsampling=upsampling,
+            downsampling=downsampling,
+            apply_scale=apply_scale,
+            apply_bias=apply_bias,
+            return_scale_and_bias=False
+        )
+
+        Ta_K = rt.where(water, Ta_K_water, Ta_K)
+
+    Ta_K.filenames = Ta_K_coarse.filenames
+
+    return Ta_K
+
+
+def downscale_soil_moisture(
+        time_UTC: datetime,
+        fine_geometry: RasterGrid,
+        coarse_geometry: RasterGrid,
+        SM_coarse: Raster,
+        SM_resampled: Raster,
+        ST_fine: Raster,
+        NDVI_fine: Raster,
+        water: Raster,
+        fvlim=0.5,
+        a=0.5,
+        smoothing="linear") -> Raster:
+    fine = fine_geometry
+    ST_fine = ST_fine.mask(~water)
+    NDVI_fine = NDVI_fine.mask(~water)
+    FVC_fine = NDVI_to_FVC(NDVI_fine)
+    soil_fine = FVC_fine < fvlim
+    Tmin_coarse = ST_fine.to_geometry(coarse_geometry, resampling="min")
+    Tmax_coarse = ST_fine.to_geometry(coarse_geometry, resampling="max")
+    Ts_fine = ST_fine.mask(soil_fine)
+    Tsmin_coarse = Ts_fine.to_geometry(coarse_geometry, resampling="min").fill(Tmin_coarse)
+    Tsmax_coarse = Ts_fine.to_geometry(coarse_geometry, resampling="max").fill(Tmax_coarse)
+    ST_coarse = ST_fine.to_geometry(coarse_geometry, resampling="average")
+    SEE_coarse = (Tsmax_coarse - ST_coarse) / rt.clip(Tsmax_coarse - Tsmin_coarse, 1, None)
+    SM_SEE_proportion = (SM_coarse / SEE_coarse).to_geometry(fine, resampling=smoothing)
+    Tsmax_fine = Tsmax_coarse.to_geometry(fine_geometry, resampling=smoothing)
+    Tsrange_fine = (Tsmax_coarse - Tsmin_coarse).to_geometry(fine, resampling=smoothing)
+    SEE_fine = (Tsmax_fine - ST_fine) / rt.clip(Tsrange_fine, 1, None)
+
+    SEE_mean = SEE_coarse.to_geometry(fine, resampling=smoothing)
+    SM_fine = rt.clip(SM_resampled + a * SM_SEE_proportion * (SEE_fine - SEE_mean), 0, 1)
+    SM_fine = SM_fine.mask(~water)
+
+    return SM_fine
+
+
+def downscale_vapor_pressure_deficit(
+        time_UTC: datetime,
+        VPD_Pa_coarse: Raster,
+        ST_K: Raster,
+        fine_geometry: RasterGeometry = None,
+        coarse_geometry: RasterGeometry = None,
+        resampling: str = None,
+        upsampling: str = None,
+        downsampling: str = None,
+        return_scale_and_bias: bool = False) -> Raster:
+    if upsampling is None:
+        upsampling = "average"
+
+    if downsampling is None:
+        downsampling = "linear"
+
+    if fine_geometry is None:
+        fine_geometry = ST_K.geometry
+
+    if coarse_geometry is None:
+        coarse_geometry = VPD_Pa_coarse.geometry
+
+    return linear_downscale(
+        coarse_image=VPD_Pa_coarse,
+        fine_image=ST_K,
+        upsampling=upsampling,
+        downsampling=downsampling,
+        return_scale_and_bias=return_scale_and_bias
+    )
+
+
+def downscale_relative_humidity(
+        time_UTC: datetime,
+        RH_coarse: Raster,
+        SM,
+        ST_K,
+        VPD_kPa,
+        water: Raster = None,
+        fine_geometry: RasterGeometry = None,
+        coarse_geometry: RasterGeometry = None,
+        resampling: str = None,
+        upsampling: str = None,
+        downsampling: str = None) -> Raster:
+    if upsampling is None:
+        upsampling = "average"
+
+    if downsampling is None:
+        downsampling = "linear"
+
+    if fine_geometry is None:
+        fine_geometry = SM.geometry
+
+    if coarse_geometry is None:
+        coarse_geometry = RH_coarse.geometry
+
+    bias_fine = None
+
+    RH_estimate_fine = SM ** (1 / VPD_kPa)
+
+    RH = bias_correct(
+        coarse_image=RH_coarse,
+        fine_image=RH_estimate_fine,
+        upsampling=upsampling,
+        downsampling=downsampling,
+        return_bias=False
+    )
+
+    if water is not None:
+        ST_K_water = rt.where(water, ST_K, np.nan)
+        RH_coarse_complement = 1 - RH_coarse
+        RH_complement_water = linear_downscale(
+            coarse_image=RH_coarse_complement,
+            fine_image=ST_K_water,
+            upsampling=upsampling,
+            downsampling=downsampling,
+            apply_bias=True,
+            return_scale_and_bias=False
+        )
+
+        RH_water = 1 - RH_complement_water
+        RH = rt.where(water, RH_water, RH)
+
+    RH = rt.clip(RH, 0, 1)
+
+    return RH
+

PMJPL/downscaling/linear_downscale.py

@@ -0,0 +1,71 @@
+from rasters import Raster
+import rasters as rt
+
+DEFAULT_UPSAMPLING = "average"
+DEFAULT_DOWNSAMPLING = "linear"
+
+def bias_correct(
+        coarse_image: Raster,
+        fine_image: Raster,
+        upsampling: str = "average",
+        downsampling: str = "linear",
+        return_bias: bool = False):
+    fine_geometry = fine_image.geometry
+    coarse_geometry = coarse_image.geometry
+    upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+    bias_coarse = upsampled - coarse_image
+    bias_fine = bias_coarse.to_geometry(fine_geometry, resampling=downsampling)
+    bias_corrected_fine = fine_image - bias_fine
+
+    if return_bias:
+        return bias_corrected_fine, bias_fine
+    else:
+        return bias_corrected_fine
+
+def linear_downscale(
+        coarse_image: Raster,
+        fine_image: Raster,
+        upsampling: str = "average",
+        downsampling: str = "cubic",
+        use_gap_filling: bool = False,
+        apply_scale: bool = True,
+        apply_bias: bool = True,
+        return_scale_and_bias: bool = False) -> Raster:
+    if upsampling is None:
+        upsampling = DEFAULT_UPSAMPLING
+
+    if downsampling is None:
+        downsampling = DEFAULT_DOWNSAMPLING
+
+    coarse_geometry = coarse_image.geometry
+    fine_geometry = fine_image.geometry
+    upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+
+    if apply_scale:
+        scale_coarse = coarse_image / upsampled
+        scale_coarse = rt.where(coarse_image == 0, 0, scale_coarse)
+        scale_coarse = rt.where(upsampled == 0, 0, scale_coarse)
+        scale_fine = scale_coarse.to_geometry(fine_geometry, resampling=downsampling)
+        scale_corrected_fine = fine_image * scale_fine
+        fine_image = scale_corrected_fine
+    else:
+        scale_fine = fine_image * 0 + 1
+
+    if apply_bias:
+        upsampled = fine_image.to_geometry(coarse_geometry, resampling=upsampling)
+        bias_coarse = upsampled - coarse_image
+        bias_fine = bias_coarse.to_geometry(fine_geometry, resampling=downsampling)
+        bias_corrected_fine = fine_image - bias_fine
+        fine_image = bias_corrected_fine
+    else:
+        bias_fine = fine_image * 0
+
+    if use_gap_filling:
+        gap_fill = coarse_image.to_geometry(fine_geometry, resampling=downsampling)
+        fine_image = fine_image.fill(gap_fill)
+
+    if return_scale_and_bias:
+        fine_image["scale"] = scale_fine
+        fine_image["bias"] = bias_fine
+
+    return fine_image

PMJPL/evapotranspiration_conversion/__init__.py

@@ -0,0 +1 @@
+from .evapotranspiration_conversion import *

PMJPL/evapotranspiration_conversion/evapotranspiration_conversion.py

@@ -0,0 +1,80 @@
+from typing import Union
+from sun_angles import SHA_deg_from_DOY_lat, daylight_from_SHA, sunrise_from_SHA
+
+import rasters as rt
+from rasters import Raster
+import numpy as np
+import pandas as pd
+
+from ..meteorology_conversion.meteorology_conversion import celcius_to_kelvin
+from ..verma_net_radiation.verma_net_radiation import daily_Rn_integration_verma
+
+# latent heat of vaporization for water at 20 Celsius in Joules per kilogram
+LAMBDA_JKG_WATER_20C = 2450000.0
+
+def lambda_Jkg_from_Ta_K(Ta_K: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    # Calculate the latent heat of vaporization (J kg-1)
+    return (2.501 - 0.002361 * (Ta_K - 273.15)) * 1e6
+
+def lambda_Jkg_from_Ta_C(Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    Ta_K = celcius_to_kelvin(Ta_C)
+    lambda_Jkg = lambda_Jkg_from_Ta_K(Ta_K)
+
+    return lambda_Jkg
+
+def daily_ET_from_daily_LE(
+        LE_daylight: Union[Raster, np.ndarray], 
+        daylight_hours: Union[Raster, np.ndarray],
+        lambda_Jkg: float = LAMBDA_JKG_WATER_20C) -> Union[Raster, np.ndarray]:
+    """
+    Calculate daily evapotranspiration (ET) from daily latent heat flux (LE).
+
+    Parameters:
+        LE_daily (Union[Raster, np.ndarray]): Daily latent heat flux.
+        daylight_hours (Union[Raster, np.ndarray]): Length of day in hours.
+        latent_vaporization (float, optional): Latent heat of vaporization. Defaults to LATENT_VAPORIZATION.
+
+    Returns:
+        Union[Raster, np.ndarray]: Daily evapotranspiration in kilograms.
+    """
+    # convert length of day in hours to seconds
+    daylight_seconds = daylight_hours * 3600.0
+
+    # factor seconds out of watts to get joules and divide by latent heat of vaporization to get kilograms
+    ET_daily_kg = rt.clip(LE_daylight * daylight_seconds / LAMBDA_JKG_WATER_20C, 0.0, None)
+
+    return ET_daily_kg
+
+def process_daily_ET_table(input_df: pd.DataFrame) -> pd.DataFrame:
+    hour_of_day = input_df.hour_of_day
+    DOY = input_df.doy
+    lat = input_df.lat
+    LE = input_df.LE
+    Rn = input_df.Rn
+    EF = LE / Rn
+
+    SHA_deg = SHA_deg_from_DOY_lat(DOY=DOY, latitude=lat)
+    sunrise_hour = sunrise_from_SHA(SHA_deg)
+    daylight_hours = daylight_from_SHA(SHA_deg)
+
+    Rn_daylight = daily_Rn_integration_verma(
+        Rn=Rn,
+        hour_of_day=hour_of_day,
+        DOY=DOY,
+        lat=lat,
+        sunrise_hour=sunrise_hour,
+        daylight_hours=daylight_hours
+    )
+
+    LE_daylight = EF * Rn_daylight
+    ET = daily_ET_from_daily_LE(LE_daylight, daylight_hours)
+
+    output_df = input_df.copy()
+    output_df["EF"] = EF
+    output_df["sunrise_hour"] = sunrise_hour
+    output_df["daylight_hours"] = daylight_hours
+    output_df["Rn_daylight"] = Rn_daylight
+    output_df["ET"] = ET
+
+    return output_df
+    

PMJPL/fwet.py

@@ -0,0 +1,21 @@
+import numpy as np
+from typing import Union
+from rasters import Raster
+
+from .constants import RH_THRESHOLD, MIN_FWET
+
+def calculate_fwet(
+        RH: Union[Raster, np.ndarray], 
+        RH_threshold: float = RH_THRESHOLD, 
+        min_fwet: float = MIN_FWET) -> Union[Raster, np.ndarray]:
+    """
+    calculates relative surface wetness
+    :param RH: relative humdity from 0.0 to 1.0
+    :return: relative surface wetness from 0.0 to 1.0
+    """
+    fwet = np.float32(np.clip(RH ** 4.0, min_fwet, None))
+
+    if RH_threshold is not None:
+        fwet = np.where(RH < RH_threshold, min_fwet, fwet)
+
+    return fwet

PMJPL/interception.py

@@ -0,0 +1,41 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+from .constants import GAMMA_PA
+
+def calculate_interception(
+        delta_Pa: Union[Raster, np.ndarray],
+        Ac: Union[Raster, np.ndarray],
+        rho: Union[Raster, np.ndarray],
+        Cp: Union[Raster, np.ndarray],
+        VPD_Pa: Union[Raster, np.ndarray],
+        FVC: Union[Raster, np.ndarray],
+        rhrc: Union[Raster, np.ndarray],
+        fwet: Union[Raster, np.ndarray],
+        rvc: Union[Raster, np.ndarray],
+        water: Union[Raster, np.ndarray],
+        gamma_Pa: Union[Raster, np.ndarray, float] = GAMMA_PA) -> Union[Raster, np.ndarray]:
+    """
+    Calculates the wet evaporation partition of the latent heat flux using the MOD16 method.
+
+    :param delta_Pa: slope of saturation to vapor pressure curve in Pascal per degree Celsius
+    :param Ac: available radiation to the canopy in watts per square meter
+    :param rho: air density in kilograms per cubic meter
+    :param Cp: specific heat capacity of the air in joules per kilogram per kelvin
+    :param VPD: vapor pressure deficit in Pascal
+    :param FVC: fraction of vegetation cover
+    :param rhrc: aerodynamic resistance in seconds per meter
+    :param fwet: relative surface wetness
+    :param rvc: wet canopy resistance
+    :param water: water content in the canopy
+    :param gamma_Pa: psychrometric constant for atmospheric pressure in Pascal (default: GAMMA_PA)
+
+    :return: wet evaporation in watts per square meter
+    """
+    numerator = (delta_Pa * Ac + (rho * Cp * VPD_Pa * FVC / rhrc)) * fwet
+    denominator = delta_Pa + gamma_Pa * (rvc / rhrc)
+    LEi = numerator / denominator
+
+    return LEi

PMJPL/meteorology_conversion/__init__.py

@@ -0,0 +1 @@
+from .meteorology_conversion import *

PMJPL/meteorology_conversion/meteorology_conversion.py

@@ -0,0 +1,123 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+# gas constant for dry air in joules per kilogram per kelvin
+RD = 286.9
+
+# gas constant for moist air in joules per kilogram per kelvin
+RW = 461.5
+
+# specific heat of water vapor in joules per kilogram per kelvin
+CPW = 1846.0
+
+# specific heat of dry air in joules per kilogram per kelvin
+CPD = 1005.0
+
+def kelvin_to_celsius(T_K: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    convert temperature in kelvin to celsius.
+    :param T_K: temperature in kelvin
+    :return: temperature in celsius
+    """
+    return T_K - 273.15
+
+def celcius_to_kelvin(T_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    convert temperature in celsius to kelvin.
+    :param T_C: temperature in celsius
+    :return: temperature in kelvin
+    """
+    return T_C + 273.15
+
+def calculate_specific_humidity(
+        Ea_Pa: Union[Raster, np.ndarray], 
+        Ps_Pa: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculate the specific humidity of air as a ratio of kilograms of water to kilograms of air.
+    
+    Args:
+        Ea_Pa (Union[Raster, np.ndarray]): Actual water vapor pressure in Pascal.
+        surface_pressure_Pa (Union[Raster, np.ndarray]): Surface pressure in Pascal.
+    
+    Returns:
+        Union[Raster, np.ndarray]: Specific humidity in kilograms of water per kilograms of air.
+    """
+    return ((0.622 * Ea_Pa) / (Ps_Pa - (0.387 * Ea_Pa)))
+
+def calculate_specific_heat(specific_humidity: Union[Raster, np.ndarray]):
+    # calculate specific heat capacity of the air (Cp)
+    # in joules per kilogram per kelvin
+    # from specific heat of water vapor (CPW)
+    # and specific heat of dry air (CPD)
+    Cp_Jkg = specific_humidity * CPW + (1 - specific_humidity) * CPD
+
+    return Cp_Jkg
+
+def calculate_air_density(
+        surface_pressure_Pa: Union[Raster, np.ndarray], 
+        Ta_K: Union[Raster, np.ndarray], 
+        specific_humidity: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculate air density.
+
+    Parameters:
+    surface_pressure_Pa (Union[Raster, np.ndarray]): Surface pressure in Pascal.
+    Ta_K (Union[Raster, np.ndarray]): Air temperature in Kelvin.
+    specific_humidity (Union[Raster, np.ndarray]): Specific humidity.
+
+    Returns:
+    Union[Raster, np.ndarray]: Air density in kilograms per cubic meter.
+    """
+    # numerator: Pa(N / m ^ 2 = kg * m / s ^ 2); denominator: J / kg / K * K)
+    rhoD = surface_pressure_Pa / (RD * Ta_K)
+
+    # calculate air density (rho) in kilograms per cubic meter
+    rho = rhoD * ((1.0 + specific_humidity) / (1.0 + specific_humidity * (RW / RD)))
+
+    return rho
+
+def SVP_kPa_from_Ta_C(Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculate the saturation vapor pressure in kiloPascal (kPa) from air temperature in Celsius.
+
+    Parameters:
+    Ta_C (Union[Raster, np.ndarray]): Air temperature in Celsius.
+
+    Returns:
+    Union[Raster, np.ndarray]: Saturation vapor pressure in kPa.
+
+    """
+    SVP_kPa = np.clip(0.611 * np.exp((Ta_C * 17.27) / (Ta_C + 237.7)), 1, None)
+
+    return SVP_kPa
+
+def SVP_Pa_from_Ta_C(Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculate the saturation vapor pressure in Pascal (Pa) from the air temperature in Celsius (Ta_C).
+
+    Parameters:
+        Ta_C (Union[Raster, np.ndarray]): Air temperature in Celsius.
+
+    Returns:
+        Union[Raster, np.ndarray]: Saturation vapor pressure in Pascal (Pa).
+    """
+    return SVP_kPa_from_Ta_C(Ta_C) * 1000
+
+def calculate_surface_pressure(elevation_m: Union[Raster, np.ndarray], Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculate surface pressure using elevation and air temperature.
+
+    Parameters:
+        elevation_m (Union[Raster, np.ndarray]): Elevation in meters.
+        Ta_K (Union[Raster, np.ndarray]): Air temperature in Kelvin.
+
+    Returns:
+        Union[Raster, np.ndarray]: Surface pressure in Pascal (Pa).
+    """
+    Ta_K = kelvin_to_celsius(Ta_C)
+    Ps_Pa = 101325.0 * (1.0 - 0.0065 * elevation_m / Ta_K) ** (9.807 / (0.0065 * 287.0))  # [Pa]
+
+    return Ps_Pa
+

PMJPL/parameters.py

@@ -0,0 +1,41 @@
+from typing import Union
+from os.path import join, abspath, dirname
+import numpy as np
+import pandas as pd
+
+from rasters import Raster, RasterGeometry
+
+from .MCD12C1.MCD12C1 import load_MCD12C1_IGBP
+
+LUT = pd.read_csv(join(abspath(dirname(__file__)), 'mod16.csv'))
+
+def MOD16_parameter_from_IGBP(variable: str, IGBP: Union[Raster, np.ndarray] = None, geometry: RasterGeometry = None) -> Union[Raster, np.ndarray]:
+    """
+    Translates the IGBP (International Geosphere-Biosphere Programme) values to the corresponding values in the Look-Up Table (LUT) for a given variable.
+
+    Parameters:
+        variable (str): The variable for which the translation is performed.
+            gl_sh (m s-1 LAI-1) Leaf conductance to sensible heat per unit LAI
+            gl_e_wv (m s-1 LAI-1) Leaf conductance to evaporated water per unit LAI
+            rbl_min (s m-1) Minimum atmospheric boundary layer resistance
+            rbl_max (s m-1) Maximum atmospheric boundary layer resistance
+            cl (m s-1) Mean potential stomatal conductance per unit leaf area
+            tmin_open (deg C) Temperature at which stomata are completely open, i.e., there is no effect of temperature on transpiration
+            tmin_close (deg C) Temperature at which stomata are almost completely closed due to (minimum) temperature stress
+            vpd_close (Pa) The VPD at which stomata are almost completely closed due to water stress
+            vpd_open (Pa) The VPD at which stomata are completely open, i.e., there is no effect of water stress on transpiration
+        IGBP (Union[np.ndarray, Raster]): The IGBP values to be translated.
+
+    Returns:
+        Union[np.ndarray, Raster]: The translated values.
+
+    """
+    if IGBP is None:
+        IGBP = load_MCD12C1_IGBP(geometry=geometry)
+
+    result = np.float32(np.array(LUT[variable])[np.array(IGBP).astype(int)])
+
+    if isinstance(IGBP, Raster):
+        result = Raster(result, geometry=IGBP.geometry)
+    
+    return result

PMJPL/penman_monteith/__init__.py

@@ -0,0 +1 @@
+from .penman_monteith import *

PMJPL/penman_monteith/penman_monteith.py

@@ -0,0 +1,20 @@
+from typing import Union
+import numpy as np
+from ..evapotranspiration_conversion.evapotranspiration_conversion import lambda_Jkg_from_Ta_C
+from ..meteorology_conversion.meteorology_conversion import celcius_to_kelvin
+
+from rasters import Raster
+
+SPECIFIC_HEAT_CAPACITY_AIR = 1013 # J kg-1 K-1, Monteith & Unsworth (2001)
+MOL_WEIGHT_WET_DRY_RATIO_AIR = 0.622
+
+def calculate_gamma(
+        Ta_C: Union[Raster, np.ndarray],
+        Ps_Pa: Union[Raster, np.ndarray],
+        Cp_Jkg: Union[Raster, np.ndarray, float] = SPECIFIC_HEAT_CAPACITY_AIR,
+        RMW: Union[Raster, np.ndarray, float] = MOL_WEIGHT_WET_DRY_RATIO_AIR) -> Union[Raster, np.ndarray]:
+    # calculate latent heat of vaporization (J kg-1)
+    lambda_Jkg = lambda_Jkg_from_Ta_C(Ta_C)
+    gamma =  (Cp_Jkg * Ps_Pa) / (lambda_Jkg * RMW)
+    
+    return gamma