STIC-JPL 1.6.0__py3-none-any.whl

STIC_JPL/ECOv002_calval_STIC_inputs.py

@@ -0,0 +1,19 @@
+import os
+import pandas as pd
+
+def load_ECOv002_calval_STIC_inputs() -> pd.DataFrame:
+    """
+    Load the input data for the STIC model from the ECOSTRESS Collection 2 Cal-Val dataset.
+
+    Returns:
+        pd.DataFrame: A DataFrame containing the input data.
+    """
+
+    # Define the path to the input CSV file relative to this module's directory
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    input_file_path = os.path.join(module_dir, "ECOv002-cal-val-STIC-JPL-inputs.csv")
+
+    # Load the input data into a DataFrame
+    inputs_df = pd.read_csv(input_file_path)
+
+    return inputs_df

STIC_JPL/FVC_from_NDVI.py

@@ -0,0 +1,49 @@
+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]:
+    """
+    Estimate Fractional Vegetation Cover (FVC) from Normalized Difference Vegetation Index (NDVI)
+    using a scaled NDVI approach.
+
+    This method linearly scales NDVI values between two endmembers:
+        - NDVIs: NDVI value for bare soil (typically ~0.04 ± 0.03)
+        - NDVIv: NDVI value for full vegetation (typically ~0.52 ± 0.03)
+
+    The resulting Fractional Vegetation Cover (FVC) is calculated as:
+
+        FVC = clip((NDVI - NDVIs) / (NDVIv - NDVIs), 0.0, 1.0)
+
+    This approach is based on the assumption that NDVI increases linearly with vegetation cover
+    between these two extremes, and is well-supported in the literature.
+
+    References:
+        Carlson, T. N., & Ripley, D. A. (1997). On the relation between NDVI, fractional vegetation cover,
+        and leaf area index. Remote Sensing of Environment, 62(3), 241–252.
+        https://doi.org/10.1016/S0034-4257(97)00104-1
+
+        Gutman, G., & Ignatov, A. (1998). The derivation of the green vegetation fraction from NOAA/AVHRR
+        data for use in numerical weather prediction models. International Journal of Remote Sensing,
+        19(8), 1533–1543. https://doi.org/10.1080/014311698215333
+
+    Parameters:
+        NDVI (Union[Raster, np.ndarray]): Input NDVI data.
+
+    Returns:
+        Union[Raster, np.ndarray]: Estimated Fractional Vegetation Cover (FVC).
+    """
+    NDVIv = 0.52  # NDVI for fully vegetated pixel
+    NDVIs = 0.04  # NDVI for bare soil pixel
+
+    # Scale NDVI to FVC using a linear model and clip to [0, 1]
+    FVC = rt.clip((NDVI - NDVIs) / (NDVIv - NDVIs), 0.0, 1.0)
+
+    return FVC

STIC_JPL/LAI_from_NDVI.py

@@ -0,0 +1,61 @@
+from typing import Union
+import numpy as np
+import rasters as rt
+from rasters import Raster
+
+# Constants
+KPAR = 0.5  # Extinction coefficient for PAR, assumed average for broadleaf canopies (Weiss & Baret, 2010)
+MIN_FIPAR = 0.0
+MAX_FIPAR = 1.0
+MIN_LAI = 0.0
+MAX_LAI = 10.0
+
+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]:
+    """
+    Estimate Leaf Area Index (LAI) from NDVI using a simplified two-step empirical model.
+
+    This method first approximates the fraction of absorbed photosynthetically active radiation (fIPAR)
+    from NDVI, and then estimates LAI using the Beer–Lambert Law. The extinction coefficient for PAR (KPAR)
+    is assumed to be 0.5, which is typical for broadleaf canopies under diffuse light conditions.
+
+    Steps:
+    1. fIPAR ≈ NDVI - 0.05 (empirical offset to account for soil background and sensor noise)
+       - Based on observed relationships in Myneni & Williams (1994)
+    2. LAI = -ln(1 - fIPAR) / KPAR (Beer–Lambert Law)
+       - From Sellers (1985)
+
+    All outputs are clipped to user-defined minimum and maximum thresholds to ensure physical realism.
+
+    Parameters:
+        NDVI (Union[Raster, np.ndarray]): Input NDVI data.
+        min_fIPAR (float): Minimum fIPAR value for clipping (default 0.0).
+        max_fIPAR (float): Maximum fIPAR value for clipping (default 1.0).
+        min_LAI (float): Minimum LAI value for clipping (default 0.0).
+        max_LAI (float): Maximum LAI value for clipping (default 10.0).
+
+    Returns:
+        Union[Raster, np.ndarray]: Estimated LAI values.
+
+    References:
+        - Sellers, P. J. (1985). Canopy reflectance, photosynthesis and transpiration. 
+          *International Journal of Remote Sensing*, 6(8), 1335–1372.
+        - Myneni, R. B., & Williams, D. L. (1994). On the relationship between FAPAR and NDVI. 
+          *Remote Sensing of Environment*, 49(3), 200–211.
+        - Weiss, M., & Baret, F. (2010). CAN-EYE V6.1 User Manual. INRA-CSE.
+
+    """
+    # Empirical conversion from NDVI to fIPAR (adjusted for background noise)
+    fIPAR = rt.clip(NDVI - 0.05, min_fIPAR, max_fIPAR)
+
+    # Avoid division by zero or log of 0 by masking zero fIPAR values
+    fIPAR = np.where(fIPAR == 0, np.nan, fIPAR)
+
+    # Apply Beer–Lambert law to estimate LAI
+    LAI = rt.clip(-np.log(1 - fIPAR) * (1 / KPAR), min_LAI, max_LAI)
+
+    return LAI

