loone-data-prep 1.2.4__py3-none-any.whl → 1.3.1__py3-none-any.whl

loone_data_prep/flow_data/get_inflows.py

@@ -45,20 +45,22 @@ def main(workspace: str, dbkeys: dict = DBKEYS) -> dict:
     Returns:
         dict: Success or error message
     """
+    # Make a copy of the dbkeys dictionary because key value pairs will be removed as they are successfully downloaded
+    dbkeys = dbkeys.copy()
     
     # Retrieve inflow data
     for dbkey, station in dbkeys.copy().items():
-        file_name = f"{station}_FLOW_cmd.csv"
+        file_name = f"{station.replace(' ', '_')}_FLOW_cmd.csv"
         date_latest = find_last_date_in_csv(workspace, file_name)
         
         # File with data for this dbkey does NOT already exist (or possibly some other error occurred)
         if date_latest is None:
             # Download all the data
             print(f'Downloading all inflow data for {station}')
-            hydro.get(workspace, dbkey)
+            hydro.get(workspace=workspace, dbkey=dbkey, station=station)
         else:
             # Check whether the latest data is already up to date.
-            if dbhydro_data_is_latest(date_latest):
+            if dbhydro_data_is_latest(date_latest, dbkey):
                 # Notify that the data is already up to date
                 print(f'Downloading of new inflow data skipped for Station {station} (dbkey: {dbkey}). Data is already up to date.')
                 
@@ -67,8 +69,15 @@ def main(workspace: str, dbkeys: dict = DBKEYS) -> dict:
                 continue
             
             # Download only the new data
-            print(f'Downloading new inflow data for {station} starting from date {date_latest}')
-            hydro.get(workspace, dbkey, date_latest)
+            date_next = (pd.to_datetime(date_latest) + pd.Timedelta(days=1)).strftime("%Y-%m-%d")
+            print(f'Downloading new inflow data for {station} starting from date {date_next}')
+            hydro.get(workspace=workspace, dbkey=dbkey, date_min=date_next, station=station)
+            
+            # Check if the station name contains a space
+            if ' ' in station:
+                # Replace space with underscore in the station name
+                station_previous = station
+                station = station.replace(' ', '_')
             
             # Make sure both our original data and newly downloaded data exist
             df_original_path = os.path.join(workspace, f"{station}_FLOW_cmd.csv")
@@ -94,7 +103,7 @@ def main(workspace: str, dbkeys: dict = DBKEYS) -> dict:
         S65E_total.get(workspace, date_max=datetime.now().strftime("%Y-%m-%d"))
     else:
         # Check whether the latest data is already up to date.
-        if dbhydro_data_is_latest(date_latest):
+        if dbhydro_data_is_latest(date_latest, '91656') and dbhydro_data_is_latest(date_latest, 'AL760'):
             # Notify that the data is already up to date
             print(f'Downloading of new inflow data skipped for S65E_total. Data is already up to date.')
         else:
@@ -104,8 +113,9 @@ def main(workspace: str, dbkeys: dict = DBKEYS) -> dict:
             
             try:
                 # Download only the new data
-                print(f'Downloading new S65E_total data starting from date {date_latest}')
-                S65E_total.get(workspace, date_min=date_latest, date_max=datetime.now().strftime("%Y-%m-%d"))
+                date_next = (pd.to_datetime(date_latest) + pd.Timedelta(days=1)).strftime("%Y-%m-%d")
+                print(f'Downloading new S65E_total data starting from date {date_next}')
+                S65E_total.get(workspace, date_min=date_next, date_max=datetime.now().strftime("%Y-%m-%d"))
                 
                 # Merge the new data with the original data
                 df_original = pd.read_csv(os.path.join(workspace, original_file_name), index_col=0)

loone_data_prep/flow_data/get_outflows.py

@@ -56,8 +56,8 @@ def _get_outflow_data_from_station_ids(workspace: str, station_ids: list) -> dic
         dict: Success or error message
     """
     # Get dbkeys from station ids
