STIC-JPL 1.6.0__py3-none-any.whl

STIC_JPL/net_radiation.py

@@ -0,0 +1,38 @@
+from typing import Union
+import numpy as np
+
+from rasters import Raster
+
+from .constants import SB_SIGMA
+
+def calculate_net_longwave_radiation(
+        Ta_C: Union[Raster, np.ndarray], 
+        Ea_hPa: Union[Raster, np.ndarray], 
+        ST_C: Union[Raster, np.ndarray], 
+        emissivity: Union[Raster, np.ndarray], 
+        albedo: Union[Raster, np.ndarray],
+        sigma: float = SB_SIGMA) -> Union[Raster, np.ndarray]:
+    """
+    Calculate the net radiation.
+
+    Parameters:
+    Ta_C (np.ndarray): Air temperature in Celsius
+    Ea_hPa (np.ndarray): Actual vapor pressure at air temperature in hPa
+    ST_C (np.ndarray): Surface temperature in Celsius
+    emissivity (np.ndarray): Emissivity of the surface
+    RG (np.ndarray): Global radiation
+    albedo (np.ndarray): Albedo of the surface
+
+    Returns:
+    Lnet (np.ndarray): Net longwave radiation
+    """
+    etaa = 1.24 * (Ea_hPa / (Ta_C + 273.15)) ** (1.0 / 7.0)  # air emissivity
+    LWin = sigma * etaa * (Ta_C + 273.15) ** 4
+    LWout = sigma * emissivity * (ST_C + 273.15) ** 4
+    
+    # emissivity was being applied twice here
+    # LWnet = emissivity * LWin - LWout
+    
+    LWnet = LWin - LWout
+
+    return LWnet

STIC_JPL/process_STIC_table.py

