PM-JPL 1.2.0__py3-none-any.whl

PMJPL/potential_soil_evaporation.py

@@ -0,0 +1,48 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+from .constants import GAMMA_PA
+
+def calculate_potential_soil_evaporation(
+        delta_Pa: float,
+        Asoil: float,
+        rho: float,
+        Cp_Jkg: float,
+        FVC: float,
+        VPD: float,
+        ras: float,
+        fwet: float,
+        rtot: float,
+        gamma_Pa: float = GAMMA_PA) -> Union[Raster, np.ndarray]:
+    """
+    MOD16 method for calculating potential soil evaporation using Penman-Monteith
+
+    Parameters:
+    s (float): Slope of the saturation to vapor pressure curve.
+    Asoil (float): Available radiation at the soil.
+    rho (float): Density of air.
+    Cp (float): Specific heat capacity of air.
+    fc (float): Fraction of soil covered by vegetation.
+    VPD (float): Vapor pressure deficit.
+    ras (float): Aerodynamic resistance.
+    fwet (float): Fraction of soil surface wetted.
+    rtot (float): Total resistance.
+    gamma (float, optional): Psychrometric constant. Defaults to GAMMA.
+
+    Returns:
+    Union[Raster, np.ndarray]: The potential soil evaporation.
+
+    Notes:
+    - The potential soil evaporation is calculated using the Penman-Monteith equation.
+    - The Penman-Monteith equation takes into account various factors such as radiation, air density, heat capacity, vegetation cover, vapor pressure deficit, aerodynamic resistance, soil wetness, and total resistance.
+    - The function returns the potential soil evaporation as either a Raster object or a NumPy array, depending on the input data type.
+    """
+    numerator = (delta_Pa * Asoil + rho * Cp_Jkg * (1.0 - FVC) * VPD / ras) * (1.0 - fwet)
+    denominator = delta_Pa + gamma_Pa * rtot / ras
+    LE_soil_pot = numerator / denominator
+
+    LE_soil_pot = rt.clip(LE_soil_pot, 0.0, None)
+
+    return LE_soil_pot

PMJPL/priestley_taylor/__init__.py

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

PMJPL/priestley_taylor/priestley_taylor.py