-    dbkeys = list(get_dbkeys(station_ids, "SW", "FLOW", "MEAN", "PREF", detail_level="dbkey"))
-    dbkeys.extend(list(get_dbkeys(station_ids, "SW", "FLOW", "MEAN", "DRV", detail_level="dbkey")))
+    dbkeys = get_dbkeys(station_ids, "SW", "FLOW", "MEAN", "PREF")
+    dbkeys.extend(get_dbkeys(station_ids, "SW", "FLOW", "MEAN", "DRV"))
 
     for dbkey in dbkeys:
         hydro.get(workspace, dbkey, "2000-01-01")
@@ -94,6 +94,8 @@ def main(workspace: str, dbkeys: dict = DBKEYS, station_ids: list = STATION_IDS)
     Returns:
         dict: Success or error message
     """
+    # Make a copy of the dbkeys dictionary because key value pairs will be removed as they are successfully downloaded
+    dbkeys = dbkeys.copy()
     
     # No dbkeys given, attempt to get data from station ids
     if dbkeys is None:
@@ -102,16 +104,16 @@ def main(workspace: str, dbkeys: dict = DBKEYS, station_ids: list = STATION_IDS)
     # Get outflow data from dbkeys
     for dbkey, station in dbkeys.copy().items():
         # Get the date of the latest data in the csv file (if any)
-        date_latest = find_last_date_in_csv(workspace, f"{station}_FLOW_cmd.csv")
+        date_latest = find_last_date_in_csv(workspace, f"{station.replace(' ', '_')}_FLOW_cmd.csv")
         
         # File with data for this dbkey does NOT already exist (or possibly some other error occurred)
         if date_latest is None:
             # Download all data
             print(f'Downloading all outflow data for {station}')
-            hydro.get(workspace, dbkey, "2000-01-01")
+            hydro.get(workspace=workspace, dbkey=dbkey, date_min="2000-01-01", station=station)
         else:
             # Check whether the latest data is already up to date.
-            if dbhydro_data_is_latest(date_latest):
+            if dbhydro_data_is_latest(date_latest, dbkey):
                 # Notify that the data is already up to date
                 print(f'Downloading of new outflow data skipped for Station {station} (dbkey: {dbkey}). Data is already up to date.')
                 
@@ -120,8 +122,15 @@ def main(workspace: str, dbkeys: dict = DBKEYS, station_ids: list = STATION_IDS)
                 continue
             
             # Download only the new data
-            print(f'Downloading new outflow data for {station} starting from date {date_latest}')
-            hydro.get(workspace, dbkey, date_latest)
+            date_next = (pd.to_datetime(date_latest) + pd.Timedelta(days=1)).strftime("%Y-%m-%d")
+            print(f'Downloading new outflow data for {station} starting from date {date_next}')
+            hydro.get(workspace=workspace, dbkey=dbkey, date_min=date_next, station=station)
+            
+            # Check if the station name contains a space
+            if ' ' in station:
+                # Replace space with underscore in the station name
+                station_previous = station
+                station = station.replace(' ', '_')
             
             # Make sure both our original data and newly downloaded data exist
             df_old_path = os.path.join(workspace, f"{station}_FLOW_cmd.csv")

loone_data_prep/flow_data/hydro.py

@@ -1,116 +1,68 @@
 import sys
 from datetime import datetime
-from glob import glob
 from retry import retry
-import os
 import pandas as pd
-from rpy2.robjects import r
-from rpy2.rinterface_lib.embedded import RRuntimeError
+from loone_data_prep.utils import df_replace_missing_with_nan, get_dbhydro_api
 
 
 DATE_NOW = datetime.now().strftime("%Y-%m-%d")
 
 
-@retry(RRuntimeError, tries=5, delay=15, max_delay=60, backoff=2)
+@retry(Exception, tries=5, delay=15, max_delay=60, backoff=2)
 def get(
     workspace: str,
     dbkey: str,
     date_min: str = "1990-01-01",
-    date_max: str = DATE_NOW
+    date_max: str = DATE_NOW,
+    station: str | None = None
 ) -> None:
-    r_str = f"""
-    download_flow_data <- function(workspace, dbkey, date_min, date_max) 
-    {{
-        # Load the required libraries
-        library(dbhydroR)
-        library(dplyr)
-
-        # Retrieve data for the dbkey
-        data <- get_hydro(dbkey = "{dbkey}", date_min = "{date_min}", date_max = "{date_max}", raw = TRUE)
-        
-        # Check if data is empty or contains only the "date" column
-        if (ncol(data) <= 1) {{
-            cat("No data found for dbkey", "{dbkey}", "Skipping to the next dbkey.\n")
-        }}
-        
-        # Give data.frame correct column names so it can be cleaned using the clean_hydro function
-        colnames(data) <- c("station", "dbkey", "date", "data.value", "qualifer", "revision.date")
-        
-        # Check if the data.frame has any rows
-        if (nrow(data) == 0) 
-        {{
-            # No data given back, It's possible that the dbkey has reached its end date.
-            print(paste("Empty data.frame returned for dbkey", "{dbkey}", "It's possible that the dbkey has reached its end date. Skipping to the next dbkey."))
-            return(list(success = FALSE, dbkey = "{dbkey}"))
-        }}
-        
-        # Add a type and units column to data so it can be cleaned using the clean_hydro function
-        data$type <- "FLOW"
-        data$units <- "cfs"
-        
-        # Get the station
-        station <- data$station[1]
-        
-        # Clean the data.frame
-        data <- clean_hydro(data)
-
-        # Multiply all columns except "date" column by 0.0283168466 * 86400 to convert Flow rate from cfs to m³/day
-        data[, -1] <- data[, -1] * (0.0283168466 * 86400)
-        
-        # Drop the " _FLOW_cfs" column
-        data <- data %>% select(-` _FLOW_cfs`)    
-        
-        # Sort the data by date
-        data <- data[order(data$date), ]
-        
-        # Get the filename for the output CSV file
-        filename <- paste0(station, "_FLOW", "_{dbkey}_cmd.csv")
-        
-        # Save data to a CSV file
-        write.csv(data, file = paste0("{workspace}/", filename))
-
-        # Print a message indicating the file has been saved
-        cat("CSV file", filename, "has been saved.\n")
-
-        # Add a delay between requests
-        Sys.sleep(1)  # Wait for 1 second before the next iteration
-        
-        # Return the station and dbkey to the python code
-        list(success = TRUE, station = station, dbkey = "{dbkey}")
-    }}
+    """Fetches daily flow data from DBHYDRO and saves it to a CSV file.
+    
+    Args:
+        workspace (str): Path to the workspace directory where data will be saved.
+        dbkey (str): The DBHYDRO database key for the station.
+        date_min (str): Minimum date for data retrieval in 'YYYY-MM-DD' format.
+        date_max (str): Maximum date for data retrieval in 'YYYY-MM-DD' format.
+        station (str | None): The station name. If None, the station name will be fetched from DBHYDRO.
     """
