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

PMJPL/open_vapor_pressure_deficit.py

@@ -0,0 +1,11 @@
+from .PMJPL_parameter_from_IGBP import PMJPL_parameter_from_IGBP
+from rasters import Raster, RasterGeometry, VectorGeometry
+from typing import Union
+
+def open_vapor_pressure_deficit(IGBP: Union[Raster, int], geometry=None, IGBP_upsampling_resolution_meters=None):
+    return PMJPL_parameter_from_IGBP(
+        variable="VPD_open",
+        IGBP=IGBP,
+        geometry=geometry,
+        IGBP_upsampling_resolution_meters=IGBP_upsampling_resolution_meters
+    )

PMJPL/potential_soil_evaporation.py

@@ -11,7 +11,7 @@ def calculate_potential_soil_evaporation(
         rho: float,
         Cp_Jkg: float,
         FVC: float,
-        VPD: float,
+        VPD_Pa: float,
         ras: float,
         fwet: float,
         rtot: float,
@@ -39,7 +39,7 @@ def calculate_potential_soil_evaporation(
     - 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)
+    numerator = (delta_Pa * Asoil + rho * Cp_Jkg * (1.0 - FVC) * VPD_Pa / ras) * (1.0 - fwet)
     denominator = delta_Pa + gamma_Pa * rtot / ras
     LE_soil_pot = numerator / denominator
 

PMJPL/potential_stomatal_conductance.py

@@ -0,0 +1,11 @@
+from .PMJPL_parameter_from_IGBP import PMJPL_parameter_from_IGBP
+from rasters import Raster, RasterGeometry, VectorGeometry
+from typing import Union
+
+def potential_stomatal_conductance(IGBP: Union[Raster, int], geometry=None, IGBP_upsampling_resolution_meters=None):
+    return PMJPL_parameter_from_IGBP(
+        variable="CL",
+        IGBP=IGBP,
+        geometry=geometry,
+        IGBP_upsampling_resolution_meters=IGBP_upsampling_resolution_meters
+    )

PMJPL/process_PMJPL_table.py

@@ -0,0 +1,208 @@
+"""
+Module: process_PMJPL_table.py
+
+This module provides a function to process input data for the PM-JPL (Penman-Monteith Jet Propulsion Laboratory) model.
+It prepares the required variables from a pandas DataFrame, handles missing or alternative column names, computes derived variables as needed, and runs the PM-JPL model to generate output variables, which are appended to the input DataFrame.
+"""
+import logging
+
+import numpy as np
+import pandas as pd
+import rasters as rt
+from rasters import MultiPoint, WGS84
+
+from dateutil import parser
+from pandas import DataFrame
+
+from .constants import *
+from .PMJPL import PMJPL
+
+logger = logging.getLogger(__name__)
+
+# FIXME include additional inputs required by PM-JPL that were not required by PT-JPL
+
+def process_PMJPL_table(
+        input_df: DataFrame,
+        upscale_to_daylight: bool = False,
+        regenerate_net_radiation: bool = False
+        ) -> DataFrame:
+    """
+    Processes an input DataFrame to prepare all required variables for the PM-JPL model,
+    runs the model, and returns a DataFrame with the model outputs appended as new columns.
+
+    This function is designed to work with tabular (pandas DataFrame) data, such as point or site-level measurements or extracted pixel values from gridded products. It is compatible with DataFrames produced by ECOSTRESS Cal-Val or similar sources, and is suitable for both single-site and batch sensitivity analysis workflows.
+
+    The function is commonly used as a forward process in sensitivity or perturbation analysis, and can be chained with net radiation calculations prior to running the PM-JPL model.
+
+    Expected Input DataFrame Columns:
+        - 'NDVI': Normalized Difference Vegetation Index (required)
+        - 'ST_C': Surface temperature in Celsius (required)
+        - 'albedo': Surface albedo (required)
+        - 'Ta_C' or 'Ta': Air temperature in Celsius (required)
+        - 'RH': Relative humidity (0-1, required)
+        - 'Rn_Wm2': Net radiation (W/m^2, required)
+        - 'time_UTC': Time in UTC (required)
+        - 'geometry': Geometry object (optional, will be constructed from 'lat' and 'lon' if missing)
+        - 'lat', 'lon': Latitude and longitude (optional, used to construct geometry if needed)
+
+    The function will attempt to load or compute any missing optional variables using spatial context if possible.
+
+    Returns:
+        DataFrame: The input DataFrame with PM-JPL model outputs added as columns. Output columns include:
+            - 'LE': Total instantaneous evapotranspiration
+            - 'LE_canopy': Canopy transpiration
+            - 'LE_soil': Soil evaporation
+            - 'LE_interception': Interception evaporation
+            - 'PET': Potential evapotranspiration
+
+    Example:
+        Suppose you have a CSV file with columns: NDVI, ST_C, albedo, Ta_C, RH, Rn, time_UTC, lat, lon
+
+        ```python
+        import pandas as pd
+        from PMJPL.process_PMJPL_table import process_PMJPL_table
+
+        # Load your data
+        df = pd.read_csv('my_input_data.csv')
+
+        # Process the table and run the PM-JPL model
+        output_df = process_PMJPL_table(df)
+
+        # The output DataFrame will have new columns: 'LE', 'LE_canopy', 'LE_soil', 'LE_interception', 'PET'
+        print(output_df.head())
+        ```
+
+    Notes:
+        - If any required columns are missing, a KeyError will be raised.
+        - If geometry is not provided, latitude and longitude columns are required to construct spatial context.
+        - All input columns should be numeric and of compatible shape.
+        - This function is suitable for batch-processing site-level or point data tables for ET partitioning and for use in sensitivity analysis workflows.
+    """
+    logger.info("starting PM-JPL table processing")
+
+    # Extract and typecast surface temperature (ST_C) and NDVI
+    ST_C = np.array(input_df.ST_C).astype(np.float64)
+    emissivity = np.array(input_df.emissivity).astype(np.float64)
+    NDVI = np.array(input_df.NDVI).astype(np.float64)
+
+    # Mask NDVI values below threshold (0.06) as NaN
+    NDVI = np.where(NDVI > 0.06, NDVI, np.nan).astype(np.float64)
+
+    # Extract and typecast albedo
+    albedo = np.array(input_df.albedo).astype(np.float64)
+
+    # Handle air temperature column name differences (Ta_C or Ta)
+    if "Ta_C" in input_df:
+        Ta_C = np.array(input_df.Ta_C).astype(np.float64)
+    elif "Ta" in input_df:
+        Ta_C = np.array(input_df.Ta).astype(np.float64)
+    else:
+        raise KeyError("Input DataFrame must contain either 'Ta_C' or 'Ta' column.")
+
+    # Extract and typecast relative humidity and net radiation
+    RH = np.array(input_df.RH).astype(np.float64)
+
+    if "SWin_Wm2" in input_df:
+        SWin_Wm2 = np.array(input_df.SWin_Wm2).astype(np.float64)
+    else:
+        SWin_Wm2 = None
+
+    if "Rn_Wm2" in input_df:
+        Rn_Wm2 = np.array(input_df.Rn_Wm2).astype(np.float64)
+    else:
+        Rn_Wm2 = None
+
+    if "Rn_daily_Wm2" in input_df:
+        Rn_daylight_Wm2 = np.array(input_df.Rn_daily_Wm2).astype(np.float64)
+    else:
+        Rn_daylight_Wm2 = None
+
+    if "Tmin_C" in input_df:
+        Tmin_C = np.array(input_df.Tmin_C).astype(np.float64)
+    else:
+        Tmin_C = None
+
+    if "elevation_km" in input_df:
+        elevation_km = np.array(input_df.elevation_km).astype(np.float64)
+    else:
+        elevation_km = None
+
+    if "IGBP" in input_df:
+        IGBP = np.array(input_df.IGBP).astype(np.int8)
+    else:
+        IGBP = None
+
+    # --- Handle geometry and time columns ---
+    import pandas as pd
+    from rasters import MultiPoint, WGS84
+    from shapely.geometry import Point
+
+    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 PM-JPL 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 PM-JPL input table")
+
+    logger.info("started extracting time from PM-JPL input table")
+    time_UTC = pd.to_datetime(input_df.time_UTC).tolist()
+    logger.info("completed extracting time from PM-JPL input table")
+
+    # --- Pass time and geometry to the model ---
+    results = PMJPL(
+        geometry=geometry,
+        NDVI=NDVI,
+        Ta_C=Ta_C,
+        ST_C=ST_C,
+        emissivity=emissivity,
+        RH=RH,
+        Rn_Wm2=Rn_Wm2,
+        Rn_daylight_Wm2=Rn_daylight_Wm2,
+        SWin_Wm2=SWin_Wm2,
+        albedo=albedo,
+        Tmin_C=Tmin_C,
+        IGBP=IGBP,
+        elevation_km=elevation_km,
+        time_UTC=time_UTC,
+        upscale_to_daylight=upscale_to_daylight,
+        regenerate_net_radiation=regenerate_net_radiation
+    )
+
+    output_df = input_df.copy()
+    for key, value in results.items():
+        output_df[key] = value
+
+    logger.info("PM-JPL table processing complete")
+
+    return output_df

PMJPL/process_daily_ET_table.py

@@ -0,0 +1,40 @@
+import pandas as pd
+
+from sun_angles import SHA_deg_from_DOY_lat, daylight_from_SHA, sunrise_from_SHA
+from verma_net_radiation import daylight_Rn_integration_verma
+from daylight_evapotranspiration import daylight_ET_from_daily_LE
+
+from meteorology_conversion import celcius_to_kelvin
+
+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 = daylight_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 = daylight_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/transpiration.py

@@ -8,8 +8,8 @@ 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], 
+        rho_kgm3: Union[Raster, np.ndarray], 
+        Cp_Jkg: Union[Raster, np.ndarray], 
         VPD_Pa: Union[Raster, np.ndarray], 
         FVC: Union[Raster, np.ndarray], 
         ra: Union[Raster, np.ndarray], 