STIC_JPL/STIC_JPL.py

@@ -0,0 +1,5 @@
+from .model import *
+from .generate_STIC_inputs import generate_STIC_inputs
+from .process_STIC_table import process_STIC_table
+from .verify import verify
+from .ECOv002_calval_STIC_inputs import load_ECOv002_calval_STIC_inputs

STIC_JPL/__init__.py

@@ -0,0 +1,4 @@
+from .STIC_JPL import *
+from .version import __version__
+
+__author__ = "Gregory H. Halverson"

STIC_JPL/canopy_air_stream.py

@@ -0,0 +1,37 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+
+from rasters import Raster
+
+from .constants import *
+
+def calculate_canopy_air_stream_vapor_pressure(
+        LE: Union[Raster, np.ndarray],  # Latent heat flux [W/m^2]
+        Ea_hPa: Union[Raster, np.ndarray],  # Actual vapor pressure [hPa]
+        Estar: Union[Raster, np.ndarray],  # Saturation vapor pressure [hPa]
+        gB: Union[Raster, np.ndarray],  # Conductance of boundary layer [mol/m^2/s]
+        gS: Union[Raster, np.ndarray],  # Conductance of stomata [mol/m^2/s]
+        rho_kgm3: Union[Raster, np.ndarray, float] = RHO_KGM3,  # Air density (kg/m^3)
+        Cp_Jkg: Union[Raster, np.ndarray, float] = CP_JKG,  # Specific heat at constant pressure (J/kg/K)
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA,  # Psychrometric constant (hPa/°C)
+    ) -> Union[Raster, np.ndarray]:
+    """
+    Calculate the canopy air stream vapor pressure.
+
+    Parameters:
+        LE (Union[Raster, np.ndarray]): Latent heat flux [W/m^2]
+        Ea_hPa (Union[Raster, np.ndarray]): Actual vapor pressure [hPa]
+        Estar (Union[Raster, np.ndarray]): Saturation vapor pressure [hPa]
+        gB (Union[Raster, np.ndarray]): Conductance of boundary layer [mol/m^2/s]
+        gS (Union[Raster, np.ndarray]): Conductance of stomata [mol/m^2/s]
+
+    Returns:
+        Union[Raster, np.ndarray]: The calculated canopy air stream vapor pressure [hPa]
+    """
+    e0star = Ea_hPa + (gamma_hPa * LE * (gB + gS)) / (rho_kgm3 * Cp_Jkg * gB * gS)
+    e0star = rt.where(e0star < 0, Estar, e0star)
+    e0star = rt.where(e0star > 250, Estar, e0star)
+
+    return e0star

STIC_JPL/celcius_to_kelvin.py

@@ -0,0 +1,11 @@
+from typing import Union
+import numpy as np
+from rasters import Raster
+
+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

STIC_JPL/closure.py