-
-    r(r_str)
+    # Get a DbHydroApi instance
+    api = get_dbhydro_api()
     
-    # Call the R function to download the flow data
-    result = r.download_flow_data(workspace, dbkey, date_min, date_max)
+    # Get the daily data from DbHydro
+    response = api.get_daily_data([dbkey], 'id', date_min, date_max, 'NGVD29', False)
     
     # Check for failure
-    success = result.rx2("success")[0]
-
-    if not success:
+    if not response.has_data():
         return
     
-    # Get the station name for _reformat_flow_file()
-    station = result.rx2("station")[0]
+    # Get the station name for _reformat_flow_df()
+    if station is None:
+        station = response.get_site_codes()[0]
+    
+    # Get the data as a dataframe
+    df = response.to_dataframe(True)
     
-    # Reformat the flow data file to the expected layout
-    _reformat_flow_file(workspace, station, dbkey)
+    # Replace flagged 0 values and -99999.0 with NaN
+    df = df_replace_missing_with_nan(df)
+    
+    # Convert flow from cfs to cmd
+    df['value'] = df['value'] * (0.0283168466 * 86400)
+    
+    # Prepare the dataframe to be reformatted into the expected layout
+    df.reset_index(inplace=True)
+    df.rename(columns={'datetime': 'date', 'value': f'{station}_FLOW_cmd'}, inplace=True)
+    
+    # Reformat the flow df to the expected layout
+    df = _reformat_flow_df(df, station)
     
     # Check if the station name contains a space
