BESS-JPL 1.26.0__py3-none-any.whl

BESS_JPL/process_BESS_table.py

@@ -0,0 +1,365 @@
+import logging
+
+import numpy as np
+import pandas as pd
+import rasters as rt
+from dateutil import parser
+from pandas import DataFrame
+
+# Import functions for calculating solar time
+from solar_apparent_time import calculate_solar_day_of_year, calculate_solar_hour_of_day
+from geopandas import GeoSeries
+from shapely.geometry import Point as ShapelyPoint
+
+from GEOS5FP import GEOS5FP
+
+from .constants import *
+from .model import BESS_JPL
+from .retrieve_BESS_JPL_GEOS5FP_inputs import retrieve_BESS_JPL_GEOS5FP_inputs
+
+logger = logging.getLogger(__name__)
+
+def _is_notebook() -> bool:
+    """Check if code is running in a Jupyter notebook environment."""
+    try:
+        from IPython import get_ipython
+        shell = get_ipython().__class__.__name__
+        if shell == 'ZMQInteractiveShell':
+            return True   # Jupyter notebook or qtconsole
+        elif shell == 'TerminalInteractiveShell':
+            return False  # Terminal running IPython
+        else:
+            return False  # Other type (?)
+    except (ImportError, NameError):
+        return False      # Probably standard Python interpreter
+
+def process_BESS_table(
+        input_df: DataFrame,
+        GEOS5FP_connection: GEOS5FP = None,
+        C4_fraction_scale_factor: float = C4_FRACTION_SCALE_FACTOR,
+        verbose: bool = None,
+        offline_mode: bool = False) -> DataFrame:
+    # Set verbose default based on environment if not explicitly provided
+    if verbose is None:
+        verbose = not _is_notebook()
+    
+    ST_C = np.array(input_df.ST_C).astype(np.float64)
+    NDVI = np.array(input_df.NDVI).astype(np.float64)
+
+    NDVI = np.where(NDVI > 0.06, NDVI, np.nan).astype(np.float64)
+
+    albedo = np.array(input_df.albedo).astype(np.float64)
+    
+    if "PAR_albedo" in input_df:
+        PAR_albedo = np.array(input_df.PAR_albedo).astype(np.float64)
+    else:
+        PAR_albedo = None
+        
+    if "NIR_albedo" in input_df:
+        NIR_albedo = np.array(input_df.NIR_albedo).astype(np.float64)
+    else:
+        NIR_albedo = None
+    
+    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)
+
+    RH = np.array(input_df.RH).astype(np.float64)
+
+    if "elevation_m" in input_df:
+        elevation_m = np.array(input_df.elevation_m).astype(np.float64)
+        elevation_km = elevation_m / 1000
+    elif "elevation_km" in input_df:
+        elevation_km = np.array(input_df.elevation_km).astype(np.float64)
+        elevation_m = elevation_km * 1000
+    else:
+        elevation_km = None
+        elevation_m = 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:
+        # Default to 400 ppm when Ca is not provided
+        Ca = np.full_like(ST_C, 400.0, dtype=np.float64)
+
+    if "wind_speed_mps" in input_df:
+        wind_speed_mps = np.array(input_df.wind_speed_mps).astype(np.float64)
+        # Apply default wind speed of 7.4 m/s when wind speed is 0 or very low
+        # to avoid numerical instability in aerodynamic resistance calculations
+        # wind_speed_mps = np.where(wind_speed_mps < 0.1, 7.4, wind_speed_mps)
+    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 temperature defaults
+    if "canopy_temperature_C" in input_df:
+        canopy_temperature_C = np.array(input_df.canopy_temperature_C).astype(np.float64)
+    else:
+        # Default to surface temperature when canopy temperature is not provided
+        canopy_temperature_C = ST_C.copy()
+
+    if "soil_temperature_C" in input_df:
+        soil_temperature_C = np.array(input_df.soil_temperature_C).astype(np.float64)
+    else:
+        # Default to surface temperature when soil temperature is not provided
+        soil_temperature_C = ST_C.copy()
+
+    # --- Handle geometry and time columns ---
+    import pandas as pd
+    from rasters import MultiPoint, WGS84
+    # from shapely.geometry import Point
+    from rasters 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 BESS input table")
+
+    if "geometry" in input_df:
+        # Convert Point objects to a list of Points
+        if hasattr(input_df.geometry.iloc[0], "x") and hasattr(input_df.geometry.iloc[0], "y"):
+            geometry = [Point(pt.x, pt.y) for pt in input_df.geometry]
+        else:
+            geometry = [Point(pt) for pt in input_df.geometry]
+    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 = [Point(lon[i], lat[i]) for i in range(len(lat))]
+    else:
+        raise KeyError("Input DataFrame must contain either 'geometry' or both 'lat' and 'lon' columns.")
+
+    logger.info("completed extracting geometry from BESS input table")
+
+    logger.info("started extracting time from BESS input table")
+    time_UTC_list = pd.to_datetime(input_df.time_UTC).tolist()
+    
+    # Calculate day_of_year and hour_of_day for each point
+    day_of_year_list = []
+    hour_of_day_list = []
+    
+    for i, (time_utc, geom) in enumerate(zip(time_UTC_list, geometry)):
+        # Create a GeoSeries with a Shapely Point (lon, lat order)
+        shapely_point = ShapelyPoint(geom.x, geom.y)
+        geoseries = GeoSeries([shapely_point])
+        doy = calculate_solar_day_of_year(time_UTC=time_utc, geometry=geoseries)
+        hod = calculate_solar_hour_of_day(time_UTC=time_utc, geometry=geoseries)
+        # Extract scalar values if returned as arrays
+        doy_scalar = doy[0] if hasattr(doy, '__getitem__') else doy
+        hod_scalar = hod[0] if hasattr(hod, '__getitem__') else hod
+        day_of_year_list.append(doy_scalar)
+        hour_of_day_list.append(hod_scalar)
+    
+    # Convert to numpy arrays (1D)
+    day_of_year = np.array(day_of_year_list)
+    hour_of_day = np.array(hour_of_day_list)
+    
+    # Convert list of rasters.Point to MultiPoint for compatibility with FLiESANN and other functions
+    from rasters import MultiPoint
+    # Extract (x, y) tuples from rasters.Point objects
+    point_tuples = [(pt.x, pt.y) for pt in geometry]
+    geometry_multipoint = MultiPoint(point_tuples)
+    
+    # Check if all times are the same
+    if len(set(time_UTC_list)) == 1:
+        # All timestamps are identical, use single datetime
+        time_UTC = time_UTC_list[0]
+    else:
+        # Different timestamps per point, keep as list
+        time_UTC = time_UTC_list
+
+    BESS_GEOS5FP_inputs = retrieve_BESS_JPL_GEOS5FP_inputs(
+        time_UTC=time_UTC,
+        geometry=geometry_multipoint,
+        albedo=albedo,
+        GEOS5FP_connection=GEOS5FP_connection,
+        Ta_C=Ta_C,
+        RH=RH,
+        COT=COT,
+        AOT=AOT,
+        vapor_gccm=vapor_gccm,
+        ozone_cm=ozone_cm,
+        PAR_albedo=PAR_albedo,
+        NIR_albedo=albedo,
+        Ca=Ca,
+        wind_speed_mps=wind_speed_mps,
+        verbose=verbose,
+        offline_mode=offline_mode
+    )
+    
+    albedo = BESS_GEOS5FP_inputs['albedo']
+    Ta_C = BESS_GEOS5FP_inputs['Ta_C']
+    RH = BESS_GEOS5FP_inputs['RH']
+    COT = BESS_GEOS5FP_inputs['COT']
+    AOT = BESS_GEOS5FP_inputs['AOT']
+    vapor_gccm = BESS_GEOS5FP_inputs['vapor_gccm']
+    ozone_cm = BESS_GEOS5FP_inputs['ozone_cm']
+    PAR_albedo = BESS_GEOS5FP_inputs['PAR_albedo']
+    NIR_albedo = BESS_GEOS5FP_inputs['NIR_albedo']
+    Ca = BESS_GEOS5FP_inputs['Ca']
+    wind_speed_mps = BESS_GEOS5FP_inputs['wind_speed_mps']
+    
+    logger.info("completed extracting time from BESS input table")
+
+    results = BESS_JPL(
+        geometry=geometry_multipoint,
+        time_UTC=time_UTC,
+        day_of_year=day_of_year,
+        hour_of_day=hour_of_day,
+        ST_C=ST_C,
+        albedo=albedo,
+        NDVI=NDVI,
+        Ta_C=Ta_C,
+        RH=RH,
+        elevation_m=elevation_m,
+        NDVI_minimum=NDVI_minimum,
+        NDVI_maximum=NDVI_maximum,
+        C4_fraction=C4_fraction,
+        carbon_uptake_efficiency=carbon_uptake_efficiency,
+        kn=kn,
+        peakVCmax_C3_μmolm2s1=peakVCmax_C3,
+        peakVCmax_C4_μmolm2s1=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=wind_speed_mps,
+        vapor_gccm=vapor_gccm,
+        ozone_cm=ozone_cm,
+        PAR_albedo=albedo,
+        NIR_albedo=albedo,
+        canopy_temperature_C=canopy_temperature_C,
+        soil_temperature_C=soil_temperature_C,
+        C4_fraction_scale_factor=C4_fraction_scale_factor,
+        GEOS5FP_connection=GEOS5FP_connection,
+        offline_mode=offline_mode
+    )
+
+    output_df = input_df.copy()
+
+    # Collect new columns to avoid DataFrame fragmentation
+    new_columns = {}
+    for key, value in results.items():
+        # Skip non-array-like objects (e.g., MultiPoint geometry)
+        if hasattr(value, '__len__') and not isinstance(value, (str, MultiPoint)):
+            try:
+                new_columns[key] = value
+            except (ValueError, TypeError):
+                # Skip values that can't be assigned to DataFrame
+                logger.warning(f"Skipping assignment of key '{key}' to output DataFrame")
+                continue
+        elif isinstance(value, (int, float, np.number)):
+            # Handle scalar values
+            new_columns[key] = value
+
+    # Add all new columns at once using concat to avoid fragmentation
+    if new_columns:
+        output_df = pd.concat([output_df, pd.DataFrame(new_columns, index=output_df.index)], axis=1)
+
+    return output_df