@@ -0,0 +1,68 @@
+from typing import Union, Tuple
+import numpy as np
+
+import rasters as rt
+
+from rasters import Raster
+
+from .constants import *
+
+def STIC_closure(
+        delta_hPa: Union[Raster, np.ndarray],  # Slope of the saturation vapor pressure-temperature curve (hPa/°C)
+        phi_Wm2: Union[Raster, np.ndarray],  # available energy (W/m^2)
+        Es_hPa: Union[Raster, np.ndarray],  # Vapor pressure at the reference height (hPa)
+        Ea_hPa: Union[Raster, np.ndarray],  # Actual vapor pressure (hPa)
+        Estar_hPa: Union[Raster, np.ndarray],  # Saturation vapor pressure at the reference height (hPa)
+        SM: Union[Raster, np.ndarray],  # Soil moisture (m³/m³)
+        gamma_hPa: float = GAMMA_HPA,  # Psychrometric constant (hPa/°C)
+        rho_kgm3: float = RHO_KGM3,  # Air density (kg/m³)
+        Cp_Jkg: float = CP_JKG,  # Specific heat capacity of air (J/kg/°C)
+        alpha: float = PT_ALPHA  # Priestley-Taylor alpha
+    ) -> Tuple[Union[Raster, np.ndarray]]:
+    """
+    STIC closure equations with modified Priestley Taylor and Penman Monteith
+    (Mallick et al., 2015, Water Resources research)
+
+    Parameters:
+    delta (np.ndarray): Slope of the saturation vapor pressure-temperature curve (hPa/°C)
+    phi (np.ndarray): available energy (W/m^2)
+    Es (np.ndarray): Vapor pressure at the reference height (hPa)
+    Ea (np.ndarray): Actual vapor pressure (hPa)
+    Estar (np.ndarray): Saturation vapor pressure at the reference height (hPa)
+    SM (np.ndarray): Soil moisture (m³/m³)
+    rho (float, optional): Air density (kg/m³). Defaults to RHO.
+    cp (float, optional): Specific heat capacity of air (J/kg/°C). Defaults to CP.
+    gamma (float, optional): Psychrometric constant (hPa/°C). Defaults to GAMMA.
+    alpha (float, optional): Stability correction factor for conductance. Defaults to ALPHA.
+
+    Returns:
+    gB (np.ndarray): boundary layer conductance (m s^-1)
+    gS (np.ndarray): stomatal conductance (m s^-1)
+    dT (np.ndarray): difference between surface and air temperature
+    EF (np.ndarray): evaporative fraction
+    """
+
+    epsilon = 1e-8  # Small value to prevent division by zero
+
+    # boundary layer conductance (m s^-1)
+    gB_den = (2 * Cp_Jkg * delta_hPa * Es_hPa * rho_kgm3 - 2 * Cp_Jkg * delta_hPa * Ea_hPa * rho_kgm3 - 2 * Cp_Jkg * Ea_hPa * gamma_hPa * rho_kgm3 + Cp_Jkg * Es_hPa * gamma_hPa * rho_kgm3 + Cp_Jkg * Estar_hPa * gamma_hPa * rho_kgm3 - Cp_Jkg * SM * Es_hPa * gamma_hPa * rho_kgm3 + Cp_Jkg * SM * Estar_hPa * gamma_hPa * rho_kgm3)
+    gB = ((2 * phi_Wm2 * alpha * delta_hPa * gamma_hPa) / (gB_den + epsilon))
+    gB = rt.clip(gB, 0.0001, 0.2)
+
+    # stomatal conductance (m s^-1)
+    gS_den = (Cp_Jkg * Estar_hPa ** 2 * gamma_hPa * rho_kgm3 - Cp_Jkg * Es_hPa ** 2 * gamma_hPa * rho_kgm3 - 2 * Cp_Jkg * delta_hPa * Es_hPa ** 2 * rho_kgm3 + 2 * Cp_Jkg * delta_hPa * Ea_hPa * Es_hPa * rho_kgm3 - 2 * Cp_Jkg * delta_hPa * Ea_hPa * Estar_hPa * rho_kgm3 + 2 * Cp_Jkg * delta_hPa * Es_hPa * Estar_hPa * rho_kgm3 + 2 * Cp_Jkg * Ea_hPa * Es_hPa * gamma_hPa * rho_kgm3 - 2 * Cp_Jkg * Ea_hPa * Estar_hPa * gamma_hPa * rho_kgm3 + Cp_Jkg * SM * Es_hPa ** 2 * gamma_hPa * rho_kgm3 + Cp_Jkg * SM * Estar_hPa ** 2 * gamma_hPa * rho_kgm3 - 2 * Cp_Jkg * SM * Es_hPa * Estar_hPa * gamma_hPa * rho_kgm3)
+    gS = (-(2 * (phi_Wm2 * alpha * delta_hPa * Ea_hPa * gamma_hPa - phi_Wm2 * alpha * delta_hPa * Es_hPa * gamma_hPa)) / (gS_den + epsilon))
+    gS = rt.clip(gS, 0.0001, 0.2)
+
+    # difference between surface and air temperature (Celsius)
+    dT_num = (2 * delta_hPa * Es_hPa - 2 * delta_hPa * Ea_hPa - 2 * Ea_hPa * gamma_hPa + Es_hPa * gamma_hPa + Estar_hPa * gamma_hPa - SM * Es_hPa * gamma_hPa + SM * Estar_hPa * gamma_hPa + 2 * alpha * delta_hPa * Ea_hPa - 2 * alpha * delta_hPa * Es_hPa)
+    dT_den = (2 * alpha * delta_hPa * gamma_hPa)
+    dT = dT_num / (dT_den + epsilon)
+    dT = rt.clip(dT, -10, 50)
+
+    # evaporative fraction
+    EF_den = (2 * delta_hPa * Es_hPa - 2 * delta_hPa * Ea_hPa - 2 * Ea_hPa * gamma_hPa + Es_hPa * gamma_hPa + Estar_hPa * gamma_hPa - SM * Es_hPa * gamma_hPa + SM * Estar_hPa * gamma_hPa)
+    EF = -(2 * alpha * delta_hPa * Ea_hPa - 2 * alpha * delta_hPa * Es_hPa) / (EF_den + epsilon)
+    EF = rt.clip(EF, 0, 1)
+
+    return gB, gS, dT, EF