@@ -0,0 +1,152 @@
+import logging
+
+import numpy as np
+import pandas as pd
+from dateutil import parser
+from pandas import DataFrame
+from rasters import Point, MultiPoint, WGS84
+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 shapely.geometry import Point
+
+from .constants import *
+from .model import STIC_JPL, MAX_ITERATIONS, USE_VARIABLE_ALPHA
+
+logger = logging.getLogger(__name__)
+
+def process_STIC_table(
+        input_df: DataFrame, 
+        max_iterations = MAX_ITERATIONS, 
+        use_variable_alpha = USE_VARIABLE_ALPHA,
+        constrain_negative_LE = CONSTRAIN_NEGATIVE_LE,
+        supply_SWin = SUPPLY_SWIN,
+        upscale_to_daylight = UPSCALE_TO_DAYLIGHT,
+        offline_mode: bool = False
+    ) -> DataFrame:
+    """
+    Process STIC table with batch processing.
+    
+    Note: daylight_evapotranspiration now supports arrays of datetime objects,
+    so batch processing works efficiently even with upscale_to_daylight=True.
+    """
+    return process_STIC_table_single(
+        input_df, 
+        max_iterations=max_iterations,
+        use_variable_alpha=use_variable_alpha,
+        constrain_negative_LE=constrain_negative_LE,
+        supply_SWin=supply_SWin,
+        upscale_to_daylight=upscale_to_daylight,
+        offline_mode=offline_mode
+    )
+
+
+def process_STIC_table_single(
+        input_df: DataFrame, 
+        max_iterations = MAX_ITERATIONS, 
+        use_variable_alpha = USE_VARIABLE_ALPHA,
+        constrain_negative_LE = CONSTRAIN_NEGATIVE_LE,
+        supply_SWin = SUPPLY_SWIN,
+        upscale_to_daylight = UPSCALE_TO_DAYLIGHT,
+        offline_mode: bool = False
+    ) -> DataFrame:
+    """Process a single row or batch of data through STIC-JPL model."""
+    
+    ST_C = np.float64(np.array(input_df.ST_C))
+    emissivity = np.float64(np.array(input_df.EmisWB))
+    NDVI = np.float64(np.array(input_df.NDVI))
+    albedo = np.float64(np.array(input_df.albedo))
+    Ta_C = np.float64(np.array(input_df.Ta_C))
+    RH = np.float64(np.array(input_df.RH))
+    Rn_Wm2 = np.float64(np.array(input_df.Rn_Wm2))
+    Rg = np.float64(np.array(input_df.Rg))
+
+    if "G" in input_df:
+        G_Wm2 = np.array(input_df.G)
+    else:
+        G_Wm2 = calculate_SEBAL_soil_heat_flux(
+            Rn=Rn_Wm2,
+            ST_C=ST_C,
+            NDVI=NDVI,
+            albedo=albedo
+        )
+    
+    if "SWin_Wm2" in input_df and supply_SWin:
+        SWin_Wm2 = np.float64(np.array(input_df.SWin_Wm2))
+    else:
+        SWin_Wm2 = None
+
+    # --- Handle geometry and time columns ---
+    def ensure_geometry(df):
+        if "geometry" in df:
+            if isinstance(df.geometry.iloc[0], str):
+                def parse_geom(s):
+                    s = s.strip()
+                    if s.startswith("POINT"):
+                        coords = s.replace("POINT", "").replace("(", "").replace(")", "").strip().split()
+                        return Point(float(coords[0]), float(coords[1]))
+                    elif "," in s:
+                        coords = [float(c) for c in s.split(",")]
+                        return Point(coords[0], coords[1])
+                    else:
+                        coords = [float(c) for c in s.split()]
+                        return Point(coords[0], coords[1])
+                df = df.copy()
+                df['geometry'] = df['geometry'].apply(parse_geom)
+        return df
+
+    input_df = ensure_geometry(input_df)
+
+    logger.info("started extracting geometry from PT-JPL-SM input table")
+
+    if "geometry" in input_df:
+        # Convert Point objects to coordinate tuples for MultiPoint
+        if hasattr(input_df.geometry.iloc[0], "x") and hasattr(input_df.geometry.iloc[0], "y"):
+            coords = [(pt.x, pt.y) for pt in input_df.geometry]
+            geometry = MultiPoint(coords, crs=WGS84)
+        else:
+            geometry = MultiPoint(input_df.geometry, crs=WGS84)
+    elif "lat" in input_df and "lon" in input_df:
+        lat = np.array(input_df.lat).astype(np.float64)
+        lon = np.array(input_df.lon).astype(np.float64)
+        geometry = MultiPoint(x=lon, y=lat, crs=WGS84)
+    else:
+        raise KeyError("Input DataFrame must contain either 'geometry' or both 'lat' and 'lon' columns.")
+
+    logger.info("completed extracting geometry from PT-JPL-SM input table")
+
+    logger.info("started extracting time from PT-JPL-SM input table")
+    
+    # Handle time conversion - for single row, extract single datetime; for multiple rows, use list
+    if len(input_df) == 1:
+        time_UTC = pd.to_datetime(input_df.time_UTC.iloc[0])
+    else:
+        time_UTC = pd.to_datetime(input_df.time_UTC).tolist()
+    
+    logger.info("completed extracting time from PT-JPL-SM input table")
+    
+    results = STIC_JPL(
+        geometry=geometry,
+        ST_C = ST_C,
+        emissivity=emissivity,
+        NDVI=NDVI,
+        albedo=albedo,
+        Ta_C=Ta_C,
+        RH=RH,
+        Rn_Wm2=Rn_Wm2,
+        G_Wm2=G_Wm2,
+        SWin_Wm2=SWin_Wm2,
+        time_UTC=time_UTC,
+        max_iterations=max_iterations,
+        use_variable_alpha=use_variable_alpha,
+        constrain_negative_LE=constrain_negative_LE,
+        upscale_to_daylight=upscale_to_daylight,
+        offline_mode=offline_mode
+    )
+
+    output_df = input_df.copy()
+
+    for key, value in results.items():
+        output_df[key] = value
+
+    return output_df

STIC_JPL/root_zone_initialization.py