@@ -34,11 +34,11 @@ def calculate_transpiration(
     Returns:
         Union[Raster, np.ndarray]: transpiration (LEc) in mm/day.
     """
-    numerator = (delta_Pa * Ac + (rho * Cp * FVC * VPD_Pa / ra)) * (1.0 - fwet)
+    numerator = (delta_Pa * Ac + (rho_kgm3 * Cp_Jkg * 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)
+    LEc = rt.where(np.isnan(LEc), 0.0, LEc)
 
     return LEc

PMJPL/verify.py

@@ -0,0 +1,77 @@
+def verify() -> bool:
+    """
+    Verifies the correctness of the PT-JPL 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_PMJPL_inputs import load_ECOv002_calval_PMJPL_inputs
+    from .process_PMJPL_table import process_PMJPL_table
+    import os
+
+    # Load input and output tables
+    input_df = load_ECOv002_calval_PMJPL_inputs()
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    output_file_path = os.path.join(module_dir, "ECOv002-cal-val-PM-JPL-outputs.csv")
+    output_df = pd.read_csv(output_file_path)
+
+    # Run the model on the input table
+    model_df = process_PMJPL_table(input_df)
+
+    # Columns to compare (model outputs)
+    output_columns = [
+        "G_Wm2",
+        # "Rn_soil_Wm2",
+        # "LE_soil_Wm2",
+        # "Rn_canopy_Wm2",
+        # "PET_Wm2",
+        # "LE_canopy_Wm2",
+        # "LE_interception_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

PMJPL/version.py

@@ -0,0 +1,4 @@
+from os.path import join, abspath, dirname
+
+from importlib.metadata import version
+__version__ = version("PM-JPL")

PMJPL/wet_canopy_resistance.py

@@ -18,4 +18,5 @@ def calculate_wet_canopy_resistance(
     :param fwet: relative surface wetness
     :return: wet canopy resistance
     """
+    # print(f"conductance: {conductance.shape}, LAI: {LAI.shape}, fwet: {fwet.shape}")
     return rt.clip(1.0 / rt.clip(conductance * LAI * fwet, 1.0 / max_resistance, None), min_resistance, max_resistance)

PMJPL/wet_soil_evaporation.py

@@ -7,10 +7,10 @@ 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], 
+        rho_kgm3: Union[Raster, np.ndarray], 
+        Cp_Jkg: Union[Raster, np.ndarray], 
         FVC: Union[Raster, np.ndarray], 
-        VPD: Union[Raster, np.ndarray], 
+        VPD_Pa: Union[Raster, np.ndarray], 
         ras: Union[Raster, np.ndarray], 
         fwet: Union[Raster, np.ndarray], 
         rtot: Union[Raster, np.ndarray],
@@ -29,7 +29,7 @@ def calculate_wet_soil_evaporation(
     :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
+    numerator = (delta_Pa * Asoil + rho_kgm3 * Cp_Jkg * (1.0 - FVC) * VPD_Pa / ras) * fwet
     denominator = delta_Pa + gamma_Pa * rtot / ras
     LE_soil_wet = numerator / denominator
 

{pm_jpl-1.2.1.dist-info → pm_jpl-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PM-JPL
-Version: 1.2.1
+Version: 1.7.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
@@ -9,28 +9,25 @@ 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: carlson-fractional-vegetation-cover
+Requires-Dist: carlson-leaf-area-index
+Requires-Dist: check-distribution
+Requires-Dist: daylight-evapotranspiration>=1.2.1
+Requires-Dist: ECOv002-CMR>=1.0.5
+Requires-Dist: ECOv002-granules>=1.0.3
+Requires-Dist: ECOv003-granules
+Requires-Dist: GEOS5FP>=1.1.1
+Requires-Dist: MCD12C1_2019_v006
+Requires-Dist: meteorology-conversion
+Requires-Dist: NASADEM
 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
+Requires-Dist: priestley-taylor
+Requires-Dist: PTJPL>=1.5.1
+Requires-Dist: rasters>=1.11.0
+Requires-Dist: SEBAL-soil-heat-flux
+Requires-Dist: sun-angles>=1.3.0
+Requires-Dist: verma-net-radiation>=1.8.0
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pytest>=6.0; extra == "dev"

pm_jpl-1.7.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+PMJPL/ECOv002-cal-val-PM-JPL-inputs.csv,sha256=8U5x7QZI6qklpCNdEWuAt19RS2BtYjWDDgG1D49CREY,1060696
+PMJPL/ECOv002-cal-val-PM-JPL-outputs.csv,sha256=i2nEvXaZqRX7IlXyd2BkDK1clrVcTcDGqV1QoMG30qI,1623539
+PMJPL/ECOv002-static-tower-PM-JPL-inputs.csv,sha256=2ckj9kpAS8QSLets0jegf1G8Z8mSYjYT80k12kDQZlc,14915
+PMJPL/ECOv002_calval_PMJPL_inputs.py,sha256=c0tqGN-oJWoQUGZq5s3EdllrgkOQxMOBwdit_5a8s3U,608
+PMJPL/ECOv002_static_tower_PMJPL_inputs.py,sha256=nvMOIqZtJPKs--YHH4IyxAjfOGVv4BH8EriKMJolFek,618
+PMJPL/PMJPL.py,sha256=8YXZpOT181YYWnSal0-yQliKkJev1OZKR2Qdx_vK2t0,3554
+PMJPL/PMJPL_parameter_from_IGBP.py,sha256=3mzk957afEp0jBKWxpSDhzm33ZGkG_5RCyijlpQTlwk,2537
+PMJPL/VPD_factor.py,sha256=ezHMnnMPGNBt6ZTyiwsTEyMr8fwre6JDsHQea68P7T0,970
+PMJPL/__init__.py,sha256=jke4us8XYaXqU4fL97WYb7Ot1kdD4hV_2NyqFchUh6Q,91
+PMJPL/calculate_gamma.py,sha256=1rrIe9gz3VvkzaLBURSQDke3drIHnqoyBOdNfyvxhaM,5900
+PMJPL/canopy_aerodynamic_resistance.py,sha256=eU5x8riEROyynsMiWDHR_sDCeDexsWDlhuU69tUvC2s,8490
+PMJPL/canopy_conductance.py,sha256=ow7Egm_2wu2Zu5WxkESaUABf7UQA0ldmyPe5Wf4FQ2Y,4814
+PMJPL/closed_minimum_temperature.py,sha256=kMnu9vXK0qDDfyWk5-gdbEkLWzcn28Hz_NplMkyeiUE,461
+PMJPL/closed_vapor_pressure_deficit.py,sha256=v-bihgWfvaklR6f1jkb7XT4hIDk04O2zC08b8QmVJAQ,463
+PMJPL/constants.py,sha256=kFu_YZDpDHvKTOuxICaUV-VCf-B8S_2ZQ79gx2rjzjg,890
+PMJPL/correctance_factor.py,sha256=bVsu23oeTJoeMe-SIsH6cdFyATsLhgwvQUz79yf6kcQ,3181
+PMJPL/generate_PMJPL_inputs.py,sha256=YxConMMvqC1HQdg04fOZIqGLp_-CXzR4SRhiTSm4S8o,13523
+PMJPL/interception.py,sha256=2kDqMefH_kzMO9mLVY9BPFSoJE4K0pkQCXwrSi2CR9c,1605
+PMJPL/leaf_conductance_to_evaporated_water.py,sha256=04_w2Davv3LXqaeSOd_fwRp0wuG4rrjOXBGY4bwvw9U,467
+PMJPL/leaf_conductance_to_sensible_heat.py,sha256=nNQliqi0bMRFqXXva4s05nJnhdhgv1PGLVHlwPK3IuA,3602
+PMJPL/maximum_boundary_layer_resistance.py,sha256=fy2r8B3Ucs9mqI8JYLjS6BYL03iSAIPHQc-ZCd4UUlA,464
+PMJPL/minimum_boundary_layer_resistance.py,sha256=sYbLK_nPrnSD8LMMr_phULaAoBJk-5Nx1AT_D5q70ww,464
+PMJPL/minimum_temperature_factor.py,sha256=bHET3MLD9MlGwd8d5l0DR-4AY1emwJ1Eoqv7FxmZCWk,1585
+PMJPL/mod16.csv,sha256=oq-4b7dCqIrxTX2RcHjZMIZuqE8qThkW3bykqNpw18c,849
+PMJPL/model.py,sha256=RwRd8DHIEM4H33fopO9T0XLVVv06ADwoH_TZjlb2894,26866
+PMJPL/open_minimum_temperature.py,sha256=m03AU4REmcPEcWDyixSkNPYGgG_YAfGeYAg6LwPXjZY,457
+PMJPL/open_vapor_pressure_deficit.py,sha256=d5Q1EqOCOZE9QKDU0k1trSujHytz_QeRehHHjwhUI5I,459
+PMJPL/potential_soil_evaporation.py,sha256=O8bHGM4ARqSXJDHu6IWneSEy5qScenotGR3uawijGWg,1829
+PMJPL/potential_stomatal_conductance.py,sha256=MlK9_GATJ_yMr2YEqp_8wz6y4chWufrUEO9xrRaQqGs,456
+PMJPL/process_PMJPL_table.py,sha256=sGM3Q45p94DwLgo9RIKpt2XzZ6ElLoluibGtXzpfCE0,8266
+PMJPL/process_daily_ET_table.py,sha256=xwyWvsSNSswNDX-CYljJaHsDz5ktWPsDCvjuxQ3tJ2w,1202
+PMJPL/soil_moisture_constraint.py,sha256=URUGsE1_p2P1dVQ8qKRcKb93hahYWtAmYqoassRu-PI,667
+PMJPL/transpiration.py,sha256=lhRm2A0yxrlJxDw2he-k3PhE7G-sBsVvAMKo5fmh7wU,1998
+PMJPL/verify.py,sha256=NJ4YFWnil-1WnVt7OmNoDDaqVyn6ghzWGGFyIqN_bss,3216
+PMJPL/version.py,sha256=7e7k9a2pQYZR4Fyhl6UDY8NQ1lFi5ChR0Zk9Mpl45BU,115
+PMJPL/wet_canopy_resistance.py,sha256=Eape5EBJuoP-IRvD0SWHJKCJWhzm03vcG72OZVYqt_Q,879
+PMJPL/wet_soil_evaporation.py,sha256=mw9JG1oXfVdSWnVRLP2SPd53mSRK96b8k3E1zf0ci7A,1440
+pm_jpl-1.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pm_jpl-1.7.0.dist-info/METADATA,sha256=EZvJWQw-dmMYhm36Vkk8qkt8OEmspTrzC7O3ZXFxiHo,4399
+pm_jpl-1.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pm_jpl-1.7.0.dist-info/top_level.txt,sha256=YaAFwdYHUxfUW08hiuFquUEdDGrsYn1duuMMjJKh0Ws,6
+pm_jpl-1.7.0.dist-info/RECORD,,

{pm_jpl-1.2.1.dist-info → pm_jpl-1.7.0.dist-info}/WHEEL

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

PMJPL/MCD12C1/MCD12C1.py

@@ -1,10 +0,0 @@
-from os.path import join, abspath, dirname
-import numpy as np
-import rasters as rt
-from rasters import Raster, RasterGeometry
-
-def load_MCD12C1_IGBP(geometry: RasterGeometry = None) -> Raster:
-    filename = join(abspath(dirname(__file__)), "MCD12C1.A2019001.006.2020220162300.tif")
-    image = rt.Raster.open(filename, geometry=geometry, resampling="nearest")
-
-    return image

PMJPL/MCD12C1/__init__.py

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

PMJPL/SEBAL/SEBAL.py

@@ -1,45 +0,0 @@
-import numpy as np
-import pandas as pd
-import rasters as rt
-
-def calculate_soil_heat_flux(Rn: np.ndarray, ST_C: np.ndarray, NDVI: np.ndarray, albedo: np.ndarray) -> np.ndarray:
-    """
-    This function calculates the soil heat flux (G) in the Surface Energy Balance Algorithm for Land (SEBAL) model.
-    The formula used in the function is a simplification of the more complex relationship between these variables in the energy balance at the surface.
-    
-    Parameters:
-    Rn (np.ndarray): Net radiation at the surface.
-    ST_C (np.ndarray): Surface temperature in Celsius.
-    NDVI (np.ndarray): Normalized Difference Vegetation Index, indicating the presence and condition of vegetation.
-    albedo (np.ndarray): Measure of the diffuse reflection of solar radiation.
-    
-    Returns:
-    np.ndarray: The soil heat flux (G), a key component in the energy balance.
-    
-    Reference:
-    "Evapotranspiration Estimation Based on Remote Sensing and the SEBAL Model in the Bosten Lake Basin of China" [^1^][1]
-    """
-    # Empirical coefficients used in the calculation
-    coeff1 = 0.0038
-    coeff2 = 0.0074
-    
-    # Vegetation cover correction factor
-    NDVI_correction = 1 - 0.98 * NDVI ** 4
-    
-    # Calculation of the soil heat flux (G)
-    G = Rn * ST_C * (coeff1 + coeff2 * albedo) * NDVI_correction
-    
-    G = rt.clip(G, 0, None)
-
-    return G
-
-def process_SEBAL_G_table(input_df: pd.DataFrame) -> pd.DataFrame:
-    Rn = input_df.Rn
-    ST_C = input_df.ST_C
-    NDVI = input_df.NDVI
-    albedo = input_df.albedo
-    G = calculate_soil_heat_flux(Rn=Rn, ST_C=ST_C, NDVI=NDVI, albedo=albedo)
-    output_df = input_df.copy()
-    output_df["G"] = G
-
-    return output_df

PMJPL/SEBAL/__init__.py

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

PMJPL/downscaling/__init__.py

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