STIC_JPL/constants.py

@@ -0,0 +1,31 @@
+from matplotlib.colors import LinearSegmentedColormap
+
+RESAMPLING = "cubic"
+CONSTRAIN_NEGATIVE_LE = False
+SUPPLY_SWIN = False
+UPSCALE_TO_DAYLIGHT = False
+
+RHO_KGM3 = 1.2  # Air density (kg m-3)
+CP_JKG = 1013  # Specific heat of air at constant pressure (J/kg/K)
+GAMMA_HPA = 0.67  # Psychrometric constant (hpa/K)
+PT_ALPHA = 1.26  # Priestley-Taylor coefficient
+SB_SIGMA = 5.67e-8  # Stefann Boltzmann constant
+DEFAULT_G_METHOD = "santanello"
+LE_CONVERGENCE_TARGET_WM2 = 2.0
+MAX_ITERATIONS = 30
+USE_VARIABLE_ALPHA = True
+SHOW_DISTRIBUTIONS = True
+
+ET_COLORMAP = LinearSegmentedColormap.from_list("ET", [
+    "#f6e8c3",
+    "#d8b365",
+    "#99974a",
+    "#53792d",
+    "#6bdfd2",
+    "#1839c5"
+])
+
+GEOS5FP_INPUTS = [
+    "Ta_C",
+    "RH"
+]

STIC_JPL/exceptions.py

@@ -0,0 +1,3 @@
+class MissingOfflineParameter(Exception):
+    """Raised when an expected offline parameter is missing."""
+    pass

STIC_JPL/generate_STIC_inputs.py

