BESS-JPL 1.17.0__py3-none-any.whl → 1.18.0__py3-none-any.whl

BESS_JPL/process_BESS_table.py

@@ -5,11 +5,14 @@ import rasters as rt
 from dateutil import parser
 from pandas import DataFrame
 
+from .constants import *
 from .model import BESS_JPL
 
 logger = logging.getLogger(__name__)
 
-def process_BESS_table(input_df: DataFrame) -> DataFrame:
+def process_BESS_table(
+        input_df: DataFrame,
+        C4_fraction_scale_factor: float = C4_FRACTION_SCALE_FACTOR) -> DataFrame:
     ST_C = np.array(input_df.ST_C).astype(np.float64)
     NDVI = np.array(input_df.NDVI).astype(np.float64)
 
@@ -23,28 +26,185 @@ def process_BESS_table(input_df: DataFrame) -> DataFrame:
         Ta_C = np.array(input_df.Ta).astype(np.float64)
 
     RH = np.array(input_df.RH).astype(np.float64)
-    # Rn = np.array(input_df.Rn).astype(np.float64)
-    # Topt = np.array(input_df.Topt).astype(np.float64)
-    # fAPARmax = np.array(input_df.fAPARmax).astype(np.float64)
-
-    # fAPARmax = np.where(fAPARmax == 0, np.nan, fAPARmax).astype(np.float64)
-
-    # if "G" in input_df:
-    #     G = np.array(input_df.G).astype(np.float64)
-    # else:
-    #     G = calculate_SEBAL_soil_heat_flux(
-    #         Rn=Rn,
-    #         ST_C=ST_C,
-    #         NDVI=NDVI,
-    #         albedo=albedo
-    #     ).astype(np.float64)
+
+    if "elevation_km" in input_df:
+        elevation_km = np.array(input_df.elevation_km).astype(np.float64)
+    else:
+        elevation_km = None
+
+    if "NDVI_minimum" in input_df:
+        NDVI_minimum = np.array(input_df.NDVI_minimum).astype(np.float64)
+    else:
+        NDVI_minimum = None
+
+    if "NDVI_maximum" in input_df:
+        NDVI_maximum = np.array(input_df.NDVI_maximum).astype(np.float64).astype(np.float64)
+    else:
+        NDVI_maximum = None
+    
+    if "C4_fraction" in input_df:
+        C4_fraction = np.array(input_df.C4_fraction).astype(np.float64)
+    else:
+        C4_fraction = None
+
+    if "carbon_uptake_efficiency" in input_df:
+        carbon_uptake_efficiency = np.array(input_df.carbon_uptake_efficiency).astype(np.float64)
+    else:
+        carbon_uptake_efficiency = None
+
+    if "kn" in input_df:
+        kn = np.array(input_df.kn).astype(np.float64)
+    else:
+        kn = None
+    
+    if "peakVCmax_C3" in input_df:
+        peakVCmax_C3 = np.array(input_df.peakVCmax_C3).astype(np.float64)
+    else:
+        peakVCmax_C3 = None
+
+    if "peakVCmax_C4" in input_df:
+        peakVCmax_C4 = np.array(input_df.peakVCmax_C4).astype(np.float64)
+    else:
+        peakVCmax_C4 = None
+    
+    if "ball_berry_slope_C3" in input_df:
+        ball_berry_slope_C3 = np.array(input_df.ball_berry_slope_C3).astype(np.float64)
+    else:
+        ball_berry_slope_C3 = None
     