BESS_JPL/process_paw_and_gao_LE.py

@@ -0,0 +1,50 @@
+import numpy as np
+
+def process_paw_and_gao_LE(
+        Rn: np.ndarray,  # net radiation (W m-2)
+        Ta_C: np.ndarray,  # air temperature (C)
+        VPD_Pa: np.ndarray,  # vapor pressure (Pa)
+        Cp: np.ndarray,  # specific heat of air (J kg-1 K-1)
+        rhoa: np.ndarray,  # air density (kg m-3)
+        gamma: np.ndarray,  # psychrometric constant (Pa K-1)
+        Rc: np.ndarray,
+        rs: np.ndarray,
+        desTa: np.ndarray,
+        ddesTa: np.ndarray) -> np.ndarray:
+    """
+    :param Rn:  net radiation (W m-2)
+    :param Ta_C:  air temperature (C)
+    :param VPD_Pa:  vapor pressure (Pa)
+    :param Cp:  specific heat of air (J kg-1 K-1)
+    :param rhoa:  air density (kg m-3)
+    :param gamma:  psychrometric constant (Pa K-1)
+    :param Rc:
+    :param rs:
+    :param desTa:
+    :param ddesTa:
+    :return:  latent heat flux (W m-2)
+    """
+    # To reduce redundant computation
+    rc = rs
+    ddesTa_Rc2 = ddesTa * Rc * Rc
+    gamma_Rc_rc = gamma * (Rc + rc)
+    rhoa_Cp_gamma_Rc_rc = rhoa * Cp * gamma_Rc_rc
+
+    # Solution (Paw and Gao 1988)
+    a = 1.0 / 2.0 * ddesTa_Rc2 / rhoa_Cp_gamma_Rc_rc  # Eq. (10b)
+    b = -1.0 - Rc * desTa / gamma_Rc_rc - ddesTa_Rc2 * Rn / rhoa_Cp_gamma_Rc_rc  # Eq. (10c)
+    c = rhoa * Cp / gamma_Rc_rc * VPD_Pa + desTa * Rc / gamma_Rc_rc * Rn + 1.0 / 2.0 * ddesTa_Rc2 / rhoa_Cp_gamma_Rc_rc * Rn * Rn  # Eq. (10d) in Paw and Gao (1988)
+
+    # calculate latent heat flux
+    LE = (-b + np.sign(b) * np.sqrt(b * b - 4.0 * a * c)) / (2.0 * a)  # Eq. (10a)
+    LE = np.real(LE)
+
+    # Constraints
+    # LE[LE > Rn] = Rn[LE > Rn]
+    LE = np.clip(LE, 0, Rn)
+    # LE[Rn < 0.0] = 0.0
+    # LE[LE < 0.0] = 0.0
+    # LE[Ta < 0.0] = 0.0  # Now using Celsius
+    LE = np.where(Ta_C < 0.0, 0, LE)
+
+    return LE