@@ -0,0 +1,65 @@
+import logging
+
+import numpy as np
+from dateutil import parser
+from pandas import DataFrame
+from rasters import Point
+from sentinel_tiles import sentinel_tiles
+from solar_apparent_time import UTC_to_solar
+from SEBAL_soil_heat_flux import calculate_SEBAL_soil_heat_flux
+
+from .model import STIC_JPL, MAX_ITERATIONS, USE_VARIABLE_ALPHA
+
+logger = logging.getLogger(__name__)
+
+def generate_STIC_inputs(STIC_inputs_from_calval_df: DataFrame) -> DataFrame:
+    """
+    STIC_inputs_from_claval_df:
+        Pandas DataFrame containing the columns: tower, lat, lon, time_UTC, albedo, elevation_km
+    return:
+        Pandas DataFrame containing the columns: tower, lat, lon, time_UTC, doy, albedo, elevation_km, AOT, COT, vapor_gccm, ozone_cm, SZA, KG
+    """
+    # output_rows = []
+    STIC_inputs_df = STIC_inputs_from_calval_df.copy()
+
+    hour_of_day = []
+    doy = []
+    Topt = []
+    fAPARmax = []
+
+    for i, input_row in STIC_inputs_from_calval_df.iterrows():
+        tower = input_row.tower
+        lat = input_row.lat
+        lon = input_row.lon
+        time_UTC = input_row.time_UTC
+        albedo = input_row.albedo
+        elevation_km = input_row.elevation_km
+        logger.info(f"collecting STIC inputs for tower {tower} lat {lat} lon {lon} time {time_UTC} UTC")
+        time_UTC = parser.parse(str(time_UTC))
+        time_solar = UTC_to_solar(time_UTC, lon)
+        hour_of_day.append(time_solar.hour)
+        doy.append(time_UTC.timetuple().tm_yday)
+        date_UTC = time_UTC.date()
+        tile = sentinel_tiles.toMGRS(lat, lon)[:5]
+        tile_grid = sentinel_tiles.grid(tile=tile, cell_size=70)
+        rows, cols = tile_grid.shape
+        row, col = tile_grid.index_point(Point(lon, lat))
+        geometry = tile_grid[max(0, row - 1):min(row + 2, rows - 1),
+                             max(0, col - 1):min(col + 2, cols - 1)]
+    
+    if not "hour_of_day" in STIC_inputs_df.columns:
+        STIC_inputs_df["hour_of_day"] = hour_of_day
+
+    if not "doy" in STIC_inputs_df.columns:
+        STIC_inputs_df["doy"] = doy
+    
+    if not "Topt" in STIC_inputs_df.columns:
+        STIC_inputs_df["Topt"] = Topt
+    
+    if not "fAPARmax" in STIC_inputs_df.columns:
+        STIC_inputs_df["fAPARmax"] = fAPARmax
+    
+    if "Ta" in STIC_inputs_df and "Ta_C" not in STIC_inputs_df:
+        STIC_inputs_df.rename({"Ta": "Ta_C"}, inplace=True)
+    
+    return STIC_inputs_df

STIC_JPL/initialize_with_solar.py

