PM-JPL 1.2.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

PMJPL/downscaling/downscaling.py

@@ -1,271 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

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

PMJPL/evapotranspiration_conversion/evapotranspiration_conversion.py

@@ -1,80 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/meteorology_conversion/__init__.py

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

PMJPL/meteorology_conversion/meteorology_conversion.py

@@ -1,123 +0,0 @@
-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/penman_monteith/__init__.py

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

PMJPL/penman_monteith/penman_monteith.py

@@ -1,20 +0,0 @@
-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

PMJPL/priestley_taylor/__init__.py

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

PMJPL/priestley_taylor/priestley_taylor.py

@@ -1,27 +0,0 @@
-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

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

PMJPL/santanello/santanello.py

@@ -1,46 +0,0 @@
-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

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