Add RRFS radar viewer with Leaflet map integration

- Implement Gradio app for viewing RRFS composite reflectivity
- Fetch real RRFS data from NOAA AWS S3 bucket using Herbie
- Display radar data on interactive Leaflet map with Folium
- Support multiple forecast hours (0-18) and run times
- Add NEXRAD-style color scheme for reflectivity visualization
- Include geographic bounds for CONUS domain

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,28 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.DS_Store
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/

app.py

@@ -0,0 +1,363 @@
+import gradio as gr
+import folium
+from folium import plugins
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import numpy as np
+from datetime import datetime, timedelta
+from io import BytesIO
+import base64
+from PIL import Image
+import requests
+from herbie import Herbie
+import warnings
+warnings.filterwarnings('ignore')
+
+# RRFS domain bounds (approximate CONUS)
+CONUS_BOUNDS = [[21.14, -122.7], [47.86, -60.9]]
+
+def get_available_runs():
+    """Get list of available RRFS run times from the past week"""
+    runs = []
+    # RRFS retrospective data from May 2024
+    base_dates = [
+        "2024-05-02 12:00",
+        "2024-05-02 00:00",
+        "2024-05-01 12:00",
+        "2024-05-01 00:00",
+    ]
+    return base_dates
+
+def create_radar_colormap():
+    """Create NEXRAD-like color map for composite reflectivity"""
+    colors = [
+        '#646464',  # No echo
+        '#04e9e7',  # Light blue
+        '#019ff4',  # Blue
+        '#0300f4',  # Dark blue
+        '#02fd02',  # Green
+        '#01c501',  # Dark green
+        '#008e00',  # Darker green
+        '#fdf802',  # Yellow
+        '#e5bc00',  # Orange-yellow
+        '#fd9500',  # Orange
+        '#fd0000',  # Red
+        '#d40000',  # Dark red
+        '#bc0000',  # Darker red
+        '#f800fd',  # Magenta
+        '#9854c6',  # Purple
+    ]
+    bounds = [-30, -20, -10, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 75]
+    cmap = mcolors.ListedColormap(colors)
+    norm = mcolors.BoundaryNorm(bounds, cmap.N)
+    return cmap, norm
+
+def fetch_rrfs_data(run_time, forecast_hour):
+    """
+    Fetch RRFS composite reflectivity data from NOAA
+
+    Args:
+        run_time: Model run time (YYYYMMDDHH format or datetime string)
+        forecast_hour: Forecast hour (0-18)
+
+    Returns:
+        tuple: (data_array, lats, lons) or (None, None, None) if fetch fails
+    """
+    try:
+        # Parse run time
+        if isinstance(run_time, str):
+            if '-' in run_time:
+                dt = datetime.strptime(run_time, "%Y-%m-%d %H:%M")
+            else:
+                dt = datetime.strptime(run_time, "%Y%m%d%H")
+        else:
+            dt = run_time
+
+        # Initialize Herbie for RRFS
+        # Using AWS S3 bucket for retrospective data
+        H = Herbie(
+            dt,
+            model='rrfs',
+            product='nat',
+            fxx=forecast_hour,
+            priority=['aws'],
+        )
+
+        # Try to get composite reflectivity
+        # REFC = Composite Reflectivity
+        try:
+            ds = H.xarray('REFC:entire')
+        except:
+            # If REFC not available, try alternative variable names
+            try:
+                ds = H.xarray('REFD')
+            except:
+                return None, None, None
+
+        # Extract data
+        if 'refc' in ds:
+            refc = ds['refc']
+        elif 'refd' in ds:
+            refc = ds['refd']
+        else:
+            # Get first variable
+            var_name = list(ds.data_vars)[0]
+            refc = ds[var_name]
+
+        # Get coordinates
+        lats = refc.latitude.values if hasattr(refc, 'latitude') else refc.lat.values
+        lons = refc.longitude.values if hasattr(refc, 'longitude') else refc.lon.values
+
+        # Get reflectivity values
+        refc_data = refc.values
+
+        return refc_data, lats, lons
+
+    except Exception as e:
+        print(f"Error fetching RRFS data: {e}")
+        return None, None, None
+
+def create_radar_overlay(refc_data, lats, lons):
+    """
+    Create a PNG overlay image from radar data
+
+    Args:
+        refc_data: Composite reflectivity data array
+        lats: Latitude coordinates
+        lons: Longitude coordinates
+
+    Returns:
+        tuple: (image_base64, bounds) for folium ImageOverlay
+    """
+    # Create figure
+    fig, ax = plt.subplots(figsize=(10, 8), dpi=150)
+
+    # Get colormap
+    cmap, norm = create_radar_colormap()
+
+    # Plot data
+    im = ax.pcolormesh(lons, lats, refc_data, cmap=cmap, norm=norm, shading='auto')
+
+    # Remove axes
+    ax.axis('off')
+    plt.tight_layout(pad=0)
+
+    # Save to bytes
+    buf = BytesIO()
+    plt.savefig(buf, format='png', transparent=True, bbox_inches='tight', pad_inches=0)
+    plt.close(fig)
+    buf.seek(0)
+
+    # Convert to base64
+    img_base64 = base64.b64encode(buf.read()).decode()
+
+    # Get bounds for overlay
+    bounds = [
+        [float(np.min(lats)), float(np.min(lons))],
+        [float(np.max(lats)), float(np.max(lons))]
+    ]
+
+    return f"data:image/png;base64,{img_base64}", bounds
+
+def generate_map(run_time, forecast_hour):
+    """
+    Generate Folium map with RRFS radar overlay
+
+    Args:
+        run_time: Model run time
+        forecast_hour: Forecast hour
+
+    Returns:
+        folium.Map object
+    """
+    # Create base map centered on CONUS
+    m = folium.Map(
+        location=[39.0, -98.0],
+        zoom_start=4,
+        tiles='OpenStreetMap'
+    )
+
+    # Add tile layer options
+    folium.TileLayer('Cartodb Positron').add_to(m)
+    folium.TileLayer('Cartodb dark_matter').add_to(m)
+
+    # Fetch RRFS data
+    status_html = """
+    <div style='position: fixed; bottom: 20px; left: 20px; z-index: 1000;
+                background-color: white; padding: 10px; border-radius: 5px;
+                border: 2px solid #333; font-family: Arial;'>
+        <b>RRFS Composite Reflectivity</b><br>
+        Run: {run_time}<br>
+        Forecast Hour: F{fxx:03d}<br>
+        Valid: {valid_time}<br>
+        <span style='color: #0066cc;'>Source: NOAA RRFS (AWS S3)</span>
+    </div>
+    """
+
+    try:
+        # Parse run time
+        if isinstance(run_time, str):
+            if '-' in run_time:
+                dt = datetime.strptime(run_time, "%Y-%m-%d %H:%M")
+            else:
+                dt = datetime.strptime(run_time, "%Y%m%d%H")
+        else:
+            dt = run_time
+
+        valid_time = dt + timedelta(hours=int(forecast_hour))
+
+        # Add status info
+        m.get_root().html.add_child(folium.Element(
+            status_html.format(
+                run_time=dt.strftime("%Y-%m-%d %H:00 UTC"),
+                fxx=int(forecast_hour),
+                valid_time=valid_time.strftime("%Y-%m-%d %H:00 UTC")
+            )
+        ))
+
+        # Fetch and overlay data
+        refc_data, lats, lons = fetch_rrfs_data(run_time, int(forecast_hour))
+
+        if refc_data is not None:
+            # Create overlay
+            img_data, bounds = create_radar_overlay(refc_data, lats, lons)
+
+            # Add image overlay
+            folium.raster_layers.ImageOverlay(
+                image=img_data,
+                bounds=bounds,
+                opacity=0.6,
+                name='RRFS Composite Reflectivity'
+            ).add_to(m)
+
+            # Add colorbar legend
+            legend_html = '''
+            <div style="position: fixed; top: 20px; right: 20px; z-index: 1000;
+                        background-color: white; padding: 10px; border-radius: 5px;
+                        border: 2px solid #333; font-family: Arial; font-size: 12px;">
+                <b>Reflectivity (dBZ)</b><br>
+                <div style="display: flex; flex-direction: column; margin-top: 5px;">
+                    <div><span style="background: #9854c6; width: 20px; height: 15px; display: inline-block;"></span> 60-75</div>
+                    <div><span style="background: #f800fd; width: 20px; height: 15px; display: inline-block;"></span> 50-60</div>
+                    <div><span style="background: #bc0000; width: 20px; height: 15px; display: inline-block;"></span> 45-50</div>
+                    <div><span style="background: #d40000; width: 20px; height: 15px; display: inline-block;"></span> 40-45</div>
+                    <div><span style="background: #fd0000; width: 20px; height: 15px; display: inline-block;"></span> 35-40</div>
+                    <div><span style="background: #fd9500; width: 20px; height: 15px; display: inline-block;"></span> 30-35</div>
+                    <div><span style="background: #e5bc00; width: 20px; height: 15px; display: inline-block;"></span> 25-30</div>
+                    <div><span style="background: #fdf802; width: 20px; height: 15px; display: inline-block;"></span> 20-25</div>
+                    <div><span style="background: #008e00; width: 20px; height: 15px; display: inline-block;"></span> 15-20</div>
+                    <div><span style="background: #01c501; width: 20px; height: 15px; display: inline-block;"></span> 10-15</div>
+                    <div><span style="background: #02fd02; width: 20px; height: 15px; display: inline-block;"></span> 5-10</div>
+                    <div><span style="background: #0300f4; width: 20px; height: 15px; display: inline-block;"></span> 0-5</div>
+                </div>
+            </div>
+            '''
+            m.get_root().html.add_child(folium.Element(legend_html))
+        else:
+            # Add error message
+            error_html = """
+            <div style='position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
+                        z-index: 1001; background-color: #ffcccc; padding: 20px;
+                        border-radius: 10px; border: 2px solid #ff0000; font-family: Arial;'>
+                <h3>Data Not Available</h3>
+                <p>Unable to fetch RRFS data for the selected time.</p>
+                <p><b>Note:</b> Real-time RRFS output ceased in December 2024 for testing.<br>
+                Retrospective data from May 2024 is available.</p>
+            </div>
+            """
+            m.get_root().html.add_child(folium.Element(error_html))
+
+    except Exception as e:
+        # Add error message
+        error_html = f"""
+        <div style='position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%);
+                    z-index: 1001; background-color: #ffcccc; padding: 20px;
+                    border-radius: 10px; border: 2px solid #ff0000; font-family: Arial;'>
+            <h3>Error Loading Data</h3>
+            <p>Error: {str(e)}</p>
+            <p>Please try a different run time or forecast hour.</p>
+        </div>
+        """
+        m.get_root().html.add_child(folium.Element(error_html))
+
+    # Add layer control
+    folium.LayerControl().add_to(m)
+
+    return m
+
+def create_interface():
+    """Create Gradio interface"""
+
+    with gr.Blocks(title="RRFS Radar Viewer") as demo:
+        gr.Markdown("""
+        # RRFS Composite Reflectivity Viewer
+
+        View NOAA Rapid Refresh Forecast System (RRFS) composite reflectivity data on an interactive map.
+
+        **Data Source:** NOAA RRFS retrospective data from AWS S3 (May 2024)
+
+        **Note:** Real-time RRFS output ceased in December 2024 for final testing before operational deployment in 2026.
+        """)
+
+        with gr.Row():
+            run_time = gr.Dropdown(
+                choices=get_available_runs(),
+                value=get_available_runs()[0],
+                label="Model Run Time (UTC)",
+                info="Select RRFS model initialization time"
+            )
+
+            forecast_hour = gr.Slider(
+                minimum=0,
+                maximum=18,
+                step=1,
+                value=0,
+                label="Forecast Hour",
+                info="Hours from model initialization (0-18)"
+            )
+
+        load_btn = gr.Button("Load Radar Data", variant="primary", size="lg")
+
+        map_output = gr.HTML(label="RRFS Radar Map")
+
+        def load_map(run_time, forecast_hour):
+            m = generate_map(run_time, int(forecast_hour))
+            return m._repr_html_()
+
+        load_btn.click(
+            fn=load_map,
+            inputs=[run_time, forecast_hour],
+            outputs=map_output
+        )
+
+        gr.Markdown("""
+        ---
+        ### About RRFS
+
+        The Rapid Refresh Forecast System (RRFS) is NOAA's next-generation convection-allowing ensemble prediction system.
+        It provides high-resolution weather forecasts at 3 km grid spacing over North America.
+
+        **Composite Reflectivity** shows the maximum radar reflectivity in a vertical column, useful for identifying
+        precipitation intensity and convective weather features.
+
+        ### Data Information
+
+        - **Model:** RRFS (Rapid Refresh Forecast System)
+        - **Grid Spacing:** 3 km
+        - **Domain:** North America (CONUS shown)
+        - **Forecast Length:** 18 hours
+        - **Update Frequency:** Retrospective runs from May 2024
+        - **Source:** NOAA AWS S3 Bucket (noaa-rrfs-pds)
+
+        ### References
+
+        - [RRFS Information (NOAA)](https://rapidrefresh.noaa.gov/RRFS/)
+        - [RRFS on AWS Open Data](https://registry.opendata.aws/noaa-rrfs/)
+        - [NOAA Global Systems Laboratory](https://gsl.noaa.gov/focus-areas/unified_forecast_system/rrfs)
+        """)
+
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+gradio==5.49.1
+herbie-data==2024.12.0
+cartopy==0.23.0
+matplotlib==3.9.3
+numpy==1.26.4
+xarray==2024.11.0
+cfgrib==0.9.14.1
+folium==0.18.0
+Pillow==11.0.0
+requests==2.32.3