@@ -0,0 +1,36 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+from rasters import Raster
+
+from .constants import GAMMA_HPA
+
+def calculate_root_zone_moisture(
+        delta_hPa: Union[Raster, np.ndarray],
+        ST_C: Union[Raster, np.ndarray], 
+        Ta_C: Union[Raster, np.ndarray], 
+        Td_C: Union[Raster, np.ndarray], 
+        s11: Union[Raster, np.ndarray], 
+        s33: Union[Raster, np.ndarray], 
+        s44: Union[Raster, np.ndarray], 
+        Tsd_C: Union[Raster, np.ndarray],
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA) -> Union[Raster, np.ndarray]:
+    """
+    This function calculates the rootzone moisture (Mrz) using various parameters.
+
+    Parameters:
+    delta (np.ndarray): Rate of change of saturation vapor pressure with temperature (hPa/°C)
+    ST_C (np.ndarray): Surface temperature (°C)
+    Ta_C (np.ndarray): Air temperature (°C)
+    Td_C (np.ndarray): Dewpoint temperature (°C)
+    s11 (np.ndarray): The slope of SVP at dewpoint temperature (hPa/K)
+    s33 (np.ndarray): The slope of SVP at surface temperature (hPa/K)
+    s44 (np.ndarray): The difference between saturation vapor pressure and actual vapor pressure divided by the difference between air temperature and dewpoint temperature (hPa/K)
+    Tsd_C (np.ndarray): The surface dewpoint temperature (°C)
+
+    Returns:
+    SMrz (np.ndarray): The rootzone moisture (m³/m³)
+    """
+    return rt.clip((gamma_hPa * s11 * (Tsd_C - Td_C)) / (delta_hPa * s33 * (ST_C - Td_C) + gamma_hPa * s44 * (Ta_C - Td_C) - delta_hPa * s11 * (Tsd_C - Td_C)), 0.0001, 0.999)
+    

STIC_JPL/root_zone_iteration.py