+    if "ball_berry_slope_C4" in input_df:
+        ball_berry_slope_C4 = np.array(input_df.ball_berry_slope_C4).astype(np.float64)
+    else:
+        ball_berry_slope_C4 = None
+
+    if "ball_berry_intercept_C3" in input_df:
+        ball_berry_intercept_C3 = np.array(input_df.ball_berry_intercept_C3).astype(np.float64)
+    else:
+        ball_berry_intercept_C3 = None
+
+    if "KG_climate" in input_df:
+        KG_climate = np.array(input_df.KG_climate)
+    else:
+        KG_climate = None
+
+    if "CI" in input_df:
+        CI = np.array(input_df.CI).astype(np.float64)
+    else:
+        CI = None
+
+    if "canopy_height_meters" in input_df:
+        canopy_height_meters = np.array(input_df.canopy_height_meters).astype(np.float64)
+    else:
+        canopy_height_meters = None
+
+    if "COT" in input_df:
+        COT = np.array(input_df.COT).astype(np.float64)
+    else:
+        COT = None
+
+    if "AOT" in input_df:
+        AOT = np.array(input_df.AOT).astype(np.float64)
+    else:
+        AOT = None
+
+    if "Ca" in input_df:
+        Ca = np.array(input_df.Ca).astype(np.float64)
+    else:
+        Ca = None
+
+    if "wind_speed_mps" in input_df:
+        wind_speed_mps = np.array(input_df.wind_speed_mps).astype(np.float64)
+    else:
+        wind_speed_mps = None
+
+    if "vapor_gccm" in input_df:
+        vapor_gccm = np.array(input_df.vapor_gccm).astype(np.float64)
+    else:
+        vapor_gccm = None
+    
+    if "ozone_cm" in input_df:
+        ozone_cm = np.array(input_df.ozone_cm).astype(np.float64)
+    else:
+        ozone_cm = 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 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")
+    time_UTC = pd.to_datetime(input_df.time_UTC).tolist()
+    logger.info("completed extracting time from PT-JPL-SM input table")
+
     results = BESS_JPL(
+        geometry=geometry,
+        time_UTC=time_UTC,
         ST_C=ST_C,
         albedo=albedo,
         NDVI=NDVI,
         Ta_C=Ta_C,
-        RH=RH
+        RH=RH,
+        elevation_km=elevation_km,
+        NDVI_minimum=NDVI_minimum,
+        NDVI_maximum=NDVI_maximum,
+        C4_fraction=C4_fraction,
+        carbon_uptake_efficiency=carbon_uptake_efficiency,
+        kn=kn,
+        peakVCmax_C3=peakVCmax_C3,
+        peakVCmax_C4=peakVCmax_C4,
+        ball_berry_slope_C3=ball_berry_slope_C3,
+        ball_berry_slope_C4=ball_berry_slope_C4,
+        ball_berry_intercept_C3=ball_berry_intercept_C3,
+        KG_climate=KG_climate,
+        CI=CI,
+        canopy_height_meters=canopy_height_meters,
+        COT=COT,
+        AOT=AOT,
+        Ca=Ca,
+        wind_speed_mps=COT * 0 + 7.4,
+        vapor_gccm=vapor_gccm,
+        ozone_cm=ozone_cm,
+        albedo_visible=albedo,
+        albedo_NIR=albedo,
+        C4_fraction_scale_factor=C4_fraction_scale_factor
     )
 
     output_df = input_df.copy()

BESS_JPL/verify.py