@@ -0,0 +1,80 @@
+from typing import Union, Tuple
+import numpy as np
+
+import rasters as rt
+
+from rasters import Raster
+
+from SEBAL_soil_heat_flux import calculate_SEBAL_soil_heat_flux
+
+from .constants import *
+from .soil_moisture_initialization import initialize_soil_moisture
+from .net_radiation import calculate_net_longwave_radiation
+
+
+def initialize_with_solar(
+        seconds_of_day: Union[Raster, np.ndarray],  # time of day in seconds since midnight
+        Rg_Wm2: Union[Raster, np.ndarray],  # solar radiation (W/m^2)
+        Rn_Wm2: Union[Raster, np.ndarray],  # net radiation (W/m^2)
+        ST_C: Union[Raster, np.ndarray],  # surface temperature (Celsius)
+        emissivity: Union[Raster, np.ndarray],  # emissivity of the surface
+        Ta_C: Union[Raster, np.ndarray],  # air temperature (Celsius)
+        dTS_C: Union[Raster, np.ndarray],  # surface air temperature difference (Celsius)
+        Td_C: Union[Raster, np.ndarray],  # dew point temperature (Celsius)
+        VPD_hPa: Union[Raster, np.ndarray],  # vapor pressure deficit (hPa)
+        SVP_hPa: Union[Raster, np.ndarray],  # saturation vapor pressure at given air temperature (hPa)
+        Ea_hPa: Union[Raster, np.ndarray],  # actual vapor pressure at air temperature (hPa)
+        Estar_hPa: Union[Raster, np.ndarray],  # saturation vapor pressure at surface temperature (hPa)
+        delta_hPa: Union[Raster, np.ndarray],  # slope of saturation vapor pressure to air temperature (hpa/K)
+        NDVI: Union[Raster, np.ndarray],  # normalized difference vegetation index
+        FVC: Union[Raster, np.ndarray],  # fractional vegetation cover
+        LAI: Union[Raster, np.ndarray],  # leaf area index
+        albedo: Union[Raster, np.ndarray],  # albedo of the surface
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA,  # psychrometric constant (hPa/°C)
+        G_method: str = DEFAULT_G_METHOD  # method for calculating soil heat flux
+    ) -> Tuple[Union[Raster, np.ndarray]]:
+    # Rn SOIL
+    kRN = 0.6
+    Rn_soil = Rn_Wm2 * np.exp(-kRN * LAI)
+
+    LWnet = calculate_net_longwave_radiation(
+        Ta_C=Ta_C, 
+        Ea_hPa=Ea_hPa, 
+        ST_C=ST_C, 
+        emissivity=emissivity, 
+        albedo=albedo
+    )
+    
+    # initialize soil moisture
+    SM, SMrz, Ms, Ep_PT, Ds, s1, s3, Tsd_C = initialize_soil_moisture(
+        delta_hPa=delta_hPa,  # slope of saturation vapor pressure to air temperature (hpa/K)
+        ST_C=ST_C,  # surface temperature (Celsius)
+        Ta_C=Ta_C,  # air temperature (Celsius)
+        Td_C=Td_C,  # dew point temperature (Celsius)
+        dTS=dTS_C,  # surface air temperature difference (Celsius)
+        Rn_Wm2=Rn_Wm2,  # net radiation (W/m^2)
+        LWnet_Wm2=LWnet,  # net longwave radiation (W/m^2)
+        FVC=FVC,  # fractional vegetation cover
+        VPD_hPa=VPD_hPa,  # vapor pressure deficit (hPa)
+        SVP_hPa=SVP_hPa,  # saturation vapor pressure at given air temperature (hPa)
+        Ea_hPa=Ea_hPa,  # actual vapor pressure at air temperature (hPa)
+        Estar_hPa=Estar_hPa,  # saturation vapor pressure at surface temperature (hPa)
+        gamma_hPa=gamma_hPa # psychrometric constant (hPa/°C)
+    )
+
+    # calculate soil heat flux
+    G = calculate_SEBAL_soil_heat_flux(
+        ST_C=ST_C,  # Surface temperature in Celsius
+        NDVI=NDVI,  # Normalized Difference Vegetation Index
+        albedo=albedo,  # Albedo of the surface
+        Rn=Rn_Wm2  # Net radiation (W/m^2)
+    )
+
+    # get phi with new comp
+    phi = Rn_Wm2 - G
+
+    Es = rt.where((Ep_PT > phi) & (dTS_C > 0) & (Td_C <= 0), Ea_hPa + SMrz * (Estar_hPa - Ea_hPa),
+                    Ea_hPa + Ms * (Estar_hPa - Ea_hPa))
+    
+    # Return all the created variables
+    return SM, SMrz, Ms, s1, s3, Ep_PT, Rn_soil, LWnet, G, Tsd_C, Ds, Es, phi

STIC_JPL/initialize_without_solar.py