@@ -0,0 +1,66 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+
+from rasters import Raster
+
+from .constants import GAMMA_HPA
+
+def calculate_rootzone_moisture(
+        delta_hPa: Union[Raster, np.ndarray], # Rate of change of saturation vapor pressure with temperature (hPa/°C)
+        s1_hPa: Union[Raster, np.ndarray], # The slope of SVP at surface temperature (hPa/K)
+        s3_hPa: Union[Raster, np.ndarray], # The slope of SVP at dewpoint temperature (hPa/K)
+        ST_C: Union[Raster, np.ndarray], # surface temperature (°C)
+        Ta_C: Union[Raster, np.ndarray], # air temperature (°C)
+        dTS_C: Union[Raster, np.ndarray], # difference between surface and air temperature (°C)
+        Td_C: Union[Raster, np.ndarray], # dewpoint temperature (°C)
+        Tsd_C: Union[Raster, np.ndarray], # surface dewpoint temperature (°C)
+        Rg_Wm2: Union[Raster, np.ndarray], # Incoming solar radiation (W/m^2)
+        Rn_Wm2: Union[Raster, np.ndarray], # Net radiation (W/m^2)
+        LWnet_Wm2: Union[Raster, np.ndarray], # Net longwave radiation (W/m^2)
+        FVC: Union[Raster, np.ndarray], # Fractional vegetation cover (unitless)
+        VPD_hPa: Union[Raster, np.ndarray], # Vapor pressure deficit (hPa)
+        D0_hPa: Union[Raster, np.ndarray], # Vapor pressure deficit at source (hPa)
+        SVP_hPa: Union[Raster, np.ndarray], # Saturation vapor pressure (hPa)
+        Ea_hPa: Union[Raster, np.ndarray], # Actual vapor pressure (hPa)
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA # Psychrometric constant (hPa/°C)
+    ) -> Union[Raster, np.ndarray]:
+    """
+    Calculates the root zone moisture (Mrz) based on thermal IR and meteorological information.
+
+    Args:
+        delta (np.ndarray): Rate of change of saturation vapor pressure with temperature (kPa/°C).
+        s1 (np.ndarray): The slope of saturation vapor pressure at surface temperature (hPa/K).
+        s3 (np.ndarray): The slope of saturation vapor pressure at dewpoint temperature (hPa/K).
+        ST_C (np.ndarray): Surface temperature in degrees Celsius.
+        Ta_C (np.ndarray): Air temperature in degrees Celsius.
+        dTS (np.ndarray): Difference between surface and air temperature in degrees Celsius.
+        Td_C (np.ndarray): Dewpoint temperature in degrees Celsius.
+        Tsd_C (np.ndarray): Surface dewpoint temperature in degrees Celsius.
+        Rg (np.ndarray): Incoming solar radiation in W/m^2.
+        Rn (np.ndarray): Net radiation in W/m^2.
+        Lnet (np.ndarray): Net longwave radiation in W/m^2.
+        fc (np.ndarray): Fractional vegetation cover (unitless).
+        VPD_hPa (np.ndarray): Vapor pressure deficit in hPa.
+        D0 (np.ndarray): Vapor pressure deficit at source in hPa.
+        SVP_hPa (np.ndarray): Saturation vapor pressure in hPa.
+        Ea_hPa (np.ndarray): Actual vapor pressure in hPa.
+
+    Returns:
+        np.ndarray: Root zone moisture (Mrz) (value 0 to 1).
+    """
+    s44 = (SVP_hPa - Ea_hPa) / (Ta_C - Td_C)
+    kTSTD = (ST_C - Tsd_C) / (Ta_C - Td_C)
+    Mrz = (gamma_hPa * s1_hPa * (Tsd_C - Td_C)) / (delta_hPa * s3_hPa * kTSTD * (ST_C - Td_C) + gamma_hPa * s44 * (Ta_C - Td_C) - delta_hPa * s1_hPa * (Tsd_C - Td_C))
+    Mrz = rt.where((Rn_Wm2 < 0) & (dTS_C < 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Rn_Wm2 < 0) & (dTS_C > 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Rn_Wm2 > 0) & (dTS_C < 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Rn_Wm2 > 0) & (dTS_C > 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Rg_Wm2 > 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Rg_Wm2 < 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where((Td_C < 0) & (Mrz < 0), np.abs(Mrz), Mrz)
+    Mrz = rt.where(Mrz > 1, 1, Mrz)
+    Mrz = rt.where(Mrz < 0, 0.0001, Mrz)
+    
+    return Mrz

STIC_JPL/soil_moisture_initialization.py

@@ -0,0 +1,115 @@
+from typing import Union, Tuple
+import numpy as np
+
+import rasters as rt
+from rasters import Raster
+
+from .FVC_from_NDVI import FVC_from_NDVI
+from .LAI_from_NDVI import LAI_from_NDVI
+
+from .constants import GAMMA_HPA
+from .root_zone_initialization import calculate_root_zone_moisture
+
+def initialize_soil_moisture(
+        delta_hPa: Union[Raster, np.ndarray],  # Rate of change of saturation vapor pressure with temperature (hPa/°C)
+        ST_C: Union[Raster, np.ndarray],  # Surface temperature (°C)
+        Ta_C: Union[Raster, np.ndarray],  # Air temperature (°C)
+        Td_C: Union[Raster, np.ndarray],  # Dewpoint temperature (°C)
+        dTS: Union[Raster, np.ndarray],  # Difference between surface and air temperature (°C)
+        Rn_Wm2: Union[Raster, np.ndarray],  # Net radiation (W/m²)
+        LWnet_Wm2: Union[Raster, np.ndarray],  # Net longwave radiation (W/m²)
+        FVC: Union[Raster, np.ndarray],  # Fractional vegetation cover (unitless)
+        VPD_hPa: Union[Raster, np.ndarray],  # Vapor pressure deficit (hPa)
+        SVP_hPa: Union[Raster, np.ndarray],  # Saturation vapor pressure (hPa)
+        Ea_hPa: Union[Raster, np.ndarray],  # Actual vapor pressure (hPa)
+        Estar_hPa: Union[Raster, np.ndarray],  # Saturation vapor pressure at surface temperature (hPa)
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA  # Psychrometric constant (hPa/°C)
+    ) -> Tuple[Union[Raster, np.ndarray]]:
+    """
+    This function estimates the soil moisture availability (SM) based on thermal IR and meteorological information. 
+    The estimated SM is treated as initial SM, which will be later estimated through iteration in the actual ET estimation loop to establish feedback between SM and biophysical states.
+
+    Parameters:
+    delta (np.ndarray): Rate of change of saturation vapor pressure with temperature (kPa/°C)
+    ST_C (np.ndarray): Surface temperature (°C)
+    Ta_C (np.ndarray): Air temperature (°C)
+    Td_C (np.ndarray): Dewpoint temperature (°C)
+    dTS (np.ndarray): Difference between surface and air temperature (°C)
+    Rn (np.ndarray): Net radiation (W/m²)
+    LWnet (np.ndarray): Net longwave radiation (W/m²)
+    NDVI (np.ndarray): Normalized Difference Vegetation Index (unitless)
+    VPD_hPa (np.ndarray): Vapor pressure deficit (hPa)
+    SVP_hPa (np.ndarray): Saturation vapor pressure (hPa)
+    Ea_hPa (np.ndarray): Actual vapor pressure (hPa)
+    Estar (np.ndarray): Saturation vapor pressure at surface temperature (hPa)
+
+    Returns:
+    SM (np.ndarray): soil moisture (m³/m³)
+    Mrz (np.ndarray): The rootzone moisture (m³/m³)
+    Ms (np.ndarray): The surface moisture (m³/m³)
+    Ep_PT (np.ndarray): The potential evaporation (Priestley-Taylor eqn.) (mm/day)
+    Ds (np.ndarray): The vapor pressure deficit at surface (hPa)
+    s1 (np.ndarray): The slope of SVP at dewpoint temperature (hPa/K)
+    s3 (np.ndarray): The slope of SVP at surface temperature (hPa/K)
+    Tsd_C (np.ndarray): The surface dewpoint temperature (°C)
+    """
+    # Compute the surface dewpoint temperature
+    s11 = (45.03 + 3.014 * Td_C + 0.05345 * Td_C ** 2 + 0.00224 * Td_C ** 3) * 1e-2  # slope of SVP at TD (hpa/K)
+    s22 = (Estar_hPa - Ea_hPa) / (ST_C - Td_C)
+    s33 = (45.03 + 3.014 * ST_C + 0.05345 * ST_C ** 2 + 0.00224 * ST_C ** 3) * 1e-2  # slope of SVP at TS (hpa/K)
+    s44 = (SVP_hPa - Ea_hPa) / (Ta_C - Td_C)
+    Tsd_C = (Estar_hPa - Ea_hPa - s33 * ST_C + s11 * Td_C) / (s11 - s33)  # Surface dewpoint temperature (degC)
+
+    # Calculate the surface moisture or wetness
+    Msurf = (s11 / s22) * ((Tsd_C - Td_C) / (ST_C - Td_C))  # Surface wetness
+    Msurf = rt.clip(Msurf, 0.0001, 0.9999)
+
+    # Calculate the surface vapor pressure and deficit
+    esurf = Ea_hPa + Msurf * (Estar_hPa - Ea_hPa)
+    Dsurf = esurf - Ea_hPa
+
+    # Separate the soil and canopy wetness to form a composite surface moisture
+    Ms = Msurf
+    Mcan = FVC * Msurf
+    Msoil = (1 - FVC) * Msurf
+
+    TdewIndex = (ST_C - Tsd_C) / (Ta_C - Td_C)  # % TdewIndex > 1 signifies super dry condition
+    Ep_PT = (1.26 * delta_hPa * Rn_Wm2) / (delta_hPa + gamma_hPa)  # Potential evaporation (Priestley-Taylor eqn.)
+
+    # Adjust surface wetness based on certain conditions
+    Ms = rt.where((FVC <= 0.25) & (TdewIndex < 1), Msoil, Ms)
+    Mcan = rt.where((FVC <= 0.25) & (TdewIndex < 1), 0, Mcan)
+    Ms = rt.where((FVC <= 0.25) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125), Msoil, Ms)
+    Mcan = rt.where((FVC <= 0.25) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125), 0, Mcan)
+    
+    # Calculate the root-zone moisture
+    SMrz = calculate_root_zone_moisture(
+        delta_hPa=delta_hPa, 
+        ST_C=ST_C, 
+        Ta_C=Ta_C, 
+        Td_C=Td_C, 
+        s11=s11, 
+        s33=s33, 
+        s44=s44, 
+        Tsd_C=Tsd_C,
+        gamma_hPa=gamma_hPa
+    )
+
+    # Combine soil moisture to account for hysteresis and initial estimation of surface vapor pressure
+    SM = Ms
+    SM = rt.where((Ep_PT > Rn_Wm2) & (dTS > 0), SMrz, SM)
+    SM = rt.where((Ep_PT > Rn_Wm2) & (FVC <= 0.25), SMrz, SM)
+    SM = rt.where((Ep_PT > Rn_Wm2) & (Dsurf > VPD_hPa), SMrz, SM)
+    SM = rt.where((FVC <= 0.25) & (dTS > 0) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125), SMrz, SM)
+    SM = rt.where((FVC <= 0.25) & (dTS > 0) & (Ta_C > 10) & (Td_C < 0) & (Dsurf > VPD_hPa), SMrz, SM)
+    SM = rt.where((Ep_PT < Rn_Wm2) & (FVC <= 0.25) & (Dsurf > VPD_hPa), SMrz, SM)
+    
+    es = Ea_hPa + SM * (Estar_hPa - Ea_hPa)
+    
+    # vapor pressure deficit at surface
+    Ds = (Estar_hPa - es)  
+    
+    s1 = s11
+    s3 = s33
+
+    return SM, SMrz, Ms, Ep_PT, Ds, s1, s3, Tsd_C