-    if " " in station:
+    if ' ' in station:
         # Replace space with underscore in the station name
         station_previous = station
-        station = station.replace(" ", "_")
-        
-        # Rename the file
-        os.rename(f"{workspace}/{station_previous}_FLOW_{dbkey}_cmd.csv", f"{workspace}/{station}_FLOW_{dbkey}_cmd.csv")
+        station = station.replace(' ', '_')
 
-    # column values are converted to cmd in R. This snippet makes sure column names are updated accordingly.
-    file = glob(f'{workspace}/*FLOW*{dbkey}_cmd.csv')[0]
-    df = pd.read_csv(file, index_col=False)
-    df.columns = df.columns.astype(str).str.replace("_cfs", "_cmd")
-    df.to_csv(file, index=False)
+    # Write the data to a CSV file
+    df.to_csv(f'{workspace}/{station}_FLOW_{dbkey}_cmd.csv', index=True)
 
 
 def _reformat_flow_file(workspace:str, station: str, dbkey: str):
@@ -130,8 +82,27 @@ def _reformat_flow_file(workspace:str, station: str, dbkey: str):
     # Read in the data
     df = pd.read_csv(f"{workspace}/{station}_FLOW_{dbkey}_cmd.csv")
     
+    # Reformat the data
+    df = _reformat_flow_df(df, station)
+    
+    # Write the updated data back to the file
+    df.to_csv(f"{workspace}/{station}_FLOW_{dbkey}_cmd.csv")
+
+
+def _reformat_flow_df(df: pd.DataFrame, station: str) -> pd.DataFrame:
+    '''
+    Reformat the flow data file to the expected layout.
+    Converts the format of the dates in the file to 'YYYY-MM-DD' then sorts the data by date.
+    
+    Args:
+        df (pd.DataFrame): The dataframe containing the flow data.
+        station (str): The station name.
+        
+    Returns:
+        pd.DataFrame: The reformatted dataframe.
+    '''
     # Grab only the columns we need
-    df = df[['date', f'{station}_FLOW_cfs']]
+    df = df[['date', f'{station}_FLOW_cmd']].copy()
     
     # Convert date column to datetime
     df['date'] = pd.to_datetime(df['date'], format='%d-%b-%Y')
@@ -143,10 +114,10 @@ def _reformat_flow_file(workspace:str, station: str, dbkey: str):
     df.reset_index(drop=True, inplace=True)
     
     # Drop rows that are missing values for both the date and value columns
-    df = df.drop(df[(df['date'].isna()) & (df[f'{station}_FLOW_cfs'].isna())].index)
+    df = df.drop(df[(df['date'].isna()) & (df[f'{station}_FLOW_cmd'].isna())].index)
     
-    # Write the updated data back to the file
-    df.to_csv(f"{workspace}/{station}_FLOW_{dbkey}_cmd.csv")
+    # Return the updated dataframe
+    return df
 
 
 if __name__ == "__main__":

loone_data_prep/forecast_scripts/get_Chla_predicted.py

@@ -9,7 +9,7 @@ def get_Chla_predicted(input_dir, output_dir):
     output_dir: Directory where the output files will be saved.
     """
     # Read forecast inflow file and get overall date range
-    # TODO: Should this be an average/median of all of the ensembles? worst case?
+    # We are only taking the dates, so it is okay to just use one ensemble because they all have the same dates
     Q_in = pd.read_csv(os.path.join(input_dir, 'LO_Inflows_BK_forecast_01.csv'))
     Q_in['date'] = pd.to_datetime(Q_in['date'])
     date_start = Q_in['date'].min()

loone_data_prep/forecast_scripts/get_NO_Loads_predicted.py

@@ -9,7 +9,7 @@ def get_NO_Loads_predicted(input_dir, output_dir):
     output_dir: Directory where the output files will be saved.
     This function reads the forecast inflow file, retrieves nitrate data for specified stations,
     """