@@ -0,0 +1,72 @@
+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_BESS_inputs import load_ECOv002_calval_BESS_inputs
+    from .process_BESS_table import process_BESS_table
+    import os
+
+    # Load input and output tables
+    input_df = load_ECOv002_calval_BESS_inputs()
+    module_dir = os.path.dirname(os.path.abspath(__file__))
+    output_file_path = os.path.join(module_dir, "ECOv002-cal-val-BESS-JPL-outputs.csv")
+    output_df = pd.read_csv(output_file_path)
+
+    # Run the model on the input table
+    model_df = process_BESS_table(input_df)
+
+    # Columns to compare (model outputs)
+    output_columns = [
+        "G_Wm2",
+        "Rn_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

BESS_JPL/version.py

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

{bess_jpl-1.17.0.dist-info → bess_jpl-1.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BESS-JPL
-Version: 1.17.0
+Version: 1.18.0
 Summary: Breathing Earth System Simulator (BESS) Gross Primary Production (GPP) and Evapotranspiration (ET) Model Python
 Author-email: Gregory Halverson <gregory.h.halverson@jpl.nasa.gov>
 Project-URL: Homepage, https://github.com/JPL-Evapotranspiration-Algorithms/BESS-JPL
@@ -10,15 +10,18 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: check-distribution
-Requires-Dist: FLiESANN>=1.5.0
+Requires-Dist: ECOv002-calval-tables>=1.6.0
+Requires-Dist: FLiESANN>=1.6.1
 Requires-Dist: gedi-canopy-height>=1.1.0
 Requires-Dist: GEOS5FP>=1.1.1
-Requires-Dist: koppengeiger>=1.0.4
-Requires-Dist: MODISCI>=1.3.0
+Requires-Dist: koppengeiger>=1.1.0
+Requires-Dist: MODISCI>=1.4.0
+Requires-Dist: monte-carlo-sensitivity
 Requires-Dist: NASADEM>=1.3.0
 Requires-Dist: numpy
-Requires-Dist: rasters
-Requires-Dist: solar-apparent-time>=1.3.2
+Requires-Dist: rasters>=1.9.0
+Requires-Dist: seaborn
+Requires-Dist: solar-apparent-time>=1.5.3
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pytest>=6.0; extra == "dev"

{bess_jpl-1.17.0.dist-info → bess_jpl-1.18.0.dist-info}/RECORD

@@ -1,15 +1,21 @@
-BESS_JPL/BESS_JPL.py,sha256=CTby93_HwhONe2NOlt-8DuqDH7jL9mAc3euuzbouANg,1365
+BESS_JPL/BESS_JPL.py,sha256=QfeMnPtlfjgugCYJVhpySP2e4OsD_FClTgS2WactAsA,1582
 BESS_JPL/C3_photosynthesis.py,sha256=-ormDycaWttCOoYJdOoOV_zlM6n0nxkgXxj7fyH_mIs,2760
 BESS_JPL/C4_fraction.jpeg,sha256=ECaEYWA8MnNd5z0Yq3beeUCR93KtTDxM8MrH-YYon3Y,2746
 BESS_JPL/C4_fraction.tif,sha256=DFS-J08JCjnf0hi_T_dFridAegVTiU3FGyMBjS9yc1w,25446
+BESS_JPL/C4_fraction.tif.aux.xml,sha256=5Ytn5UtZdGWQUKNmg_kiOU2zRQsm82sY7bq-j3TS1QY,358
 BESS_JPL/C4_photosynthesis.py,sha256=kITtT2kW1JkYY5v8wpMUhmxfBaJMr_uGk6go5P6w0ag,2029
+BESS_JPL/ECOv002-cal-val-BESS-JPL-inputs.csv,sha256=YwBaHvBXLDhCZySwwfnyhv962j5IH_YxhHex115aVKs,1247281
+BESS_JPL/ECOv002-cal-val-BESS-JPL-outputs.csv,sha256=qxJElgt1PvZYNaQsa1XaeIDcZ-1WtbCXPjblX8-jLFk,1423082
+BESS_JPL/ECOv002-static-tower-BESS-JPL-inputs.csv,sha256=LAVetRyuvyznQXPW7xkzBR0_UC35SCNFg6ukH5016dI,35585
+BESS_JPL/ECOv002_calval_BESS_inputs.py,sha256=UaGhhPQOqly0JuiM86aJAtagNYvovQViKW1tdAv5ElA,606
+BESS_JPL/ECOv002_static_tower_BESS_inputs.py,sha256=pJEindmNfm1wY0Ih-O4WyZtCwWF-NZdh7VK_aE2S-sY,621
 BESS_JPL/FVC_from_NDVI.py,sha256=LYI1ESsrO8UxlPOr_dxJYDeUsrwjVAwrV_OhL-tcAWc,567
 BESS_JPL/LAI_from_NDVI.py,sha256=uwV1voc2q45hmsSHzIhehA3ZHLivzSeoST-ht9ecSIE,783
 BESS_JPL/NDVI_maximum.jpeg,sha256=6kc0-eE_WOU31bUztdjoWsZ3ZmqHAG-ZwS7lMiZyBGA,763946
 BESS_JPL/NDVI_maximum.tif,sha256=yRgdpB-xoVNMveIUapCrnGAwHX7WkH6pVXu4HECuFfc,19664541
 BESS_JPL/NDVI_minimum.jpeg,sha256=AfpRU8PikwExBJ2IdcFKewg6aTcp3gx3y3EQMzeA7vg,644871
 BESS_JPL/NDVI_minimum.tif,sha256=wPV0CFfQSLfiTAEDlwIAI857pA7aw0iqWhVlOAZFsJg,18762242
-BESS_JPL/__init__.py,sha256=ilP6rzKsWrha-lUAtgU-k5oSDCZt0s0hEOOJzyPmsGc,217
+BESS_JPL/__init__.py,sha256=UaK3mWbc5jNoA4kNzIWF9h7CQs64O_chKrpuxNkH48o,95
 BESS_JPL/ball_berry_intercept_C3.jpeg,sha256=c8jlRD3i8cnWXQNRUfyNTuObEpptcG6p6kQd2RGMK70,634200
 BESS_JPL/ball_berry_intercept_C3.tif,sha256=O7ATUIKtXcIjkUI2lloTiHAgvRk4gWyWjYGh5Xc_CRY,1026642
 BESS_JPL/ball_berry_slope_C3.jpeg,sha256=KdFUYG4h1nRNb_eK7w-M2kqChJnhbcGmal9Z2Jos1nI,225597
@@ -23,11 +29,11 @@ BESS_JPL/canopy_shortwave_radiation.py,sha256=TzDGFFBVHcZ3s5v-R9pQYeW9PPvYDQ168V
 BESS_JPL/carbon_uptake_efficiency.jpeg,sha256=wz2cLk_4-DRdF71xR2c-cx1MsE0CH-EDWjs2pDJcRF0,704540
 BESS_JPL/carbon_uptake_efficiency.tif,sha256=Nnc8h2ImU6_sip0WzDh3q0BRoBe-CfCbwzDtYo5BSog,819269
 BESS_JPL/carbon_water_fluxes.py,sha256=T1E1AHne3lYvkEoasqlM4oLxoSWLWmeJxy1BzrVdPUw,12987
-BESS_JPL/constants.py,sha256=tOYubq17dnLVKhtTI0CJUQAEeROE4KeSBpOVBqZprUU,131
+BESS_JPL/constants.py,sha256=pkIfSXa8lOpolcjOPXK_NwGcw3IVNgCp9uOmiOT_R3w,203
 BESS_JPL/interpolate_C3_C4.py,sha256=adIyk03Yt6SJ_jFCUm6ivK9QpZYw10C3wJKpx1O56Pk,394
 BESS_JPL/kn.jpeg,sha256=wsI40jabT9_iPpQmOxd3GZzfAN7oZ2DubiARmULFUS0,854097
 BESS_JPL/kn.tif,sha256=nZAIAms7LRDVsadxa4z8yRqOudWu3AjJSm6l1T3ywuY,819988
-BESS_JPL/load_C4_fraction.py,sha256=g1NpACWIKhq9TtABqHLGvxxSFwMZ9vb27nanVE8Sf1A,493
+BESS_JPL/load_C4_fraction.py,sha256=qemgzsyDVKvzvql1p_N7g23L8KYvbLw-qxjWlUC3p_Q,624
 BESS_JPL/load_NDVI_maximum.py,sha256=CADnbDULc5qW0oR7UgNN9pM0oplz7QMf8Ki09_fbj-o,401
 BESS_JPL/load_NDVI_minimum.py,sha256=RZaLXKxJe2ViEvj76_l-YSLIMyjo54nP4oAe-NEvACs,401
 BESS_JPL/load_ball_berry_intercept_C3.py,sha256=6auXZHej127rhUCFXe7vdEg9C4CosFSHLTcdqKs06Ls,388
@@ -38,16 +44,21 @@ BESS_JPL/load_kn.py,sha256=39RkQkkdmey0IPInziJI0kSiI8alRk5Hz42pzm-qihU,346
 BESS_JPL/load_peakVCmax_C3.py,sha256=A-Wg4PjPgogfpRsAMo6ZNEXM7G3KbnF7ZRV3k_jTtEA,401
 BESS_JPL/load_peakVCmax_C4.py,sha256=iVmJTitkMkB4AjfjanAi3yv1lWO4sSF6J7cjuRmaCwU,401
 BESS_JPL/meteorology.py,sha256=xIPQnIk9wGJPy8esJyxn35d6c_7UyiNuWTJXDnuSwf8,6995
-BESS_JPL/model.py,sha256=clIpapmr_i-oZAvc-4TdUDIHumoehsaYJWZNmVhBBuw,22993
+BESS_JPL/model.py,sha256=WurAzTeyWhoc_LwCZNqm5iDfkWNVWWlHDp5EveNjE1A,24365
 BESS_JPL/peakVCmax_C3.jpeg,sha256=nVvwLx8JyRhtm5lWRW93HLz0mInshEdOCJ1tAdcFqa8,1006133
 BESS_JPL/peakVCmax_C3.tif,sha256=ax6wCOPc_ovgJJl9YRjPWNY13OCGlzs2djXqwob_U7A,1583598
 BESS_JPL/peakVCmax_C4.jpeg,sha256=s7dhpcD573KW9Se4mejDeSzbSHqPtQY2EL6KJKt7ZIo,961497
 BESS_JPL/peakVCmax_C4.tif,sha256=EST4_yy-HHYmazIv--RePL_bhLejMWql6hoV9EE38ok,1556928
-BESS_JPL/process_BESS_table.py,sha256=TYsDEZNELGdUc0xkB1MRQIDkVonNL5d49q7Zl1iaJvo,1472
+BESS_JPL/process_BESS_table.py,sha256=CiI_huBJ2R578unMqDMb9dPQUyDuscEd_vqK0-6PHXM,6941
 BESS_JPL/soil_energy_balance.py,sha256=5TKDVkKYJ8jhjuiwbRva_03fi_0gTM0IAKbSm4WhWnY,944
-BESS_JPL/version.txt,sha256=-Q2F9kDoBjnO1g1dZcNwbI4pu99GLJDvdHkxmPdU4JU,6
-bess_jpl-1.17.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-bess_jpl-1.17.0.dist-info/METADATA,sha256=3906m_oz7FCNHjyaq8IKvdIFLw1oBZQdz-5Zrc6R6MQ,6347
-bess_jpl-1.17.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bess_jpl-1.17.0.dist-info/top_level.txt,sha256=GaKnzt-BBktYn1o-w4Qzh_jHxse4Y3ACOxZQrB2ufhc,9
-bess_jpl-1.17.0.dist-info/RECORD,,
+BESS_JPL/verify.py,sha256=kNXSsiK1UD_gPRNvb-485q1lpq2wUQ8VEtXJGZRKTL8,3075
+BESS_JPL/version.py,sha256=oPRGJspBmrZU7gLv4L_3WPX3aGwee0inKgfzcyvkXcc,74
+bess_jpl-1.18.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+examples/processing_BESS_with_rasters_and_default_parameters.py,sha256=XDlRJMAoQXFSXS0q7z5l_nMeOxFwsLasyJtrNCm-Kak,2600
+tests/test_import_BESS_JPL.py,sha256=7BNKnKdIMbfUb4JVogXCXgiO7XzK9WF54q2aGXWfv3I,62
+tests/test_import_dependencies.py,sha256=sPZY_G7UaENPzTQUgms5TLsQONxtqVlS7QJlTT1izW8,360
+tests/test_verify.py,sha256=T7l9QIpKwon2bdPmfpL2Ac1B8-a9-WcxLGFDdTWnGVk,151
+bess_jpl-1.18.0.dist-info/METADATA,sha256=YBxpMuwrqQc20HYQrIGA9QbO4HCC7yTy7-0raIsY2HY,6460
+bess_jpl-1.18.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bess_jpl-1.18.0.dist-info/top_level.txt,sha256=NVdh5Igf1HghE2bBB-rc1uYmB5woir8Q-uIjwjjuu2k,24
+bess_jpl-1.18.0.dist-info/RECORD,,

bess_jpl-1.18.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+BESS_JPL
+examples
+tests

examples/processing_BESS_with_rasters_and_default_parameters.py

@@ -0,0 +1,102 @@
+# %% [markdown]
+# # Running BESS for an ECOSTRESS Scene
+# 
+# This is an example of running the artificial neural network emulator of the Breathing Earth Systems Simulator (BESS) corresponding to an ECOsystem Spaceborne Thermal Radiometer Experiment on Space Station (ECOSTRESS) scene.
+
+# %%
+from dateutil import parser
+from matplotlib.colors import LinearSegmentedColormap
+from solar_apparent_time import UTC_to_solar
+import rasters as rt
+from BESS_JPL import BESS_JPL
+import logging
+
+
+# %% [markdown]
+# Here's an example ECOSTRESS surface temperature scene.
+
+# %%
+ST_filename = "ECOv002_L2T_LSTE_34366_004_11SPS_20240728T204025_0712_01_LST.tif"
+ST_cmap = "bwr"
+ST_C = rt.Raster.open(ST_filename, cmap=ST_cmap) - 273.15
+ST_C
+
+# %% [markdown]
+# Let's get the acquisition time of the scene.
+
+# %%
+time_UTC = parser.parse(ST_filename.split("_")[6])
+geometry = ST_C.geometry
+longitude = geometry.centroid_latlon.x
+latitude = geometry.centroid_latlon.y
+time_solar = UTC_to_solar(time_UTC, longitude)
+doy_solar = time_solar.timetuple().tm_yday
+hour_of_day_solar = time_solar.hour + time_solar.minute / 60 + time_solar.second / 3600
+print(f"{time_UTC:%Y-%m-%d %H:%M:%S} UTC")
+print(f"{time_solar:%Y-%m-%d %H:%M:%S} solar apparent time at longitude {longitude}")
+print(f"day of year {doy_solar} at longitude {longitude}")
+print(f"hour of day {hour_of_day_solar} at longitude {longitude}")
+
+# %%
+albedo_filename = "ECOv002_L2T_STARS_11SPS_20240728_0712_01_albedo.tif"
+albedo_cmap = LinearSegmentedColormap.from_list(name="albedo", colors=["black", "white"])
+albedo = rt.Raster.open(albedo_filename, cmap=albedo_cmap)
+albedo
+
+# %%
+NDVI_filename = "ECOv002_L2T_STARS_11SPS_20240728_0712_01_NDVI.tif"
+NDVI = rt. Raster.open(NDVI_filename)
+
+NDVI_COLORMAP_ABSOLUTE = LinearSegmentedColormap.from_list(
+    name="NDVI",
+    colors=[
+        (0, "#0000ff"),
+        (0.4, "#000000"),
+        (0.5, "#745d1a"),
+        (0.6, "#e1dea2"),
+        (0.8, "#45ff01"),
+        (1, "#325e32")
+    ]
+)
+
+NDVI.cmap = NDVI_COLORMAP_ABSOLUTE
+NDVI
+
+# %%
+Ta_filename = "ECOv002_L3T_MET_34366_004_11SPS_20240728T204025_0712_01_Ta.tif"
+Ta_C = rt.Raster.open(Ta_filename)
+Ta_C.cmap = "bwr"
+Ta_C
+
+# %%
+RH_filename = "ECOv002_L3T_MET_34366_004_11SPS_20240728T204025_0712_01_RH.tif"
+RH = rt.Raster.open(RH_filename)
+RH.cmap = "bwr_r"
+RH
+
+# %%
+BESS_results = BESS_JPL(
+    hour_of_day=hour_of_day_solar,
+    day_of_year=doy_solar,
+    geometry=geometry,
+    time_UTC=time_UTC,
+    ST_C=ST_C,
+    NDVI=NDVI,
+    albedo=albedo,
+    Ta_C=Ta_C,
+    RH=RH
+)
+
+# %%
+BESS_results["GPP"]
+
+# %%
+BESS_results["Rn"]
+
+# %%
+BESS_results["LE"]
+
+# %%
+
+
+

tests/test_import_BESS_JPL.py

@@ -0,0 +1,2 @@
+def test_import_BESS_JPL():
+    from BESS_JPL import BESS_JPL

tests/test_import_dependencies.py

@@ -0,0 +1,17 @@
+import pytest
+
+# List of dependencies
+dependencies = [
+    "check_distribution",
+    "FLiESANN",
+    "gedi_canopy_height",
+    "GEOS5FP",
+    "MODISCI",
+    "numpy",
+    "rasters"
+]
+
+# Generate individual test functions for each dependency
+@pytest.mark.parametrize("dependency", dependencies)
+def test_dependency_import(dependency):
+    __import__(dependency)

tests/test_verify.py

@@ -0,0 +1,5 @@
+import pytest
+from BESS_JPL import verify
+
+def test_verify():
+    assert verify(), "Model verification failed: outputs do not match expected results."

BESS_JPL/version.txt

@@ -1 +0,0 @@
-1.15.0

bess_jpl-1.17.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-BESS_JPL