STIC_JPL/soil_moisture_iteration.py

@@ -0,0 +1,131 @@
+from typing import Union
+import numpy as np
+
+import rasters as rt
+
+from rasters import Raster
+
+from .constants import GAMMA_HPA
+from .root_zone_iteration import calculate_rootzone_moisture
+
+def iterate_soil_moisture(
+        delta_hPa: Union[Raster, np.ndarray], # Rate of change of saturation vapor pressure with temperature (hPa/°C)
+        s1: Union[Raster, np.ndarray], # The slope of SVP at surface temperature (hPa/K)
+        s3: Union[Raster, np.ndarray], # The slope of SVP at dewpoint temperature (hPa/K)
+        ST_C: Union[Raster, np.ndarray], # surface temperature (°C)
+        Ta_C: Union[Raster, np.ndarray], # air temperature (°C)
+        dTS_C: Union[Raster, np.ndarray], # difference between surface and air temperature (°C)
+        Td_C: Union[Raster, np.ndarray], # dewpoint temperature (°C)
+        Tsd_C: Union[Raster, np.ndarray], # surface dewpoint temperature (°C)
+        Rg_Wm2: Union[Raster, np.ndarray], # Incoming solar radiation (W/m^2)
+        Rn_Wm2: Union[Raster, np.ndarray], # Net radiation (W/m^2)
+        LWnet_Wm2: Union[Raster, np.ndarray], # Net longwave radiation (W/m^2)
+        FVC: Union[Raster, np.ndarray], # Fractional vegetation cover (unitless)
+        VPD_hPa: Union[Raster, np.ndarray], # Vapor pressure deficit (hPa)
+        D0_hPa: Union[Raster, np.ndarray], # Vapor pressure deficit at source (hPa)
+        SVP_hPa: Union[Raster, np.ndarray], # Saturation vapor pressure (hPa)
+        Ea_hPa: Union[Raster, np.ndarray], # Actual vapor pressure (hPa)
+        T0: Union[Raster, np.ndarray], # Temperature at source (°C)
+        gamma_hPa: Union[Raster, np.ndarray, float] = GAMMA_HPA # Psychrometric constant (hPa/°C)
+    ) -> Union[Raster, np.ndarray]:
+    """
+    Estimates the soil moisture availability (SM) (or wetness) (value 0 to 1) based on thermal IR and meteorological
+    information. However, this M will be treated as initial M, which will be later on estimated through iteration in the
+    actual ET estimation loop to establish feedback between M and biophysical states.
+
+    Args:
+        delta (np.ndarray): Rate of change of saturation vapor pressure with temperature (kPa/°C).
+        s1 (np.ndarray): The slope of saturation vapor pressure at surface temperature (hPa/K).
+        s3 (np.ndarray): The slope of saturation vapor pressure at dewpoint temperature (hPa/K).
+        ST_C (np.ndarray): Surface temperature in degrees Celsius.
+        Ta_C (np.ndarray): Air temperature in degrees Celsius.
+        dTS (np.ndarray): Difference between surface and air temperature in degrees Celsius.
+        Td_C (np.ndarray): Dewpoint temperature in degrees Celsius.
+        Tsd_C (np.ndarray): Surface dewpoint temperature in degrees Celsius.
+        Rg (np.ndarray): Incoming solar radiation in W/m^2.
+        Rn (np.ndarray): Net radiation in W/m^2.
+        LWnet (np.ndarray): Net longwave radiation in W/m^2.
+        FVC (np.ndarray): Fractional vegetation cover (unitless).
+        VPD_hPa (np.ndarray): Vapor pressure deficit in hPa.
+        D0 (np.ndarray): Vapor pressure deficit at source in hPa.
+        SVP_hPa (np.ndarray): Saturation vapor pressure in hPa.
+        Ea_hPa (np.ndarray): Actual vapor pressure in hPa.
+        T0 (np.ndarray): Temperature at source in degrees Celsius.
+
+    Returns:
+        np.ndarray: Soil moisture availability (SM) (or wetness) (value 0 to 1).
+    """
+    # calculate surface wetness (Msurf)
+    kTSTD = (T0 - Td_C) / (ST_C - Td_C)
+    Msurf = (s1 / s3) * ((Tsd_C - Td_C) / (kTSTD * (ST_C - Td_C)))  # Surface wetness
+    Msurf = rt.where((Rn_Wm2 < 0) & (dTS_C < 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    Msurf = rt.where((Rn_Wm2 < 0) & (dTS_C > 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    Msurf = rt.where((Rn_Wm2 > 0) & (dTS_C < 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    Msurf = rt.where((Rn_Wm2 > 0) & (dTS_C > 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    
+    # solar radiation is only used to correct negative values of surface wetness
+    Msurf = rt.where((Rg_Wm2 > 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    Msurf = rt.where((Rg_Wm2 < 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    
+    Msurf = rt.where((Td_C < 0) & (Msurf < 0), np.abs(Msurf), Msurf)
+    Msurf = rt.clip(Msurf, 0.0001, 1)
+
+    # Separating soil and canopy wetness to form a composite surface moisture
+    Ms = Msurf
+    Mcan = FVC * Msurf
+    Msoil = (1 - FVC) * Msurf
+
+    TdewIndex = (ST_C - Tsd_C) / (Ta_C - Td_C)
+
+    # Potential evaporation (Priestley-Taylor eqn.)
+    Ep_PT = (1.26 * delta_hPa * Rn_Wm2) / (delta_hPa + gamma_hPa)  
+
+    # calculate surface wetness (Ms)
+    Ms = rt.where((Ep_PT > Rn_Wm2) & (FVC <= 0.25) & (TdewIndex < 1), Msoil, Ms)
+    Ms = rt.where((FVC <= 0.25) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125), Msoil, Ms)
+    Ms = rt.where((Rn_Wm2 > Ep_PT) & (FVC <= 0.25) & (TdewIndex < 1) & (Td_C <= 0), Msoil, Ms)
+    Ms = rt.where((Rn_Wm2 > Ep_PT) & (FVC <= 0.25) & (TdewIndex < 1), Msoil, Ms)
+    Ms = rt.where((D0_hPa > VPD_hPa) & (FVC <= 0.25) & (TdewIndex < 1), Msoil, Ms)
+
+    # calculate canopy wetness (Mcan)
+    Mcan = rt.where((Ep_PT > Rn_Wm2) & (FVC <= 0.25) & (TdewIndex < 1), 0, Mcan)
+    Mcan = rt.where((FVC <= 0.25) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125), 0, Mcan)
+    Mcan = rt.where((Rn_Wm2 > Ep_PT) & (FVC <= 0.25) & (TdewIndex < 1) & (Td_C <= 0), 0, Mcan)
+    Mcan = rt.where((Rn_Wm2 > Ep_PT) & (FVC <= 0.25) & (TdewIndex < 1), 0, Mcan)
+    Mcan = rt.where((D0_hPa > VPD_hPa) & (FVC <= 0.25) & (TdewIndex < 1), 0, Mcan)
+
+    # calculate rootzone moisture (Mrz)
+    Mrz = calculate_rootzone_moisture(
+        delta_hPa=delta_hPa, 
+        s1_hPa=s1, 
+        s3_hPa=s3, 
+        ST_C=ST_C, 
+        Ta_C=Ta_C, 
+        dTS_C=dTS_C, 
+        Td_C=Td_C, 
+        Tsd_C=Tsd_C, 
+        Rg_Wm2=Rg_Wm2, 
+        Rn_Wm2=Rn_Wm2, 
+        LWnet_Wm2=LWnet_Wm2, 
+        FVC=FVC, 
+        VPD_hPa=VPD_hPa, 
+        D0_hPa=D0_hPa, 
+        SVP_hPa=SVP_hPa, 
+        Ea_hPa=Ea_hPa,
+        gamma_hPa=gamma_hPa
+    )
+
+    TdewIndex = (ST_C - Tsd_C) / (Ta_C - Td_C)
+
+    # Potential evaporation (Priestley-Taylor eqn.)
+    Ep_PT = (1.26 * delta_hPa * Rn_Wm2) / (delta_hPa + gamma_hPa)  
+
+    # COMBINE M to account for Hysteresis and initial estimation of surface vapor pressure
+    SM = Msurf
+    SM = rt.where((Ep_PT > Rn_Wm2) & (dTS_C > 0) & (FVC <= 0.25) & (D0_hPa > VPD_hPa) & (TdewIndex < 1), Mrz, SM)
+    SM = rt.where((FVC <= 0.25) & (dTS_C > 0) & (Ta_C > 10) & (Td_C < 0) & (LWnet_Wm2 < -125) & (D0_hPa > VPD_hPa), Mrz, SM)
+
+    return SM
+
+
+

STIC_JPL/verify.py

@@ -0,0 +1,71 @@
+def verify() -> bool:
+    """
+    Verifies the correctness of the PT-JPL-SM model implementation by comparing
+    its outputs to a reference dataset.
+
+    This function loads a known input table and the corresponding expected output table.
+    It runs the model on the input data, then compares the resulting outputs to the
+    reference outputs for key variables using strict numerical tolerances. If all
+    outputs match within tolerance, the function returns True. Otherwise, it prints
+    which column failed and returns False.
+
+    Returns:
+        bool: True if all model outputs match the reference outputs within tolerance, False otherwise.
+    """
+    import pandas as pd
+    import numpy as np
+    from .ECOv002_calval_STIC_inputs import load_ECOv002_calval_STIC_inputs
+    from .process_STIC_table import process_STIC_table
+    import os
+
+    # Load input and output tables
+    input_df = load_ECOv002_calval_STIC_inputs()
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    output_file_path = os.path.join(module_dir, "ECOv002-cal-val-STIC-JPL-outputs.csv")
+    output_df = pd.read_csv(output_file_path)
+
+    # Run the model on the input table
+    model_df = process_STIC_table(input_df)
+
+    # Columns to compare (model outputs)
+    output_columns = [
+        "G_Wm2",
+        "LE_Wm2"
+    ]
+
+    # Compare each output column and collect mismatches
+    mismatches = []
+    for col in output_columns:
+        if col not in model_df or col not in output_df:
+            mismatches.append((col, 'missing_column', None))
+            continue
+        model_vals = model_df[col].values
+        ref_vals = output_df[col].values
+        # Use numpy allclose for floating point comparison
+        if not np.allclose(model_vals, ref_vals, rtol=1e-5, atol=1e-8, equal_nan=True):
+            # Find indices where values differ
+            diffs = np.abs(model_vals - ref_vals)
+            max_diff = np.nanmax(diffs)
+            idxs = np.where(~np.isclose(model_vals, ref_vals, rtol=1e-5, atol=1e-8, equal_nan=True))[0]
+            mismatch_info = {
+                'indices': idxs.tolist(),
+                'model_values': model_vals[idxs].tolist(),
+                'ref_values': ref_vals[idxs].tolist(),
+                'diffs': diffs[idxs].tolist(),
+                'max_diff': float(max_diff)
+            }
+            mismatches.append((col, 'value_mismatch', mismatch_info))
+    if mismatches:
+        print("Verification failed. Details:")
+        for col, reason, info in mismatches:
+            if reason == 'missing_column':
+                print(f"  Missing column: {col}")
+            elif reason == 'value_mismatch':
+                print(f"  Mismatch in column: {col}")
+                print(f"    Max difference: {info['max_diff']}")
+                print(f"    Indices off: {info['indices']}")
+                print(f"    Model values: {info['model_values']}")
+                print(f"    Reference values: {info['ref_values']}")
+                print(f"    Differences: {info['diffs']}")
+        return False
+    return True

STIC_JPL/version.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("STIC-JPL")