@@ -0,0 +1,27 @@
+from typing import Union
+import numpy as np
+
+from rasters import Raster
+
+# psychrometric constant gamma in kiloPascal per degree Celsius
+# same as value for ventilated (Asmann type) psychrometers, with an air movement of some 5 m/s
+# http://www.fao.org/docrep/x0490e/x0490e07.htm
+GAMMA_KPA = 0.0662  # kPa/C
+
+# psychrometric constant gamma in Pascal per degree Celsius
+GAMMA_PA = GAMMA_KPA * 1000
+
+def delta_kPa_from_Ta_C(Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    return 4098 * (0.6108 * np.exp(17.27 * Ta_C / (237.7 + Ta_C))) / (Ta_C + 237.3) ** 2
+
+def delta_Pa_from_Ta_C(Ta_C: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    return delta_kPa_from_Ta_C(Ta_C) * 1000
+
+def calculate_epsilon(delta: Union[Raster, np.ndarray], gamma: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    return delta / (delta + gamma)
+
+def epsilon_from_Ta_C(Ta_C: Union[Raster, np.ndarray], gamma_Pa: Union[Raster, np.ndarray, float] = GAMMA_PA) -> Union[Raster, np.ndarray]:
+    delta_Pa = delta_Pa_from_Ta_C(Ta_C)
+    epsilon = calculate_epsilon(delta=delta_Pa, gamma=gamma_Pa)
+
+    return epsilon

PMJPL/santanello/__init__.py

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

PMJPL/santanello/santanello.py

@@ -0,0 +1,46 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+from rasters import Raster
+
+def calculate_soil_heat_flux(
+        seconds_of_day: Union[Raster, np.ndarray], 
+        Rn: Union[Raster, np.ndarray], 
+        SM: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    This function calculates the soil heat flux (G) based on the method proposed by Santanello and Friedl (2003).
+    The method estimates G as a function of time of day, net radiation (Rn), and soil moisture (SM).
+
+    Parameters:
+    seconds_of_day (np.ndarray): Time in seconds of the day since midnight
+    Rn (np.ndarray): Net radiation in W/m^2
+    SM (np.ndarray): Soil moisture in m^3/m^3
+
+    Returns:
+    G (np.ndarray): Soil heat flux in W/m^2
+
+    Reference:
+    Santanello, J. A., & Friedl, M. A. (2003). Diurnal covariation in soil heat flux and net radiation. Journal of Applied Meteorology, 42(6), 851-862.
+    """
+
+    # Constants for wet and dry surface conditions
+    cgMIN = 0.05  # for wet surface
+    cgMAX = 0.35  # for dry surface
+    tgMIN = 74000  # for wet surface
+    tgMAX = 100000  # for dry surface
+
+    # Solar noon in seconds
+    solNooN = 12 * 60 * 60
+    tg0 = solNooN - seconds_of_day
+
+    # Estimating soil heat flux (G) according to Santanello and Friedl (2003)
+    cg = (1 - SM) * cgMAX + SM * cgMIN
+    tg = (1 - SM) * tgMAX + SM * tgMIN
+
+    G = Rn * cg * np.cos(2 * np.pi * (tg0 + 10800) / tg)
+
+    # Adjusting G for negative net radiation
+    G = rt.where(Rn < 0, -G, G)
+
+    return G

PMJPL/soil_heat_flux/__init__.py

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

PMJPL/soil_heat_flux/soil_heat_flux.py

@@ -0,0 +1,62 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+from rasters import Raster
+
+from ..santanello import calculate_soil_heat_flux as santanello_G
+from ..SEBAL import calculate_soil_heat_flux as SEBAL_G
+
+DEFAULT_G_METHOD = "santanello"
+
+def calculate_soil_heat_flux(
+        seconds_of_day: Union[Raster, np.ndarray] = None,
+        ST_C: Union[Raster, np.ndarray] = None,
+        NDVI: Union[Raster, np.ndarray] = None,
+        albedo: Union[Raster, np.ndarray] = None,
+        Rn: Union[Raster, np.ndarray] = None, 
+        SM: Union[Raster, np.ndarray] = None, 
+        method: str = DEFAULT_G_METHOD) -> Union[Raster, np.ndarray]:
+    """
+    The method estimates soil heat flux (G) as a function of time of day, net radiation (Rn), soil moisture (SM), 
+    surface temperature (ST_C), Normalized Difference Vegetation Index (NDVI), and albedo. The method used for 
+    calculation can be specified.
+
+    Parameters:
+    seconds_of_day (np.ndarray): Time in seconds of the day since midnight.
+    ST_C (np.ndarray): Surface temperature in Celsius.
+    NDVI (np.ndarray): Normalized Difference Vegetation Index.
+    albedo (np.ndarray): Albedo of the surface.
+    Rn (np.ndarray): Net radiation in W/m^2.
+    SM (np.ndarray): Soil moisture in m^3/m^3.
+    method (str, optional): Method to be used for calculation. Defaults to "santanello".
+
+    Returns:
+    G (np.ndarray): Soil heat flux in W/m^2.
+    """
+
+    # FIXME make sure G doesn't drop to extreme negative values
+
+    if method == "santanello":
+        G = santanello_G(
+            seconds_of_day=seconds_of_day,
+            Rn=Rn,
+            SM=SM
+        )
+    elif method == "SEBAL":
+        G = SEBAL_G(
+            Rn=Rn,
+            ST_C=ST_C,
+            NDVI=NDVI,
+            albedo=albedo
+        )
+    elif method == "MOD16":
+        G = (-0.276 * NDVI + 0.35) * Rn
+    elif method == "PTJPL":
+        G = rt.clip(Rn * (0.05 + (1 - rt.clip(NDVI, 0, 1)) * 0.265), 0, 0.35 * Rn)
+    else:
+        raise ValueError(f"invalid soil heat flux method: {method}")
+    
+    G = rt.clip(G, 0, None)
+
+    return G

PMJPL/soil_moisture_constraint.py

@@ -0,0 +1,19 @@
+import numpy as np
+from typing import Union
+from rasters import Raster
+
+from .constants import BETA
+
+def calculate_fSM(
+        RH: Union[Raster, np.ndarray],
+        VPD: Union[Raster, np.ndarray],
+        beta: float = BETA) -> Union[Raster, np.ndarray]:
+    """
+    This function calculates the soil moisture constraint for the JPL adaptation
+    of the Penman-Monteith MOD16 algorithm.
+    :param RH: relative humidity between zero and one
+    :param VPD: vapor pressure deficit in Pascal
+    :param beta: VPD factor in Pascal (MOD16 uses 200, but PT-JPL uses 1000)
+    :return: soil moisture constraint between zero and one
+    """
+    return RH ** (VPD / beta)

PMJPL/tmin_factor.py

@@ -0,0 +1,45 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+def calculate_tmin_factor(
+        Tmin: Union[Raster, np.ndarray],
+        tmin_open: Union[Raster, np.ndarray],
+        tmin_close: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Calculates the minimum temperature factor for MOD16 equations.
+
+    Args:
+        Tmin (Union[Raster, np.ndarray]): Minimum temperature in Celsius.
+        tmin_open (Union[Raster, np.ndarray]): Open minimum temperatures.
+        tmin_close (Union[Raster, np.ndarray]): Closed minimum temperatures.
+
+    Returns:
+        Union[Raster, np.ndarray]: Minimum temperature factor (mTmin).
+
+    Raises:
+        ValueError: If the input arrays have different shapes.
+
+    Notes:
+        The minimum temperature factor (mTmin) is calculated based on the following conditions:
+        - If Tmin is greater than or equal to tmin_open, mTmin is set to 1.0.
+        - If tmin_close is less than Tmin and Tmin is less than tmin_open, mTmin is calculated as
+          (Tmin - tmin_close) / (tmin_open - tmin_close).
+        - If Tmin is less than or equal to tmin_close, mTmin is set to 0.0.
+    """
+    # Calculate minimum temperature factor using queried open and closed minimum temperatures
+    mTmin = rt.where(Tmin >= tmin_open, 1.0, np.nan)
+
+    mTmin = rt.where(
+        rt.logical_and(
+            tmin_close < Tmin,
+            Tmin < tmin_open
+        ),
+        (Tmin - tmin_close) / (tmin_open - tmin_close),
+        mTmin
+    )
+
+    mTmin = rt.where(Tmin <= tmin_close, 0.0, mTmin)
+
+    return mTmin

PMJPL/transpiration.py

@@ -0,0 +1,44 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+from .constants import GAMMA_PA
+
+def calculate_transpiration(
+        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], 
+        ra: Union[Raster, np.ndarray], 
+        fwet: Union[Raster, np.ndarray], 
+        rs: Union[Raster, np.ndarray], 
+        gamma_Pa: Union[Raster, np.ndarray, float] = GAMMA_PA) -> Union[Raster, np.ndarray]:
+    """
+    Calculates the transpiration (LEc) using the Penman-Monteith equation.
+
+    Parameters:
+        delta_Pa (Union[Raster, np.ndarray]): slope of saturation vapor pressure curve in Pascal per degree Celsius
+        Ac (Union[Raster, np.ndarray]): available radiation to the canopy in watts per square meter
+        rho (Union[Raster, np.ndarray]): calculate air density in kilograms per cubic meter
+        Cp (Union[Raster, np.ndarray]): specific heat capacity of the air in joules per kilogram per kelvin
+        VPD_Pa (Union[Raster, np.ndarray]): vapor pressure deficit in Pascal
+        FVC (Union[Raster, np.ndarray]): fraction of vegetation cover
+        ra (Union[Raster, np.ndarray]): aerodynamic resistance (ra) in s/m.
+        fwet (Union[Raster, np.ndarray]): fraction of wet area (fwet).
+        rs (Union[Raster, np.ndarray]): surface resistance (rs) in s/m.
+        gamma_Pa (Union[Raster, np.ndarray, float], optional): psychrometric constant (gamma) in Pascal per degree Celsius
+
+    Returns:
+        Union[Raster, np.ndarray]: transpiration (LEc) in mm/day.
+    """
+    numerator = (delta_Pa * Ac + (rho * Cp * FVC * VPD_Pa / ra)) * (1.0 - fwet)
+    denominator = delta_Pa + gamma_Pa * (1.0 + (rs / ra))
+    LEc = numerator / denominator
+
+    # fill transpiration with zero
+    LEc = rt.where(rt.isnan(LEc), 0.0, LEc)
+
+    return LEc

PMJPL/vegetation_conversion/__init__.py

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

PMJPL/vegetation_conversion/vegetation_conversion.py

@@ -0,0 +1,47 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+KPAR = 0.5
+MIN_FIPAR = 0.0
+MAX_FIPAR = 1.0
+MIN_LAI = 0.0
+MAX_LAI = 10.0
+
+def FVC_from_NDVI(NDVI: Union[Raster, np.ndarray]) -> Union[Raster, np.ndarray]:
+    """
+    Convert Normalized Difference Vegetation Index (NDVI) to Fractional Vegetation Cover (FVC).
+
+    Parameters:
+        NDVI (Union[Raster, np.ndarray]): Input NDVI data.
+
+    Returns:
+        Union[Raster, np.ndarray]: Converted FVC data.
+    """
+    NDVIv = 0.52  # +- 0.03
+    NDVIs = 0.04  # +- 0.03
+    FVC = rt.clip((NDVI - NDVIs) / (NDVIv - NDVIs), 0.0, 1.0)
+
+    return FVC
+
+def LAI_from_NDVI(
+        NDVI: Union[Raster, np.ndarray],
+        min_fIPAR: float = MIN_FIPAR,
+        max_fIPAR: float = MAX_FIPAR,
+        min_LAI: float = MIN_LAI,
+        max_LAI: float = MAX_LAI) -> Union[Raster, np.ndarray]:
+    """
+    Convert Normalized Difference Vegetation Index (NDVI) to Leaf Area Index (LAI).
+
+    Parameters:
+        NDVI (Union[Raster, np.ndarray]): Input NDVI data.
+
+    Returns:
+        Union[Raster, np.ndarray]: Converted LAI data.
+    """
+    fIPAR = rt.clip(NDVI - 0.05, min_fIPAR, max_fIPAR)
+    fIPAR = np.where(fIPAR == 0, np.nan, fIPAR)
+    LAI = rt.clip(-np.log(1 - fIPAR) * (1 / KPAR), min_LAI, max_LAI)
+
+    return LAI

PMJPL/verma_net_radiation/__init__.py

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

PMJPL/verma_net_radiation/verma_net_radiation.py

@@ -0,0 +1,108 @@
+from typing import Union, Dict
+import warnings
+import numpy as np
+from sun_angles import daylight_from_SHA
+from sun_angles import sunrise_from_SHA
+from sun_angles import SHA_deg_from_DOY_lat
+from rasters import Raster
+
+STEFAN_BOLTZMAN_CONSTANT = 5.67036713e-8  # SI units watts per square meter per kelvin to the fourth
+
+
+def process_verma_net_radiation(
+        SWin: np.ndarray,
+        albedo: np.ndarray,
+        ST_C: np.ndarray,
+        emissivity: np.ndarray,
+        Ta_C: np.ndarray,
+        RH: np.ndarray,
+        cloud_mask: np.ndarray = None) -> Dict:
+    results = {}
+
+    # Convert surface temperature from Celsius to Kelvin
+    ST_K = ST_C + 273.15
+
+    # Convert air temperature from Celsius to Kelvin
+    Ta_K = Ta_C + 273.15
+
+    # Calculate water vapor pressure in Pascals using air temperature and relative humidity
+    Ea_Pa = (RH * 0.6113 * (10 ** (7.5 * (Ta_K - 273.15) / (Ta_K - 35.85)))) * 1000
+    
+    # constrain albedo between 0 and 1
+    albedo = np.clip(albedo, 0, 1)
+
+    # calculate outgoing shortwave from incoming shortwave and albedo
+    SWout = np.clip(SWin * albedo, 0, None)
+    results["SWout"] = SWout
+
+    # calculate instantaneous net radiation from components
+    SWnet = np.clip(SWin - SWout, 0, None)
+
+    # calculate atmospheric emissivity
+    eta1 = 0.465 * Ea_Pa / Ta_K
+    # atmospheric_emissivity = (1 - (1 + eta1) * np.exp(-(1.2 + 3 * eta1) ** 0.5))
+    eta2 = -(1.2 + 3 * eta1) ** 0.5
+    eta2 = eta2.astype(float)
+    eta3 = np.exp(eta2)
+    atmospheric_emissivity = np.where(eta2 != 0, (1 - (1 + eta1) * eta3), np.nan)
+
+    if cloud_mask is None:
+        # calculate incoming longwave for clear sky
+        LWin = atmospheric_emissivity * STEFAN_BOLTZMAN_CONSTANT * Ta_K ** 4
+    else:
+        # calculate incoming longwave for clear sky and cloudy
+        LWin = np.where(
+            ~cloud_mask,
+            atmospheric_emissivity * STEFAN_BOLTZMAN_CONSTANT * Ta_K ** 4,
+            STEFAN_BOLTZMAN_CONSTANT * Ta_K ** 4
+        )
+    
+    results["LWin"] = LWin
+
+    # constrain emissivity between 0 and 1
+    emissivity = np.clip(emissivity, 0, 1)
+
+    # calculate outgoing longwave from land surface temperature and emissivity
+    LWout = emissivity * STEFAN_BOLTZMAN_CONSTANT * ST_K ** 4
+    results["LWout"] = LWout
+
+    # LWnet = np.clip(LWin - LWout, 0, None)
+    LWnet = np.clip(LWin - LWout, 0, None)
+
+    # constrain negative values of instantaneous net radiation
+    Rn = np.clip(SWnet + LWnet, 0, None)
+    results["Rn"] = Rn
+
+    return results
+
+def daily_Rn_integration_verma(
+        Rn: Union[Raster, np.ndarray],
+        hour_of_day: Union[Raster, np.ndarray],
+        DOY: Union[Raster, np.ndarray] = None,
+        lat: Union[Raster, np.ndarray] = None,
+        sunrise_hour: Union[Raster, np.ndarray] = None,
+        daylight_hours: Union[Raster, np.ndarray] = None) -> Raster:
+    """
+    calculate daily net radiation using solar parameters
+    this is the average rate of energy transfer from sunrise to sunset
+    in watts per square meter
+    watts are joules per second
+    to get the total amount of energy transferred, factor seconds out of joules
+    the number of seconds for which this average is representative is (daylight_hours * 3600)
+    documented in verma et al, bisht et al, and lagouARDe et al
+    :param Rn:
+    :param hour_of_day:
+    :param sunrise_hour:
+    :param daylight_hours:
+    :return:
+    """
+    if daylight_hours is None or sunrise_hour is None and DOY is not None and lat is not None:
+        sha_deg = SHA_deg_from_DOY_lat(DOY=DOY, latitude=lat)
+        daylight_hours = daylight_from_SHA(sha_deg)
+        sunrise_hour = sunrise_from_SHA(sha_deg)
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore")
+        Rn_daily = 1.6 * Rn / (np.pi * np.sin(np.pi * (hour_of_day - sunrise_hour) / (daylight_hours)))
+    
+    return Rn_daily

PMJPL/wet_canopy_resistance.py

@@ -0,0 +1,21 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+from .constants import MIN_RESISTANCE, MAX_RESISTANCE
+
+def calculate_wet_canopy_resistance(
+        conductance: Union[Raster, np.ndarray], 
+        LAI: Union[Raster, np.ndarray], 
+        fwet: Union[Raster, np.ndarray],
+        min_resistance: float = MIN_RESISTANCE,
+        max_resistance: float = MAX_RESISTANCE) -> Union[Raster, np.ndarray]:
+    """
+    calculates wet canopy resistance.
+    :param conductance: leaf conductance to evaporated water vapor
+    :param LAI: leaf-area index
+    :param fwet: relative surface wetness
+    :return: wet canopy resistance
+    """
+    return rt.clip(1.0 / rt.clip(conductance * LAI * fwet, 1.0 / max_resistance, None), min_resistance, max_resistance)

PMJPL/wet_soil_evaporation.py

@@ -0,0 +1,36 @@
+from typing import Union
+import numpy as np
+from rasters import Raster
+
+from .constants import GAMMA_PA
+
+def calculate_wet_soil_evaporation(
+        delta_Pa: Union[Raster, np.ndarray], 
+        Asoil: Union[Raster, np.ndarray], 
+        rho: Union[Raster, np.ndarray], 
+        Cp: Union[Raster, np.ndarray], 
+        FVC: Union[Raster, np.ndarray], 
+        VPD: Union[Raster, np.ndarray], 
+        ras: Union[Raster, np.ndarray], 
+        fwet: Union[Raster, np.ndarray], 
+        rtot: Union[Raster, np.ndarray],
+        gamma_Pa: float = GAMMA_PA) -> Union[Raster, np.ndarray]:
+    """
+    MOD16 method for calculating wet soil evaporation
+    :param s: slope of the saturation to vapor pressure curve
+    :param Asoil: available radiation to the soil (soil partition of net radiation)
+    :param rho: air density in kilograms per cubic meter
+    :param Cp: specific humidity
+    :param fc: vegetation fraction
+    :param VPD: vapor pressure deficit
+    :param ras: aerodynamic resistance at the soil surface
+    :param fwet: relative surface wetness
+    :param rtot: total aerodynamic resistance
+    :param gamme: gamma constant (default: GAMMA)
+    :return: wet soil evaporation in watts per square meter
+    """
+    numerator = (delta_Pa * Asoil + rho * Cp * (1.0 - FVC) * VPD / ras) * fwet
+    denominator = delta_Pa + gamma_Pa * rtot / ras
+    LE_soil_wet = numerator / denominator
+
+    return LE_soil_wet

pm_jpl-1.2.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: PM-JPL
+Version: 1.2.0
+Summary: JPL implementation of the MOD16 evapotranspiration algorithm for high resolution instantaneous remote sensing imagery
+Author-email: Gregory Halverson <gregory.h.halverson@jpl.nasa.gov>, Qiaozhen Mu <qiaozhen@ntsg.umt.edu>, Maosheng Zhao <zhao@ntsg.umt.edu>, "Steven W. Running" <swr@ntsg.umt.edu>, "Claire S. Villanueva-Weeks" <claire.s.villanueva-weeks@jpl.gov>
+Project-URL: Homepage, https://github.com/JPL-Evapotranspiration-Algorithms/PM-JPL
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: affine
+Requires-Dist: astropy
+Requires-Dist: geopandas
+Requires-Dist: h5py
+Requires-Dist: keras
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: pillow
+Requires-Dist: pygeos
+Requires-Dist: pyproj
+Requires-Dist: pyresample
+Requires-Dist: rasterio
+Requires-Dist: rasters
+Requires-Dist: requests
+Requires-Dist: scikit-image
+Requires-Dist: scipy
+Requires-Dist: shapely
+Requires-Dist: six
+Requires-Dist: sun-angles
+Requires-Dist: tensorflow
+Requires-Dist: urllib3
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# JPL implementation of the MOD16 evapotranspiration remote sensing model
+
+[![CI](https://github.com/JPL-Evapotranspiration-Algorithms/MOD16-JPL/actions/workflows/ci.yml/badge.svg)](https://github.com/JPL-Evapotranspiration-Algorithms/MOD16-JPL/actions/workflows/ci.yml)
+
+The MODIS Global Evapotranspiration Project (MOD16) is a software package developed by a team of researchers from NASA Jet Propulsion Laboratory and the University of Montana. This software is a Python implementation of the MOD16 evapotranspiration algorithm, designed to process high-resolution instantaneous remote sensing imagery.
+
+Unique features of the software include the ability to process remote sensing data with the MOD16 model and partition latent heat flux into canopy transpiration, interception, and soil evaporation. The MOD16 algorithm has been re-implemented to run on instantaneous high spatial resolution remote sensing imagery instead of 8-day MODIS imagery, making the model more accessible for remote sensing researchers.
+
+The software is written entirely in Python and is intended to be distributed using the pip package manager.
+
+The software was developed as part of a research grant by the NASA Research Opportunities in Space and Earth Sciences (ROSES) program. It was designed for use by the Ecosystem Spaceborne Thermal Radiometer Experiment on Space Station (ECOSTRESS) mission as a precursor for the Surface Biology and Geology (SBG) mission. However, it may also be useful for general remote sensing and GIS projects in Python. This package can be utilized for remote sensing research in Jupyter notebooks and deployed for operations in data processing pipelines. 
+
+The software is being released according to the SPD-41 open-science requirements of NASA-funded ROSES projects.
+
+Gregory H. Halverson (they/them)<br>
+[gregory.h.halverson@jpl.nasa.gov](mailto:gregory.h.halverson@jpl.nasa.gov)<br>
+NASA Jet Propulsion Laboratory 329G
+
+Kanishka Mallick (he/him)<br>
+[kaniska.mallick@gmail.com](mailto:kaniska.mallick@gmail.com)<br>
+Luxembourg Institute of Science and Technology
+
+Claire Villanueva-Weeks (she/her)<br>
+[claire.s.villanueva-weeks@jpl.nasa.gov](mailto:claire.s.villanueva-weeks@jpl.nasa.gov)<br>
+NASA Jet Propulsion Laboratory 329G
+
+## Installation
+
+```
+pip install MOD16-JPL
+```
+
+## Usage
+
+```
+import MOD16_JPL
+```
+
+## References
+
+- Mu, Q., Zhao, M., & Running, S. W. (2011). Improvements to a MODIS global terrestrial evapotranspiration algorithm. *Remote Sensing of Environment*, 115(8), 1781-1800. doi:10.1016/j.rse.2011.02.019
+- Mu, Q., Heinsch, F. A., Zhao, M., & Running, S. W. (2007). Development of a global evapotranspiration algorithm based on MODIS and global meteorology data. *Remote Sensing of Environment*, 111(4), 519-536. doi:10.1016/j.rse.2007.04.015

pm_jpl-1.2.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+PMJPL/PMJPL.py,sha256=QXhLgqeOiLCFjtYHr_01hUfusVL_iOqeK_PXANeKdsU,12819
+PMJPL/VPD_factor.py,sha256=mEi3qXClc07QT2wlfCgzaFkERbm_D8JqWKmB86pJMVk,970
+PMJPL/__init__.py,sha256=rqFqtI2rLgIxSN3i2J8wZVoT2EpHYgVizfZt8ctwqsc,213
+PMJPL/canopy_aerodynamic_resistance.py,sha256=ejcmjGNimv2aja6WFRC_2D_48YD2fVHE3ndWHbGbxfM,1217
+PMJPL/canopy_conductance.py,sha256=1e2KwFGiRrXMJvG0iHwP3cpQ68HFB44eQ0CXsv1mQ-A,1367
+PMJPL/constants.py,sha256=Az7hftY_CIibJdvRdQcDisRdKqJYm8khktakCcNZtXU,787
+PMJPL/correctance_factor.py,sha256=V93rZcv5DM3LfujhEK8mRgJ-GHk868hDbTmcg8VoOAo,582
+PMJPL/fwet.py,sha256=-5GEGC1ohKBzsuYGLNiCaVe10DQLm82rsZTZGVxb4WY,616
+PMJPL/interception.py,sha256=lJ_kAa_Xkr21iWcVtSmLoNPfHEzCuiFSVRxB4-NUs9k,1689
+PMJPL/parameters.py,sha256=hiMXIafFkS4rqDQVvPhCFuiLc-WXTwlRyS-eIK9vQuk,1973
+PMJPL/potential_soil_evaporation.py,sha256=Xq-cvOqOa9W1FFHMmPKGtZs18tiDRUDOQ86-8rONO_Y,1823
+PMJPL/soil_moisture_constraint.py,sha256=URUGsE1_p2P1dVQ8qKRcKb93hahYWtAmYqoassRu-PI,667
+PMJPL/tmin_factor.py,sha256=BqSPM3Y8eB2fekSxUf9dzmAT_5UPNz0eY_wWnlvn1Xg,1595
+PMJPL/transpiration.py,sha256=8wxCsXURWabn8ARUDnekG3-igdygtlX9SgLrQu_RMaA,1980
+PMJPL/wet_canopy_resistance.py,sha256=q1RBq6SePklb-XLmv3zPbLX5rxtZ4uxvEecB9faJlyE,792
+PMJPL/wet_soil_evaporation.py,sha256=1lZ0qokBffZTCKuuh0M3jYtR2nbJyVLe15gFzXRlBU0,1416
+PMJPL/MCD12C1/MCD12C1.py,sha256=2zq6QW9SJGnADwbExZ7JvAaUcBrHeBSDiRS46RrumAY,378
+PMJPL/MCD12C1/__init__.py,sha256=4_gn1pQK9nuh7ZuUTFpaFhT6ypSvsIxBwIpOYmw5Vfg,23
+PMJPL/SEBAL/SEBAL.py,sha256=IBKKYbZzk0WOND6eRVdgTyqnsLriwOFECGBKIf0nOFk,1688
+PMJPL/SEBAL/__init__.py,sha256=IK_eHynpUb_XvECuLOfE0h3Js-4vdeXqCEe9y5oeKWw,21
+PMJPL/downscaling/__init__.py,sha256=xvhP4rHzx-nK_R6HSarJ-WF1bMPXYZGvvr8Hk84-q40,27
+PMJPL/downscaling/downscaling.py,sha256=VuhFbK92llJbtkOtJpah_51sM5ctFJ9oNUaH4aaNO7g,8447
+PMJPL/downscaling/linear_downscale.py,sha256=Yi0d2rb1XVSlBJoL2Arq9RtU5FH1RJ98MHLngJIYUjM,2466
+PMJPL/evapotranspiration_conversion/__init__.py,sha256=21wYXP8FJT63MpUTbHu0wGntyFFeiGDRneGMKCNAu8Q,45
+PMJPL/evapotranspiration_conversion/evapotranspiration_conversion.py,sha256=kwxLb_Vli_Tfal4lWBHMkEMmpCV7Kha_0wgqk8HjlXs,2754
+PMJPL/meteorology_conversion/__init__.py,sha256=dLF40imqJCC_l8_QMetbsj1YzkXZuFt9tQ2fsd7Wcdw,38
+PMJPL/meteorology_conversion/meteorology_conversion.py,sha256=8vzx71FLLNhR5v6EQBL8OSgAmupQcgdLX2c9tL9TPxA,4202
+PMJPL/penman_monteith/__init__.py,sha256=vcfkNo6BLDCfSF9HZFDvRMAKCx49F9idN7iNTKQCpcA,31
+PMJPL/penman_monteith/penman_monteith.py,sha256=2rSFP9_DBz1vMSbVyBQGhW-VXXb5XT8a7ls8sCstfXU,819
+PMJPL/priestley_taylor/__init__.py,sha256=E0SiG_DNAsMz_8A3342UPwbDyrMOgd35AZ-plaJar5s,32
+PMJPL/priestley_taylor/priestley_taylor.py,sha256=Rj168jfWHSBhGeUkDs6ePrVsHhFbmUujzQaA8z0fCXE,1126
+PMJPL/santanello/__init__.py,sha256=HXZS1p3sp4mDJCXkdq___ZIJ9etu7-B8yauJcFvQFgQ,26
+PMJPL/santanello/santanello.py,sha256=lvgskYrirQz0t1m4XNSj8hLzrESS-oVZzMvAnVPyt3g,1521
+PMJPL/soil_heat_flux/__init__.py,sha256=bES8bWQhwRLmyJPsaFB190yiuz2mHyJM1X8Q1KbwwEE,30
+PMJPL/soil_heat_flux/soil_heat_flux.py,sha256=wg5h6FmIxGFYDFRyQ_0D3GaL5PIiYonuz8u4o8MPaKw,2092
+PMJPL/vegetation_conversion/__init__.py,sha256=8gnz0yK_euCV0TtVGDrSGaVfx4g0EJCG2J68ppuA5oc,37
+PMJPL/vegetation_conversion/vegetation_conversion.py,sha256=-K3FLV6pXkpxtRxQvimqqkXAgkn9mUUlHQ8FIscq1Zg,1306
+PMJPL/verma_net_radiation/__init__.py,sha256=5TzlqNWajiVxbQdUqjWuu17oBrTmjIeaF40nQPnVzWo,35
+PMJPL/verma_net_radiation/verma_net_radiation.py,sha256=Y4OxcuBXTY6IZzZ6cXjxp2xTyeSAfYQ_itws0PcSc-I,3869
+pm_jpl-1.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pm_jpl-1.2.0.dist-info/METADATA,sha256=EDovChaM_otgcmd2JGV-SQxwjvLrKKbUgd6TZz1GufY,4260
+pm_jpl-1.2.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pm_jpl-1.2.0.dist-info/top_level.txt,sha256=YaAFwdYHUxfUW08hiuFquUEdDGrsYn1duuMMjJKh0Ws,6
+pm_jpl-1.2.0.dist-info/RECORD,,

pm_jpl-1.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+