@@ -0,0 +1,85 @@
+from typing import Union, Tuple
+import numpy as np
+
+import rasters as rt
+from rasters import Raster
+
+from .constants import *
+
+def initialize_without_solar(
+            ST_C: Union[Raster, np.ndarray],  # Surface temperature in Celsius
+            Ta_C: Union[Raster, np.ndarray],  # Air temperature in Celsius
+            dTS: Union[Raster, np.ndarray],  # Temperature difference between surface and air in Celsius
+            Td_C: Union[Raster, np.ndarray],  # Dewpoint temperature in Celsius
+            Ea_hPa: Union[Raster, np.ndarray],  # Actual vapor pressure in hPa
+            Estar_hPa: Union[Raster, np.ndarray],  # Saturation vapor pressure at surface temperature in hPa
+            SVP_hPa: Union[Raster, np.ndarray],  # Saturation vapor pressure at the surface in hPa
+            delta_hPa: Union[Raster, np.ndarray],  # Slope of the saturation vapor pressure-temperature curve in hPa
+            phi_Wm2: Union[Raster, np.ndarray],  # Available energy in W/m2
+            gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA,  # Psychrometric constant in hPa/°C
+            alpha: Union[Raster, np.ndarray, float] = PT_ALPHA  # Priestley-Taylor alpha
+      ) -> Tuple[Union[Raster, np.ndarray]]:
+      """
+      Initializes the variables related to moisture and vapor pressure without considering solar radiation.
+
+      Parameters:
+          ST_C (np.ndarray): Surface temperature in Celsius.
+          Ta_C (np.ndarray): Air temperature in Celsius.
+          dTS (np.ndarray): Temperature difference between surface and air in Celsius.
+          Td_C (np.ndarray): Dewpoint temperature in Celsius.
+          Ea_hPa (np.ndarray): Actual vapor pressure in hPa.
+          Estar (np.ndarray): saturation vapor pressure at surface temperature (hPa/K)
+          SVP_hPa (np.ndarray): Saturation vapor pressure at the surface in hPa.
+          delta (np.ndarray): Slope of the saturation vapor pressure-temperature curve in hPa/K.
+          phi (np.ndarray): available energy in W/m2.
+
+      Returns:
+          Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+              - SM (np.ndarray): Soil moisture.
+              - SMrz (np.ndarray): Rootzone moisture.
+              - s1 (np.ndarray): Slope of saturation vapor pressure and dewpoint temperature.
+              - s3 (np.ndarray): Slope of saturation vapor pressure and temperature.
+              - s33 (np.ndarray): Slope of saturation vapor pressure and surface temperature.
+              - s44 (np.ndarray): s44    
+              - Ms (np.ndarray): Surface moisture.
+              - Tsd_C (np.ndarray): Surface dewpoint temperature in Celsius.
+              - Es (np.ndarray): Surface vapor pressure in hPa.
+              - Ds (np.ndarray): Vapor pressure deficit at the surface.
+      """
+      s33 = (45.03 + 3.014 * ST_C + 0.05345 * ST_C ** 2 + 0.00224 * ST_C ** 3) * 1e-2  # hpa/K
+      s1 = (45.03 + 3.014 * Td_C + 0.05345 * Td_C ** 2 + 0.00224 * Td_C ** 3) * 1e-2  # hpa/K
+      
+      # Surface dewpoint (Celsius)
+      Tsd_C = ((Estar_hPa - Ea_hPa) - (s33 * ST_C) + (s1 * Td_C)) / (s1 - s33)
+      
+      # slope of saturation vapor pressure and temperature
+      s3 = rt.where((dTS > -20) & (dTS < 5), (Estar_hPa - Ea_hPa) / (ST_C - Td_C),
+            (45.03 + 3.014 * ST_C + 0.05345 * ST_C ** 2 + 0.00224 * ST_C ** 3) * 1e-2)  # hpa/K
+      
+      # Surface Moisture (Ms)
+      # Surface wetness
+      Ms = (s1 / s3) * ((Tsd_C - Td_C) / (ST_C - Td_C))
+      Ms = rt.clip(rt.where((dTS < 0) & (Ms < 0) & (phi_Wm2 < 0), np.abs(Ms), Ms), 0, 1)
+
+      # Rootzone Moisture (Mrz)
+      s44 = (SVP_hPa - Ea_hPa) / (Ta_C - Td_C)
+      SMrz = (gamma_hPa * s1 * (Tsd_C - Td_C)) / (
+            delta_hPa * s3 * (ST_C - Td_C) + gamma_hPa * s44 * (Ta_C - Td_C) - delta_hPa * s1 * (
+            Tsd_C - Td_C))  # rootzone wetness
+      SMrz = rt.clip(rt.where((dTS < 0) & (SMrz < 0) & (phi_Wm2 < 0), np.abs(SMrz), SMrz), 0, 1)
+
+      # now the limits of both Ms and Mrz are consistent
+      # combine M to account for Hysteresis and initial estimation of surface vapor pressure
+      # Potential evaporation (Priestley-Taylor eqn.)
+      Ep_PT = (alpha * delta_hPa * phi_Wm2) / (delta_hPa + gamma_hPa)
+      Es = rt.where((Ep_PT > phi_Wm2) & (dTS > 0) & (Td_C <= 0), Ea_hPa + SMrz * (Estar_hPa - Ea_hPa),
+            Ea_hPa + Ms * (Estar_hPa - Ea_hPa))
+
+      # soil moisture
+      SM = rt.where((Ep_PT > phi_Wm2) & (dTS > 0) & (Td_C <= 0), SMrz, Ms)
+
+      # hysteresis logic
+      # vapor pressure deficit at surface (Ds is later replaced by D0)
+      Ds = (Estar_hPa - Es)
+
+      return SM, SMrz, s1, s3, s33, s44, Ms, Tsd_C, Es, Ds