-    # TODO: Should this be an average/median of all of the ensembles? worst case?
+    # It is okay to use just one ensemble because they all have the same dates and we only use the dates
     Q_in = pd.read_csv(os.path.join(input_dir, 'LO_Inflows_BK_forecast_01.csv'))
 
     datetime_str = Q_in['date'].iloc[0]

loone_data_prep/forecast_scripts/new_combined_weather_forecast.py

@@ -0,0 +1,220 @@
+import os
+import warnings
+import pandas as pd
+from datetime import datetime
+from retry import retry
+from loone_data_prep.herbie_utils import get_fast_herbie_object
+from herbie import FastHerbie
+import openmeteo_requests
+from retry_requests import retry as retry_requests
+import requests_cache
+
+warnings.filterwarnings("ignore", message="Will not remove GRIB file because it previously existed.")
+
+POINTS = pd.DataFrame({
+    "station": ["L001", "L005", "L006", "LZ40"],
+    "longitude": [-80.7934, -80.9724, -80.7828, -80.7890],
+    "latitude": [27.1389, 26.9567, 26.8226, 26.9018]
+})
+
+WIND_FILE_MAP = {
+    "L001": ("L001_WNDS_MPH_predicted.csv", "L001_WNDS_MPH"),
+    "L005": ("L005_WNDS_MPH_predicted.csv", "L005_WNDS_MPH"),
+    "L006": ("L006_WNDS_MPH_predicted.csv", "L006_WNDS_MPH"),
+    "LZ40": ("LZ40_WNDS_MPH_predicted.csv", "LZ40_WNDS_MPH")
+}
+
+AIRT_FILE_MAP = {
+    "L001": "L001_AIRT_Degrees Celsius_forecast.csv",
+    "L005": "L005_AIRT_Degrees Celsius_forecast.csv",
+    "L006": "L006_AIRT_Degrees Celsius_forecast.csv",
+    "LZ40": "LZ40_AIRT_Degrees Celsius_forecast.csv"
+}
+
+AIRT_COLUMN_MAP = {
+    "L001": "L001_AIRT_Degrees Celsius",
+    "L005": "L005_AIRT_Degrees Celsius",
+    "L006": "L006_AIRT_Degrees Celsius",
+    "LZ40": "LZ40_AIRT_Degrees Celsius"
+}
+
+@retry(Exception, tries=5, delay=15, max_delay=60, backoff=2)
+def download_herbie_variable(FH, variable_key, variable_name, point_df):
+    """Download a Herbie variable for a given point and return a DataFrame."""
+    FH.download(f":{variable_key}")
+    ds = FH.xarray(f":{variable_key}", backend_kwargs={"decode_timedelta": True})
+    dsi = ds.herbie.pick_points(point_df, method="nearest")
+
+    var_name = {
+        "10u": "u10",
+        "10v": "v10",
+        "2t": "t2m"
+    }.get(variable_name, variable_name) 
+
+    ts = dsi[var_name].squeeze()
+    df = ts.to_dataframe().reset_index()
+    if "valid_time" in df.columns:
+        df.rename(columns={"valid_time": "datetime"}, inplace=True)
+    elif "time" in df.columns:
+        df.rename(columns={"time": "datetime"}, inplace=True)
+
+    df = df[["datetime", var_name]].drop_duplicates()
+    ds.close()
+    dsi.close()
+    del ds, dsi, ts
+    return df
+
+# Download ET from Open-Meteo
+def download_hourly_et(lat, lon):
+    cache_session = requests_cache.CachedSession('.cache', expire_after=3600)
+    retry_session = retry_requests(cache_session, retries=5, backoff_factor=0.2)
+    client = openmeteo_requests.Client(session=retry_session)
+
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": lat,
+        "longitude": lon,
+        "hourly": "evapotranspiration",
+        "forecast_days": 16,
+        "models": "gfs_seamless"
+    }
+    responses = client.weather_api(url, params=params)
+    response = responses[0]
+
+    hourly = response.Hourly()
+    hourly_evap = hourly.Variables(0).ValuesAsNumpy()
+    hourly_data = {"date": pd.date_range(
+        start=pd.to_datetime(hourly.Time(), unit="s"),
+        end=pd.to_datetime(hourly.TimeEnd(), unit="s"),
+        freq=pd.Timedelta(seconds=hourly.Interval()),
+        inclusive="left"
+    )}
+    hourly_data["evapotranspiration"] = hourly_evap
+    return pd.DataFrame(hourly_data)
+
+# Main generation function
+def generate_all_outputs(output_dir):
+    os.makedirs(output_dir, exist_ok=True)
+    today_str = datetime.today().strftime('%Y-%m-%d 00:00')
+    FH = get_fast_herbie_object(today_str)
+
+    # Forecasted weather data (single point)
+    point_df = pd.DataFrame({"longitude": [-80.7976], "latitude": [26.9690]})
+    forecast_vars = ["10u", "10v", "2t", "tp", "ssrd"]
+    data = {var: download_herbie_variable(FH, var, var, point_df) for var in forecast_vars}
+
+    merged = data["10u"].merge(data["10v"], on="datetime")
+    merged = merged.merge(data["2t"], on="datetime")
+    merged = merged.merge(data["tp"], on="datetime")
+    merged = merged.merge(data["ssrd"], on="datetime")
+
+    # Derived columns
+    merged["wind_speed"] = (merged["u10"]**2 + merged["v10"]**2)**0.5  # wind speed in m/s
+    merged["wind_speed_corrected"] = 0.4167 * merged["wind_speed"] + 4.1868
+    merged["tp_inc_m"] = merged["tp"].diff().clip(lower=0)
+    # Convert incremental meters → mm
+    merged["tp_inc_mm"] = merged["tp_inc_m"] * 1000.0
+    # Apply bias correction (in mm)
+    merged["tp_corrected_mm"] = 0.7247 * merged["tp_inc_mm"] + 0.1853
+    # convert to inches
+    merged["tp_corrected"] = merged["tp_corrected_mm"] * 0.0393701
+
+    merged["ssrd_kwm2"] = merged["ssrd"].diff() / merged["datetime"].diff().dt.total_seconds() / 1000
+    merged["ssrd_corrected"] = (1.0530 * merged["ssrd_kwm2"] - 0.0347).clip(lower=0)
+    merged = merged[[
+        "datetime",
+        "wind_speed_corrected",
+        "tp_corrected",
+        "ssrd_corrected"
+    ]]
+
+    # ET for main point
+    df_et = download_hourly_et(26.9690, -80.7976)
+    merged = merged.merge(df_et, left_on="datetime", right_on="date", how="left").drop(columns=["date"])
+    merged.to_csv(os.path.join(output_dir, "forecasted_weather_data.csv"), index=False)
+
+    # 4-point wind and air temp CSVs
+    for idx, row in POINTS.iterrows():
+        station = row["station"]
+        point_df = pd.DataFrame({"longitude": [row.longitude], "latitude": [row.latitude]})
+
+        # Wind
+        df_u = download_herbie_variable(FH, "10u", "10u", point_df)
+        df_v = download_herbie_variable(FH, "10v", "10v", point_df)
+        merged_ws = df_u.merge(df_v, on="datetime")
+        merged_ws["wind_speed"] = (merged_ws["u10"]**2 + merged_ws["v10"]**2)**0.5
+        merged_ws["wind_speed_corrected"] = 0.4167 * merged_ws["wind_speed"] + 4.1868
+
+        filename, new_col = WIND_FILE_MAP[station]
+        merged_ws[["datetime", "wind_speed_corrected"]].rename(
+            columns={"datetime": "date", "wind_speed_corrected": new_col}
+        ).to_csv(os.path.join(output_dir, filename), index=False)
+
+        # Air temp
+        df_t = download_herbie_variable(FH, "2t", "2t", point_df)
+        df_t["t2m"] = df_t["t2m"] - 273.15
+        df_t.rename(columns={"datetime": "date", "t2m": AIRT_COLUMN_MAP[station]}).to_csv(
+            os.path.join(output_dir, AIRT_FILE_MAP[station]), index=False
+        )
+
+    # Rainfall, ET, and SSRD 4-point CSVs
+    rainfall_dfs, et_dfs, ssrd_dfs = [], [], []
+
+    for idx, row in POINTS.iterrows():
+        station = row["station"]
+        point_df = pd.DataFrame({"longitude": [row.longitude], "latitude": [row.latitude]})
+
+        # Rainfall
+        df_tp = download_herbie_variable(FH, "tp", "tp", point_df)
+        # Convert cumulative meters → incremental meters
+        df_tp["tp_inc_m"] = df_tp["tp"].diff().clip(lower=0)
+        # Convert incremental meters → millimeters
+        df_tp["tp_inc_mm"] = df_tp["tp_inc_m"] * 1000.0
+        df_tp["date_only"] = df_tp["datetime"].dt.date
+        # Sum incremental precipitation per day
+        df_daily = df_tp.groupby("date_only")["tp_inc_mm"].sum().reset_index()
+        # Apply bias correction on daily totals (in mm)
+        df_daily["tp_corrected_mm"] = 0.7247 * df_daily["tp_inc_mm"] + 0.1853
+        # Convert corrected mm → inches
+        df_daily["tp_corrected_in"] = df_daily["tp_corrected_mm"] * 0.0393701
+        df_daily = df_daily.rename(columns={"date_only": "date", "tp_corrected_in": station})
+        rainfall_dfs.append(df_daily[["date", station]])
+
+        # ET
+        df_et_point = download_hourly_et(row.latitude, row.longitude)
+        df_et_point.rename(columns={"evapotranspiration": station}, inplace=True)
+        et_dfs.append(df_et_point)
+
+        # SSRD
+        df_ssrd = download_herbie_variable(FH, "ssrd", "ssrd", point_df)
+        df_ssrd["ssrd_kwm2"] = df_ssrd["ssrd"].diff() / df_ssrd["datetime"].diff().dt.total_seconds() / 1000
+        df_ssrd["ssrd_corrected"] = (1.0530 * df_ssrd["ssrd_kwm2"] - 0.0347).clip(lower=0)
+        df_ssrd = df_ssrd[["datetime", "ssrd_corrected"]].rename(columns={"datetime": "date", "ssrd_corrected": station})
+        ssrd_dfs.append(df_ssrd)
+
+    # Merge rainfall
+    rainfall_df = pd.concat(rainfall_dfs, axis=0).groupby("date").first().reset_index()
+    rainfall_df["average_rainfall"] = rainfall_df[POINTS["station"]].mean(axis=1)
+    rainfall_df.to_csv(os.path.join(output_dir, "LAKE_RAINFALL_DATA_FORECAST.csv"), index=False)
+
+    # Merge ET
+    et_df_all = pd.concat(et_dfs, axis=0).groupby("date").first().reset_index()
+    et_df_all["average_ETPI"] = et_df_all[POINTS["station"]].mean(axis=1)
+    et_df_all.to_csv(os.path.join(output_dir, "LOONE_AVERAGE_ETPI_DATA_FORECAST.csv"), index=False)
+
+    # Combine all SSRD DataFrames
+    ssrd_df_all = pd.concat(ssrd_dfs, axis=0)
+    ssrd_df_all["date"] = pd.to_datetime(ssrd_df_all["date"])
+
+    # Compute the daily mean for each station
+    daily_ssrd = (
+        ssrd_df_all.groupby(ssrd_df_all["date"].dt.date)[POINTS["station"]]
+        .mean()
+        .reset_index()
+    )
+
+    daily_ssrd = daily_ssrd.rename(columns={"date": "date"})
+    daily_ssrd["Mean_RADT"] = daily_ssrd[POINTS["station"]].mean(axis=1)
+    daily_ssrd.to_csv(os.path.join(output_dir, "LO_RADT_data_forecast.csv"), index=False)
+
+    print("All outputs generated successfully.")