pyreclaim 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

reclaim/generate_features.py

@@ -2,22 +2,30 @@
 
 from typing import Dict, List
 import pandas as pd
+import geopandas as gpd
+from tqdm import tqdm
+import traceback
+from dask import delayed, compute
+from dask.diagnostics import ProgressBar
 
 # Import from your package structure
 from reclaim.static_features.reservoir_static import reservoir_based_static_features
-from reclaim.static_features.catchment_static import catchment_based_static_features
+from reclaim.static_features.catchment_static import catchment_based_static_features, catchment_based_static_features_multi_reservoir
 from reclaim.dynamic_features.reservoir_dynamic import reservoir_based_dynamic_features
 from reclaim.dynamic_features.catchment_dynamic import catchment_based_dynamic_features
+from reclaim.dynamic_features.utils.ts_aggregate import build_intervals
 from reclaim.derived_features.feature_engineering_and_transformation import engineer_and_transform_features
 
 
-def create_features_per_row(
+def create_features_per_reservoir(
     idx: int,
     observation_period: List[int],
     reservoir_static_params: dict,
-    catchment_static_params: dict,
+    catchment_static_params: dict = None,
     reservoir_dynamic_info: dict = None,
     catchment_dynamic_info: dict = None,
+    time_interval: int = None,
+    feature_engineering: bool = True,
 ) -> pd.DataFrame:
     """
     Compute all static, dynamic, and derived features for a single reservoir observation.
@@ -34,7 +42,7 @@ def create_features_per_row(
         Parameters for reservoir_based_static_features(). Expected keys:
             - obc : float, Original Built Capacity (MCM)
             - hgt : float, Dam Height (m)
-            - mrb : str, Major River Basin, optional
+            - mrb : int, Major River Basin, optional
             - lat : float, Latitude (deg)
             - lon : float, Longitude (deg)
             - by : int, Build Year
@@ -43,7 +51,7 @@ def create_features_per_row(
             - resolution : float, optional
             - aec_df : pd.DataFrame with columns ['area', 'elevation']
 
-    catchment_static_params : dict
+    catchment_static_params : dict, optional
         Parameters for catchment_based_static_features(). Expected keys:
             - ca : float, Catchment Area (sq km)
             - dca : float, Differential Catchment Area (sq km)
@@ -69,6 +77,9 @@ def create_features_per_row(
             - "tmax":   {"path": str, "time_column": str, "data_column": str}
             - "wind":   {"path": str, "time_column": str, "data_column": str}
 
+    time_interval: int, optional
+        Time interval in years between reservoir observations for dynamic feature calculations. The number of rows in the dynamic features will depend on this interval.
+    
     Returns
     -------
     pd.DataFrame
@@ -77,42 +88,88 @@ def create_features_per_row(
         - Catchment static
         - Reservoir dynamic
         - Catchment dynamic
-        - Derived/log-transformed
+        - Derived/log-transformed (if requested)
     """
     
     # --- Observevation period features ---
     osy, oey = observation_period
-    df_obs_period = pd.DataFrame({
-        "idx": [idx],
-        "OSY": [osy],
-        "OEY": [oey]
+    if time_interval is not None:
+        intervals = build_intervals(osy, oey, time_interval)
+    else:
+        intervals = [(osy, oey)]
+    # Create observation period dataframe with rows for each interval with same idx
+    df_obs = pd.DataFrame({
+    "idx": idx,
+    "OSY": [i[0] for i in intervals],
+    "OEY": [i[1] for i in intervals],
     })
 
-    # --- Static features ---
+    # --- Static features (computed ONCE) ---
     df_res_static = reservoir_based_static_features(**reservoir_static_params)
-    df_catch_static = catchment_based_static_features(**catchment_static_params)
-
-    # --- Dynamic features ---
-    df_res_dyn = pd.DataFrame()
-    df_catch_dyn = pd.DataFrame()
+    if catchment_static_params is not None:
+        df_catch_static = catchment_based_static_features(**catchment_static_params)
+    else:
+        df_catch_static = pd.DataFrame()
+    
+    static_block = pd.concat([df_res_static, df_catch_static], axis=1)
+    # Repeat static rows to match number of intervals
+    static_block = pd.concat(
+        [static_block] * len(df_obs),
+        ignore_index=True
+    )
 
-    if reservoir_dynamic_info is not None and observation_period is not None:
-        df_res_dyn = reservoir_based_dynamic_features(reservoir_dynamic_info, observation_period)
+    # --- Dynamic features (computed ONCE - internally handles intervals) ---
+    # Combine dynamic features for all intervals
+    df_res_dyn = (
+        reservoir_based_dynamic_features(
+            reservoir_dynamic_info,
+            intervals,
+        )
+        if reservoir_dynamic_info is not None
+        else pd.DataFrame()
+    )
 
-    if catchment_dynamic_info is not None and observation_period is not None:
-        df_catch_dyn = catchment_based_dynamic_features(catchment_dynamic_info, observation_period)
+    df_catch_dyn = (
+        catchment_based_dynamic_features(
+            catchment_dynamic_info,
+            intervals,
+        )
+        if catchment_dynamic_info is not None
+        else pd.DataFrame()
+    )
     
-    # --- Combine all static + dynamic ---
-    df_combined = pd.concat([df_obs_period, df_res_static, df_catch_static, df_res_dyn, df_catch_dyn], axis=1)
+    # --- Combine all features for all intervals in single dataframe ---
+    df_out = pd.concat(
+        [df_obs, static_block, df_res_dyn, df_catch_dyn],
+        axis=1
+    ).reset_index(drop=True)
 
-    # --- Engineer + log-transform features ---
-    df_final = engineer_and_transform_features(df_combined)
+    # --- Engineer ONLY if requested ---
+    if feature_engineering:
+        df_out = engineer_and_transform_features(df_out)
 
-    return df_final
+    return df_out
 
+@delayed
+def process_one_reservoir(r):
+    try:
+        df = create_features_per_reservoir(
+            idx=r["idx"],
+            observation_period=r["observation_period"],
+            reservoir_static_params=r["reservoir_static_params"],
+            catchment_static_params=None,
+            reservoir_dynamic_info=r.get("reservoir_dynamic_info"),
+            catchment_dynamic_info=r.get("catchment_dynamic_info"),
+            time_interval=r.get("time_interval"),
+            feature_engineering=False,
+        )
+        return r["idx"], df, None
+    except Exception as e:
+        return r["idx"], pd.DataFrame({"idx": [r["idx"]]}), {str(e):traceback.format_exc()}
 
-def create_features_multi(
-    reservoirs_input: List[Dict]
+def create_features_multi_reservoirs(
+    reservoirs_input: List[Dict],
+    error_log: bool = False,
 ) -> pd.DataFrame:
     """
     Compute features for multiple reservoirs using structured input.
@@ -134,25 +191,107 @@ def create_features_multi(
             Parameters for `reservoir_based_dynamic_features()`.
         - `catchment_dynamic_info` : dict
             Parameters for `catchment_based_dynamic_features()`.
-        
+        - `time_interval` : int, optional
+            Time interval in years between reservoir observations for dynamic feature calculations.
 
     Returns
     -------
     pd.DataFrame
-        Combined DataFrame with one row per reservoir observation.
+        Combined DataFrame with one row per reservoir and time intervals
+        in the observation period.
     """
 
-    all_rows = []
-    for idx, reservoir_info in enumerate(reservoirs_input):
-        df_row = create_features_per_row(
-            idx=reservoir_info.get("idx"),
-            observation_period=reservoir_info.get("observation_period"),
-            reservoir_static_params=reservoir_info.get("reservoir_static_params", {}),
-            catchment_static_params=reservoir_info.get("catchment_static_params", {}),
-            reservoir_dynamic_info=reservoir_info.get("reservoir_dynamic_info", None),
-            catchment_dynamic_info=reservoir_info.get("catchment_dynamic_info", None),
-        )
-        all_rows.append(df_row)
+    # -------- Collect catchments first (cheap, no tqdm needed)
+    catchment_rows = []
+
+    for r in reservoirs_input:
+        c = r["catchment_static_params"]
+        catchment_rows.append({
+            "idx": r["idx"],
+            "CA": c["ca"],
+            "DCA": c["dca"],
+            "geometry": c["catchment_geometry"],
+        })
+
+    catchments_gdf = gpd.GeoDataFrame(
+        catchment_rows, geometry="geometry", crs="EPSG:4326"
+    )
+
+    # -------- Compute catchment static ONCE
+    first = reservoirs_input[0]["catchment_static_params"]
 
-    df_all = pd.concat(all_rows, axis=0).reset_index(drop=True)
-    return df_all
+    df_catch_static_all = catchment_based_static_features_multi_reservoir(
+        catchments_gdf,
+        glc_share_path=first["glc_share_path"],
+        hwsd2_path=first["hwsd2_path"],
+        hilda_veg_freq_path=first["hilda_veg_freq_path"],
+        terrain_path=first["terrain_path"],
+    )
+    
+    catch_static_lookup = df_catch_static_all.set_index("idx")
+    # catch_static_lookup = pd.DataFrame()  # Placeholder if not computing
+
+    # -------- Per-reservoir loop (tqdm HERE)
+    tasks = [process_one_reservoir(r) for r in reservoirs_input]
+    with ProgressBar():
+        results = compute(*tasks, scheduler="processes", num_workers=4)
+    
+    all_reservoirs_static_info = []
+    errors = {}
+    
+    for idx, df, err in results:
+        all_reservoirs_static_info.append(df)
+        if err is not None:
+            errors[idx] = err
+
+    # for r in tqdm(
+    #     reservoirs_input,
+    #     total=len(reservoirs_input),
+    #     desc="Generating per-reservoir features",
+    #     unit="reservoir",
+    # ):
+    #     try:
+    #         df = create_features_per_reservoir(
+    #             idx=r["idx"],
+    #             observation_period=r["observation_period"],
+    #             reservoir_static_params=r["reservoir_static_params"],
+    #             catchment_static_params=None,  # already handled
+    #             reservoir_dynamic_info=r.get("reservoir_dynamic_info"),
+    #             catchment_dynamic_info=r.get("catchment_dynamic_info"),
+    #             time_interval=r.get("time_interval"),
+    #             feature_engineering=False,
+    #         )
+    #         all_reservoirs_static_info.append(df)
+    #     except Exception as e:
+    #         errors[r["idx"]] = e
+    #         errors['traceback'] = traceback.print_exc()
+    #         all_reservoirs_static_info.append(
+    #             pd.DataFrame({"idx": r["idx"]})  # Append empty DataFrame for failed reservoir
+    #         )
+            
+            
+
+    # -------- Concatenate static info
+    df_all = pd.concat(all_reservoirs_static_info, ignore_index=True)
+    # CRITICAL: restore logical ordering
+    df_all = df_all.sort_values(
+        by=["idx", "OSY"],   #
+        ascending=[True, True],
+    ).reset_index(drop=True)
+    
+    
+    # -------- Merge static catchment features with dynamic ONCE
+    df_all = df_all.merge(
+        catch_static_lookup,
+        left_on="idx",
+        right_index=True,
+        how="left",
+    )
+
+    # -------- Engineer ONCE
+    df_all = engineer_and_transform_features(df_all)
+    
+    if error_log:
+        return df_all, errors
+    else:
+        return df_all

reclaim/reclaim.py

@@ -1,5 +1,6 @@
 import os
 import pandas as pd
+from pandas.api.types import is_integer_dtype, is_string_dtype
 import numpy as np
 from sklearn.preprocessing import LabelEncoder
 from sklearn.metrics import  r2_score, mean_absolute_error,  root_mean_squared_error
@@ -197,6 +198,14 @@ class Reclaim:
                     "Safer to use DataFrame with feature names."
                 )
             
+        if self.cat_features is not None:
+            for col in self.cat_features:
+                if not (is_integer_dtype(X[col]) or is_string_dtype(X[col])):
+                    raise ValueError(
+                        f"Column {col} must be integer or string type, "
+                        f"found {X[col].dtype}"
+                    )
+            
             
         # Base model predictions
         pred_xgb = self.xgb_model.predict(X)

reclaim/static_features/catchment_static.py

@@ -1,6 +1,39 @@
+import geopandas as gpd
 import pandas as pd
 
-from reclaim.static_features.utils.catchment_agreggate import compute_catchment_aggregate
+from reclaim.static_features.utils.catchment_agreggate import compute_catchment_aggregate, compute_catchment_aggregate_multi_reservoir
+
+# ---- Rename columns to abbreviations
+RENAME_VARIABLE_DICT = {
+    # Land cover
+    "artificial_surfaces_mean": "LCAS",
+    "cropland_mean": "LCC",
+    "grassland_mean": "LCG",
+    "tree_covered_mean": "LCT",
+    "shrubs_covered_mean": "LCS",
+    "aquatic_herbaceous_mean": "LCHV",
+    "mangroves_mean": "LCM",
+    "sparse_vegetation_mean": "LCSV",
+    "bare_soil_mean": "LCBS",
+    "snow_glaciers_mean": "LCSG",
+    "waterbodies_mean": "LCWB",
+    "dominant_class_mode": "DLC",
+    # Soil
+    "COARSE_mean": "COAR",
+    "SAND_mean": "SAND",
+    "SILT_mean": "SILT",
+    "CLAY_mean": "CLAY",
+    "BULK_mean": "BULK",
+    # Terrain
+    "elevation_mean": "ELEV",
+    "slope_mean": "SLOP",
+    "curvature_mean": "CURV",
+    "aspect_mean": "ASP",
+    "hillshade_mean": "HILL",
+    # HILDA (optional, not mapped to abbreviations yet)
+    "vegetation_gain_frequency_mean": "VGF",
+    "vegetation_loss_frequency_mean": "VLF",
+}
 
 def catchment_based_static_features(
     ca: float,
@@ -89,39 +122,81 @@ def catchment_based_static_features(
     merged = pd.concat([glc_df, hwsd_df, hilda_df, terrain_df], axis=1)
     features.update(merged.to_dict(orient="records")[0])
 
-    # ---- Rename columns to abbreviations
-    rename_dict = {
-        # Land cover
-        "artificial_surfaces_mean": "LCAS",
-        "cropland_mean": "LCC",
-        "grassland_mean": "LCG",
-        "tree_covered_mean": "LCT",
-        "shrubs_covered_mean": "LCS",
-        "aquatic_herbaceous_mean": "LCHV",
-        "mangroves_mean": "LCM",
-        "sparse_vegetation_mean": "LCSV",
-        "bare_soil_mean": "LCBS",
-        "snow_glaciers_mean": "LCSG",
-        "waterbodies_mean": "LCWB",
-        "dominant_class_mode": "DLC",
-        # Soil
-        "COARSE_mean": "COAR",
-        "SAND_mean": "SAND",
-        "SILT_mean": "SILT",
-        "CLAY_mean": "CLAY",
-        "BULK_mean": "BULK",
-        # Terrain
-        "elevation_mean": "ELEV",
-        "slope_mean": "SLOP",
-        "curvature_mean": "CURV",
-        "aspect_mean": "ASP",
-        "hillshade_mean": "HILL",
-        # HILDA (optional, not mapped to abbreviations yet)
-        "vegetation_gain_frequency_mean": "VGF",
-        "vegetation_loss_frequency_mean": "VLF",
+    # Apply renaming
+    features_df = pd.DataFrame([features]).rename(columns=RENAME_VARIABLE_DICT)
+
+    return features_df
+
+def catchment_based_static_features_multi_reservoir(
+    catchments_gdf: gpd.GeoDataFrame,
+    glc_share_path: str,
+    hwsd2_path: str,
+    hilda_veg_freq_path: str,
+    terrain_path: str,
+) -> pd.DataFrame:
+    """
+    Compute catchment-based static features for MULTIPLE reservoirs efficiently.
+
+    Parameters
+    ----------
+    catchments_gdf : geopandas.GeoDataFrame
+        Must contain columns:
+            - idx
+            - CA
+            - DCA
+            - geometry
+    glc_share_path : str
+        Path to the GLC-Share NetCDF file (land cover fractions).
+    hwsd2_path : str
+        Path to the HWSD2 NetCDF file (soil composition).
+    hilda_veg_freq_path : str
+        Path to the HILDA vegetation frequency NetCDF file.
+    terrain_path : str
+        Path to the terrain NetCDF file (DEM derivatives).
+
+    Returns
+    -------
+    pd.DataFrame
+        A single-row DataFrame with abbreviations as columns:
+        - CA, DCA, LCAS, LCC, LCG, LCT, LCS, LCHV, LCM, LCSV,
+        LCBS, LCSG, LCWB, DLC, COAR, SAND, SILT, CLAY, BULK,
+        ELEV, SLOP, CURV, ASP, HILL, VGF, VLF
+    """
+
+    base = catchments_gdf[["idx", "CA", "DCA"]].set_index("idx")
+
+    # --- Land cover
+    glc_dict = {
+        "artificial_surfaces": "mean",
+        "cropland": "mean",
+        "grassland": "mean",
+        "tree_covered": "mean",
+        "shrubs_covered": "mean",
+        "aquatic_herbaceous": "mean",
+        "mangroves": "mean",
+        "sparse_vegetation": "mean",
+        "bare_soil": "mean",
+        "snow_glaciers": "mean",
+        "waterbodies": "mean",
+        "dominant_class": "mode",
     }
 
-    # Apply renaming
-    features_df = pd.DataFrame([features]).rename(columns=rename_dict)
+    glc = compute_catchment_aggregate_multi_reservoir(
+        glc_share_path, catchments_gdf, glc_dict
+    )
+
+    hwsd = compute_catchment_aggregate_multi_reservoir(
+        hwsd2_path, catchments_gdf, "mean"
+    )
+
+    hilda = compute_catchment_aggregate_multi_reservoir(
+        hilda_veg_freq_path, catchments_gdf, "mean"
+    )
+
+    terrain = compute_catchment_aggregate_multi_reservoir(
+        terrain_path, catchments_gdf, "mean"
+    )
+
+    df = pd.concat([base, glc, hwsd, hilda, terrain], axis=1)
 
-    return features_df
+    return df.rename(columns=RENAME_VARIABLE_DICT).reset_index()

reclaim/static_features/reservoir_static.py

@@ -1,9 +1,10 @@
 import pandas as pd
+import geopandas as gpd
 from shapely.geometry import Point, Polygon
 import numpy as np
 
 # Import utils
-from reclaim.static_features.utils.flow_length import find_actual_flow_path
+from reclaim.static_features.utils.flow_length import find_actual_flow_path, plot_flow_length_with_reservoir
 from reclaim.static_features.utils.area_perimeter import calculate_length_area_meters
 from reclaim.static_features.utils.aec_shape import concavity_index, mean_curvature, mean_slope
 
@@ -18,7 +19,8 @@ def reservoir_based_static_features(
     reservoir_polygon: Polygon = None,
     inlet_point: Point = None,
     resolution: float = None,
-    aec_df: pd.DataFrame = None
+    aec_df: pd.DataFrame = None,
+    savepath_flowpath_fig: str = None,
 ) -> pd.DataFrame:
     """
     Compute reservoir-based features for RECLAIM input dataset.
@@ -47,6 +49,8 @@ def reservoir_based_static_features(
         Spatial resolution used in flow length calculations.
     aec_df : pd.DataFrame, optional
         Area-Elevation Curve dataframe with columns ['area', 'elevation'].
+    savepath_flowpath_fig : str, optional
+        Path to save the flow path figure, optional.
     
     Returns
     -------
@@ -82,26 +86,51 @@ def reservoir_based_static_features(
     }
 
     # Area and Perimeter
-    if reservoir_polygon is not None:
+    if reservoir_polygon is not None and not reservoir_polygon.is_empty:
         features["RP"], features["RA"] = calculate_length_area_meters(reservoir_polygon, area=True)
         features["RA"] = features["RA"] / 1e6  # m2 → km2
         features["RP"] = features["RP"] / 1e3  # m → km
+    else:
+        features["RP"] = np.nan
+        features["RA"] = np.nan
 
     # Flow Length
     dam_point = Point(lon, lat)
-    if dam_point is not None and reservoir_polygon is not None:
-        _, _, features["FL"], _ = (
-            find_actual_flow_path(dam_point, reservoir_polygon, inlet_point, resolution) 
-        )  
-        if features["FL"]: 
-            features["FL"] = calculate_length_area_meters(features["FL"], area=False) / 1e3  # m → km
-        else:
-            features["FL"] = np.nan
+    if dam_point is not None and reservoir_polygon is not None and not reservoir_polygon.is_empty:
+        try:
+            simplified_reservoir, far_end_point, flow_path, _ = (
+                find_actual_flow_path(dam_point, reservoir_polygon, inlet_point, resolution) 
+            )
+            if savepath_flowpath_fig is not None:
+                plot_flow_length_with_reservoir(
+                    dam_point,
+                    reservoir_polygon,
+                    far_end_point,
+                    flow_path,
+                    simplified_reservoir,
+                    savepath_flowpath_fig
+                )  
+            if flow_path is not None: 
+                gseries = gpd.GeoSeries([flow_path], crs="EPSG:4326")
+                gseries = gseries.to_crs(epsg=3395)
 
+                features["FL"] = gseries.length.iloc[0] / 1e3 # m → km  
+            else:
+                features["FL"] = np.nan
+        except Exception as e:
+            print(f"Flow length calculation failed: {e}")
+            features["FL"] = np.nan
+    else:
+        features["FL"] = np.nan
+    
     # AEC metrics
-    if aec_df is not None:
+    if isinstance(aec_df, pd.DataFrame) and not aec_df.empty:
         features["AECS"] = mean_slope(aec_df)
         features["AECC"] = mean_curvature(aec_df)
         features["AECI"] = concavity_index(aec_df)
+    else:
+        features["AECS"] = np.nan
+        features["AECC"] = np.nan
+        features["AECI"] = np.nan
 
     return pd.DataFrame([features])

reclaim/static_features/utils/basin_names.py

@@ -0,0 +1,78 @@
+ID_to_BASIN = {1030008110: 'RUFIJI',
+ 1030011660: 'ZAMBEZI',
+ 1030012590: 'LIMPOPO',
+ 1030012600: 'GOURITZ',
+ 1030015850: 'ORANGE',
+ 1030022420: 'NIGER',
+ 1030022430: 'OUEME',
+ 1030023300: 'VOLTA',
+ 1030023310: 'BANDAMA',
+ 1030027430: 'DRAA',
+ 1030029810: 'MOULOUYA',
+ 1030034260: 'NILE',
+ 1030040260: 'LAKE TURKANA',
+ 1030040300: 'MELRHIR',
+ 4030003020: 'LIAO HE',
+ 4030006940: 'HAI HE',
+ 4030007850: 'YELLOW RIVER',
+ 4030009880: 'YANGTZE',
+ 4030017020: 'MEKONG',
+ 4030017030: 'CHAO PHRAYA',
+ 4030018350: 'MAE KLONG',
+ 4030022790: 'IRRAWADDY',
+ 4030024190: 'KARNAPHULI',
+ 4030025450: 'GANGES',
+ 4030025460: 'GODAVARI',
+ 4030029530: 'NARMADA',
+ 4030031750: 'KUTCH',
+ 4030033640: 'INDUS',
+ 4030039450: 'TONE',
+ 4030046370: 'TAIWAN',
+ 4030048900: 'SRI LANKA',
+ 4030050220: 'UPPER ARAL SEA',
+ 4030050240: 'LOWER ARAL SEA',
+ 5030007690: 'BENGAWAN SOLO',
+ 5030015660: 'KAPUAS',
+ 5030031240: 'INDONESIA',
+ 5030055010: 'MARIANA_ISLANDS',
+ 5030067860: 'FITZROY',
+ 2030000010: 'ORONTES',
+ 2030003440: 'KIZILIRMAK',
+ 2030008490: 'DANUBE',
+ 2030009230: 'MARITSA RIVER',
+ 2030012730: 'PO',
+ 2030014550: 'TEVERE',
+ 2030016230: 'RHONE',
+ 2030020320: 'RHINE',
+ 2030026030: 'VISTULA',
+ 2030046500: 'SICILY',
+ 2030047500: 'SARDINIA_CORSICA',
+ 2030068690: 'KURA',
+ 2030073570: 'SHATT AL ARAB',
+ 2030085720: 'DEAD SEA',
+ 7030000010: 'SANTIAGO',
+ 7030008710: 'COLORADO (also COLORADO RIVER)',
+ 7030008720: 'SAN JOAQUIN',
+ 7030014250: 'ROGUE',
+ 7030014930: 'COLUMBIA',
+ 7030022240: 'NELSON',
+ 7030034520: 'SAINT LAWRENCE (also SAINT-LAURENT)',
+ 7030038340: 'SUSQUEHANNA',
+ 7030042040: 'MOBILE RIVER',
+ 7030047060: 'MISSISSIPPI',
+ 7030047840: 'BRAZOS',
+ 7030049270: 'RIO GRANDE (also BRAVO)',
+ 7030049280: 'USUMACINTA',
+ 7030073620: 'GREAT SALT LAKE',
+ 6030000010: 'ATRATO',
+ 6030004470: 'ORINOCO',
+ 6030007000: 'AMAZON (also AMAZONAS)',
+ 6030009770: 'JAGUARIBE',
+ 6030011780: 'SAO FRANCISCO',
+ 6030011790: 'DOCE',
+ 6030016970: 'PARANA',
+ 6030029280: 'CHIRA',
+ 6030032290: 'GUAYAS'}
+
+def get_basin_name(basin_id):
+    return ID_to_BASIN[basin_id]