BESS_JPL/retrieve_BESS_JPL_GEOS5FP_inputs.py

@@ -0,0 +1,257 @@
+from typing import Union, List
+from datetime import datetime
+import numpy as np
+
+from rasters import Raster, RasterGeometry
+import rasters as rt
+
+from check_distribution import check_distribution
+
+from GEOS5FP import GEOS5FP
+
+import logging
+logger = logging.getLogger(__name__)
+
+class MissingOfflineParameter(Exception):
+    """Custom exception for missing offline parameters."""
+    pass
+
+def retrieve_BESS_JPL_GEOS5FP_inputs(
+        time_UTC: Union[datetime, List[datetime]],
+        geometry: RasterGeometry,
+        albedo: Union[Raster, np.ndarray],
+        GEOS5FP_connection: GEOS5FP = None,
+        Ta_C: Union[Raster, np.ndarray] = None,
+        RH: Union[Raster, np.ndarray] = None,
+        COT: Union[Raster, np.ndarray] = None,
+        AOT: Union[Raster, np.ndarray] = None,
+        vapor_gccm: Union[Raster, np.ndarray] = None,
+        ozone_cm: Union[Raster, np.ndarray] = None,
+        PAR_albedo: Union[Raster, np.ndarray] = None,
+        NIR_albedo: Union[Raster, np.ndarray] = None,
+        Ca: Union[Raster, np.ndarray] = None,
+        wind_speed_mps: Union[Raster, np.ndarray] = None,
+        resampling: str = "cubic",
+        verbose: bool = False,
+        offline_mode: bool = False) -> dict:
+    """
+    Retrieve GEOS-5 FP meteorological inputs for BESS-JPL model.
+    
+    This function retrieves meteorological variables from GEOS-5 FP data products
+    when they are not provided as inputs. All missing variables are retrieved in
+    a single efficient `.query()` call to minimize network requests and improve
+    performance.
+    
+    Parameters
+    ----------
+    time_UTC : Union[datetime, List[datetime]]
+        UTC time for data retrieval. Can be a single datetime or list of datetimes
+        for point-by-point queries.
+    geometry : RasterGeometry
+        Raster geometry for spatial operations
+    albedo : Union[Raster, np.ndarray]
+        Surface albedo [-], used for albedo calculations
+    GEOS5FP_connection : GEOS5FP, optional
+        Connection to GEOS-5 FP meteorological data. If None, creates new connection.
+    Ta_C : Union[Raster, np.ndarray], optional
+        Air temperature [°C]. Retrieved from GEOS-5 FP if None.
+    RH : Union[Raster, np.ndarray], optional
+        Relative humidity [fraction, 0-1]. Retrieved from GEOS-5 FP if None.
+    COT : Union[Raster, np.ndarray], optional
+        Cloud optical thickness [-]. Retrieved from GEOS-5 FP if None.
+    AOT : Union[Raster, np.ndarray], optional
+        Aerosol optical thickness [-]. Retrieved from GEOS-5 FP if None.
+    vapor_gccm : Union[Raster, np.ndarray], optional
+        Water vapor [g cm⁻²]. Retrieved from GEOS-5 FP if None.
+    ozone_cm : Union[Raster, np.ndarray], optional
+        Ozone column [cm]. Retrieved from GEOS-5 FP if None.
+    albedo_visible : Union[Raster, np.ndarray], optional
+        Surface albedo in visible wavelengths (400-700 nm) [-]. 
+        Calculated from GEOS-5 FP albedo products if None.
+    albedo_NIR : Union[Raster, np.ndarray], optional
+        Surface albedo in near-infrared wavelengths [-].
+        Calculated from GEOS-5 FP albedo products if None.
+    Ca : Union[Raster, np.ndarray], optional
+        Atmospheric CO₂ concentration [ppm]. Retrieved from GEOS-5 FP if None.
+    wind_speed_mps : Union[Raster, np.ndarray], optional
+        Wind speed [m s⁻¹]. Retrieved from GEOS-5 FP if None.
+    resampling : str, optional
+        Resampling method for data processing. Default is "cubic".
+    
+    Returns
+    -------
+    dict
+        Dictionary containing all meteorological inputs:
+        - albedo : Surface albedo [-]
+        - Ta_C : Air temperature [°C]
+        - RH : Relative humidity [fraction, 0-1]
+        - COT : Cloud optical thickness [-]
+        - AOT : Aerosol optical thickness [-]
+        - vapor_gccm : Water vapor [g cm⁻²]
+        - ozone_cm : Ozone column [cm]
+        - PAR_albedo : Surface albedo in PAR wavelengths [-]
+        - NIR_albedo : Surface albedo in near-infrared wavelengths [-]
+        - Ca : Atmospheric CO₂ concentration [ppm]
+        - wind_speed_mps : Wind speed [m s⁻¹]
+    
+    Notes
+    -----
+    The visible and NIR albedo are calculated by scaling the input albedo with
+    the ratio of GEOS-5 FP directional albedo products to total albedo.
+    
+    All missing GEOS-5 FP variables are retrieved in a single `.query()` call
+    for optimal performance, reducing network overhead and improving efficiency.
+    
+    When time_UTC is a list, it handles point-by-point queries where each point
+    may have a different datetime.
+    """
+    # Create GEOS-5 FP connection if not provided
+    if GEOS5FP_connection is None:
+        GEOS5FP_connection = GEOS5FP()
+    
+    # Initialize results dictionary
+    results = {}
+    
+    # Add albedo (always required)
+    results["albedo"] = albedo
+    
+    # Add provided inputs to results
+    if Ta_C is not None:
+        results["Ta_C"] = Ta_C
+    if RH is not None:
+        results["RH"] = RH
+    if COT is not None:
+        results["COT"] = COT
+    if AOT is not None:
+        results["AOT"] = AOT
+    if vapor_gccm is not None:
+        results["vapor_gccm"] = vapor_gccm
+    if ozone_cm is not None:
+        results["ozone_cm"] = ozone_cm
+    if PAR_albedo is not None:
+        results["PAR_albedo"] = PAR_albedo
+    if NIR_albedo is not None:
+        results["NIR_albedo"] = NIR_albedo
+    if Ca is not None:
+        results["Ca"] = Ca
+    if wind_speed_mps is not None:
+        results["wind_speed_mps"] = wind_speed_mps
+    
+    # Determine which variables need to be retrieved from GEOS-5 FP
+    variables_to_retrieve = []
+    
+    # Atmospheric parameters (from FLiESANN)
+    if COT is None:
+        variables_to_retrieve.append("COT")
+    if AOT is None:
+        variables_to_retrieve.append("AOT")
+    if vapor_gccm is None:
+        variables_to_retrieve.append("vapor_gccm")
+    if ozone_cm is None:
+        variables_to_retrieve.append("ozone_cm")
+    
+    # Meteorological parameters
+    if Ta_C is None:
+        variables_to_retrieve.append("Ta_C")
+    if RH is None:
+        variables_to_retrieve.append("RH")
+    if Ca is None:
+        variables_to_retrieve.append("CO2SC")
+    if wind_speed_mps is None:
+        variables_to_retrieve.append("wind_speed_mps")
+    
+    # Albedo products needed for visible/NIR calculations
+    if PAR_albedo is None or NIR_albedo is None:
+        variables_to_retrieve.append("ALBEDO")
+    if PAR_albedo is None:
+        variables_to_retrieve.append("ALBVISDR")
+    if NIR_albedo is None:
+        variables_to_retrieve.append("ALBNIRDR")
+    
+    if len(variables_to_retrieve) == 0:
+        logger.info("All GEOS-5 FP inputs provided, no retrieval needed.")
+    else:
+        logger.info(f"Retrieving GEOS-5 FP variables: {', '.join(variables_to_retrieve)}")
+
+    if offline_mode and variables_to_retrieve:
+        raise MissingOfflineParameter(f"missing offline parameters for BESS: {', '.join(variables_to_retrieve)}")
+
+    # Retrieve all missing variables in a single query
+    if variables_to_retrieve:
+        logger.info(f"Retrieving GEOS-5 FP variables: {', '.join(variables_to_retrieve)}")
+        logger.info(f"Time UTC type: {type(time_UTC)}")
+        logger.info(f"Geometry type: {type(geometry)}")
+        if hasattr(time_UTC, '__len__'):
+            logger.info(f"Time UTC length: {len(time_UTC)}")
+        if hasattr(geometry, '__len__'):
+            logger.info(f"Geometry length: {len(geometry)}")
+        
+        retrieved = GEOS5FP_connection.query(
+            target_variables=variables_to_retrieve,
+            time_UTC=time_UTC,
+            geometry=geometry,
+            resampling=resampling,
+            verbose=True  # Enable verbose logging to see progress
+        )
+        
+        logger.info(f"Retrieved keys: {list(retrieved.keys())}")
+        if "CO2SC" in retrieved:
+            logger.info(f"CO2SC in retrieved: {retrieved['CO2SC']}")
+        else:
+            logger.warning("CO2SC not in retrieved dictionary!")
+        
+        # Extract retrieved values and add to results
+        if "COT" in retrieved:
+            results["COT"] = retrieved["COT"]
+        if "AOT" in retrieved:
+            results["AOT"] = retrieved["AOT"]
+        if "vapor_gccm" in retrieved:
+            results["vapor_gccm"] = retrieved["vapor_gccm"]
+        if "ozone_cm" in retrieved:
+            results["ozone_cm"] = retrieved["ozone_cm"]
+        if "Ta_C" in retrieved:
+            results["Ta_C"] = retrieved["Ta_C"]
+            check_distribution(results["Ta_C"], "Ta_C")
+        if "RH" in retrieved:
+            results["RH"] = retrieved["RH"]
+            check_distribution(results["RH"], "RH")
+        if "CO2SC" in retrieved:
+            results["Ca"] = retrieved["CO2SC"]
+            logger.info(f"Retrieved Ca from GEOS-5 FP: {results['Ca']}")
+            logger.info(f"Ca type: {type(results['Ca'])}")
+            if isinstance(results["Ca"], np.ndarray):
+                logger.info(f"Ca shape: {results['Ca'].shape}, dtype: {results['Ca'].dtype}")
+                logger.info(f"Ca has NaN: {np.any(np.isnan(results['Ca']))}")
+            check_distribution(results["Ca"], "Ca")
+        if "wind_speed_mps" in retrieved:
+            results["wind_speed_mps"] = rt.clip(retrieved["wind_speed_mps"], 0.1, None)
+            check_distribution(results["wind_speed_mps"], "wind_speed_mps")
+        
+        # Calculate visible and NIR albedo from retrieved products and add to results
+        if "PAR_albedo" not in results:
+            albedo_NWP = retrieved["ALBEDO"]
+            RVIS_NWP = retrieved["ALBVISDR"]
+            results["PAR_albedo"] = rt.clip(albedo * (RVIS_NWP / albedo_NWP), 0, 1)
+        
+        if "NIR_albedo" not in results:
+            albedo_NWP = retrieved["ALBEDO"]
+            RNIR_NWP = retrieved["ALBNIRDR"]
+            results["NIR_albedo"] = rt.clip(albedo * (RNIR_NWP / albedo_NWP), 0, 1)
+    
+    # Apply default for Ca if not provided and not retrieved
+    if 'Ca' not in results:
+        logger.info("Ca not provided, using default value of 400 ppm")
+        # Create an array of 400.0 with the same shape as albedo
+        if isinstance(albedo, np.ndarray):
+            results['Ca'] = np.full_like(albedo, 400.0, dtype=np.float64)
+        else:
+            results['Ca'] = 400.0
+    
+    # Verify all required keys are present
+    required_keys = ['albedo', 'Ta_C', 'RH', 'COT', 'AOT', 'vapor_gccm', 'ozone_cm', 
+                     'PAR_albedo', 'NIR_albedo', 'Ca', 'wind_speed_mps']
+    missing_keys = [key for key in required_keys if key not in results]
+    if missing_keys:
+        raise ValueError(f"Missing required keys in results: {missing_keys}")
+
+    return results