Update app.py

app.py

@@ -801,6 +801,753 @@ def categorize_typhoon_by_standard(wind_speed, standard='atlantic'):
             return 'Tropical Storm', '#0000FF'        # Blue
         return 'Tropical Depression', '#808080'       # Gray
 
+# -----------------------------
+# FIXED: Genesis Potential Index (GPI) Based Prediction System
+# -----------------------------
+
+def calculate_genesis_potential_index(sst, rh, vorticity, wind_shear, lat, lon, month, oni_value):
+    """
+    Calculate Genesis Potential Index based on environmental parameters
+    Following Emanuel and Nolan (2004) formulation with modifications for monthly predictions
+    """
+    try:
+        # Base environmental parameters
+        
+        # SST factor - optimal range 26-30°C
+        sst_factor = max(0, (sst - 26.5) / 4.0) if sst > 26.5 else 0
+        
+        # Humidity factor - mid-level relative humidity (600 hPa)
+        rh_factor = max(0, (rh - 40) / 50.0)  # Normalized 40-90%
+        
+        # Vorticity factor - low-level absolute vorticity (850 hPa)
+        vort_factor = max(0, min(vorticity / 5e-5, 3.0))  # Cap at reasonable max
+        
+        # Wind shear factor - vertical wind shear (inverse relationship)
+        shear_factor = max(0, (20 - wind_shear) / 15.0) if wind_shear < 20 else 0
+        
+        # Coriolis factor - latitude dependency
+        coriolis_factor = max(0, min(abs(lat) / 20.0, 1.0)) if abs(lat) > 5 else 0
+        
+        # Seasonal factor
+        seasonal_weights = {
+            1: 0.3, 2: 0.2, 3: 0.4, 4: 0.6, 5: 0.8, 6: 1.0,
+            7: 1.2, 8: 1.4, 9: 1.5, 10: 1.3, 11: 0.9, 12: 0.5
+        }
+        seasonal_factor = seasonal_weights.get(month, 1.0)
+        
+        # ENSO modulation
+        if oni_value > 0.5:  # El Niño
+            enso_factor = 0.6 if lon > 140 else 0.8  # Suppress in WP
+        elif oni_value < -0.5:  # La Niña
+            enso_factor = 1.4 if lon > 140 else 1.1  # Enhance in WP
+        else:  # Neutral
+            enso_factor = 1.0
+        
+        # Regional modulation (Western Pacific specifics)
+        if 10 <= lat <= 25 and 120 <= lon <= 160:  # Main Development Region
+            regional_factor = 1.3
+        elif 5 <= lat <= 15 and 130 <= lon <= 150:  # Prime genesis zone
+            regional_factor = 1.5
+        else:
+            regional_factor = 0.8
+        
+        # Calculate GPI
+        gpi = (sst_factor * rh_factor * vort_factor * shear_factor * 
+               coriolis_factor * seasonal_factor * enso_factor * regional_factor)
+        
+        return max(0, min(gpi, 5.0))  # Cap at reasonable maximum
+        
+    except Exception as e:
+        logging.error(f"Error calculating GPI: {e}")
+        return 0.0
+
+def get_environmental_conditions(lat, lon, month, oni_value):
+    """
+    Get realistic environmental conditions for a given location and time
+    Based on climatological patterns and ENSO modulation
+    """
+    try:
+        # Base SST calculation (climatological)
+        base_sst = 28.5 - 0.15 * abs(lat - 15)  # Peak at 15°N
+        seasonal_sst_adj = 2.0 * np.cos(2 * np.pi * (month - 9) / 12)  # Peak in Sep
+        enso_sst_adj = oni_value * 0.8 if lon > 140 else oni_value * 0.4
+        sst = base_sst + seasonal_sst_adj + enso_sst_adj
+        
+        # Relative humidity (600 hPa)
+        base_rh = 75 - 0.5 * abs(lat - 12)  # Peak around 12°N
+        seasonal_rh_adj = 10 * np.cos(2 * np.pi * (month - 8) / 12)  # Peak in Aug
+        monsoon_effect = 5 if 100 <= lon <= 120 and month in [6,7,8,9] else 0
+        rh = max(40, min(90, base_rh + seasonal_rh_adj + monsoon_effect))
+        
+        # Low-level vorticity (850 hPa)
+        base_vort = 2e-5 * (1 + 0.1 * np.sin(2 * np.pi * lat / 30))
+        seasonal_vort_adj = 1e-5 * np.cos(2 * np.pi * (month - 8) / 12)
+        itcz_effect = 1.5e-5 if 5 <= lat <= 15 else 0
+        vorticity = max(0, base_vort + seasonal_vort_adj + itcz_effect)
+        
+        # Vertical wind shear (200-850 hPa)
+        base_shear = 8 + 0.3 * abs(lat - 20)  # Lower near 20°N
+        seasonal_shear_adj = 4 * np.cos(2 * np.pi * (month - 2) / 12)  # Low in Aug-Sep
+        enso_shear_adj = oni_value * 3 if lon > 140 else 0  # El Niño increases shear
+        wind_shear = max(2, base_shear + seasonal_shear_adj + enso_shear_adj)
+        
+        return {
+            'sst': sst,
+            'relative_humidity': rh,
+            'vorticity': vorticity,
+            'wind_shear': wind_shear
+        }
+        
+    except Exception as e:
+        logging.error(f"Error getting environmental conditions: {e}")
+        return {
+            'sst': 28.0,
+            'relative_humidity': 70.0,
+            'vorticity': 2e-5,
+            'wind_shear': 10.0
+        }
+
+def generate_genesis_prediction_monthly(month, oni_value, year=2025):
+    """
+    Generate realistic typhoon genesis prediction for a given month using GPI
+    Returns day-by-day genesis potential and storm development scenarios
+    """
+    try:
+        logging.info(f"Generating GPI-based prediction for month {month}, ONI {oni_value}")
+        
+        # Define the Western Pacific domain
+        lat_range = np.arange(5, 35, 2.5)  # 5°N to 35°N
+        lon_range = np.arange(110, 180, 2.5)  # 110°E to 180°E
+        
+        # Number of days in the month
+        days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1]
+        if month == 2 and year % 4 == 0:  # Leap year
+            days_in_month = 29
+        
+        # Daily GPI evolution
+        daily_gpi_maps = []
+        genesis_events = []
+        
+        for day in range(1, days_in_month + 1):
+            # Calculate GPI for each grid point
+            gpi_field = np.zeros((len(lat_range), len(lon_range)))
+            
+            for i, lat in enumerate(lat_range):
+                for j, lon in enumerate(lon_range):
+                    # Get environmental conditions
+                    env_conditions = get_environmental_conditions(lat, lon, month, oni_value)
+                    
+                    # Add daily variability
+                    daily_variation = 0.1 * np.sin(2 * np.pi * day / 30) + np.random.normal(0, 0.05)
+                    
+                    # Calculate GPI
+                    gpi = calculate_genesis_potential_index(
+                        sst=env_conditions['sst'] + daily_variation,
+                        rh=env_conditions['relative_humidity'],
+                        vorticity=env_conditions['vorticity'],
+                        wind_shear=env_conditions['wind_shear'],
+                        lat=lat,
+                        lon=lon,
+                        month=month,
+                        oni_value=oni_value
+                    )
+                    
+                    gpi_field[i, j] = gpi
+            
+            daily_gpi_maps.append({
+                'day': day,
+                'gpi_field': gpi_field,
+                'lat_range': lat_range,
+                'lon_range': lon_range
+            })
+            
+            # Check for genesis events (GPI > threshold)
+            genesis_threshold = 1.5  # Adjusted threshold
+            if np.max(gpi_field) > genesis_threshold:
+                # Find peak genesis locations
+                peak_indices = np.where(gpi_field > genesis_threshold)
+                if len(peak_indices[0]) > 0:
+                    # Select strongest genesis point
+                    max_idx = np.argmax(gpi_field)
+                    max_i, max_j = np.unravel_index(max_idx, gpi_field.shape)
+                    
+                    genesis_lat = lat_range[max_i]
+                    genesis_lon = lon_range[max_j]
+                    genesis_gpi = gpi_field[max_i, max_j]
+                    
+                    # Determine probability of actual genesis
+                    genesis_prob = min(0.8, genesis_gpi / 3.0)
+                    
+                    if np.random.random() < genesis_prob:
+                        genesis_events.append({
+                            'day': day,
+                            'lat': genesis_lat,
+                            'lon': genesis_lon,
+                            'gpi': genesis_gpi,
+                            'probability': genesis_prob,
+                            'date': f"{year}-{month:02d}-{day:02d}"
+                        })
+        
+        # Generate storm tracks for genesis events
+        storm_predictions = []
+        for i, genesis in enumerate(genesis_events):
+            storm_track = generate_storm_track_from_genesis(
+                genesis['lat'], 
+                genesis['lon'], 
+                genesis['day'], 
+                month, 
+                oni_value,
+                storm_id=i+1
+            )
+            
+            if storm_track:
+                storm_predictions.append({
+                    'storm_id': i + 1,
+                    'genesis_event': genesis,
+                    'track': storm_track,
+                    'uncertainty': calculate_track_uncertainty(storm_track)
+                })
+        
+        return {
+            'month': month,
+            'year': year,
+            'oni_value': oni_value,
+            'daily_gpi_maps': daily_gpi_maps,
+            'genesis_events': genesis_events,
+            'storm_predictions': storm_predictions,
+            'summary': {
+                'total_genesis_events': len(genesis_events),
+                'total_storm_predictions': len(storm_predictions),
+                'peak_gpi_day': max(daily_gpi_maps, key=lambda x: np.max(x['gpi_field']))['day'],
+                'peak_gpi_value': max(np.max(day_data['gpi_field']) for day_data in daily_gpi_maps)
+            }
+        }
+        
+    except Exception as e:
+        logging.error(f"Error in genesis prediction: {e}")
+        import traceback
+        traceback.print_exc()
+        return {
+            'error': str(e),
+            'month': month,
+            'oni_value': oni_value,
+            'storm_predictions': []
+        }
+
+def generate_storm_track_from_genesis(genesis_lat, genesis_lon, genesis_day, month, oni_value, storm_id=1):
+    """
+    Generate a realistic storm track from a genesis location
+    """
+    try:
+        track_points = []
+        current_lat = genesis_lat
+        current_lon = genesis_lon
+        current_intensity = 25  # Start as TD
+        
+        # Track duration (3-10 days typically)
+        track_duration_hours = np.random.randint(72, 240)
+        
+        for hour in range(0, track_duration_hours + 6, 6):
+            # Calculate storm motion
+            # Base motion patterns for Western Pacific
+            if current_lat < 20:  # Low latitude - westward motion
+                lat_speed = 0.1 + np.random.normal(0, 0.05)  # Slight poleward
+                lon_speed = -0.3 + np.random.normal(0, 0.1)  # Westward
+            elif current_lat < 25:  # Mid latitude - WNW motion
+                lat_speed = 0.15 + np.random.normal(0, 0.05)
+                lon_speed = -0.2 + np.random.normal(0, 0.1)
+            else:  # High latitude - recurvature
+                lat_speed = 0.2 + np.random.normal(0, 0.05)
+                lon_speed = 0.1 + np.random.normal(0, 0.1)  # Eastward
+            
+            # ENSO effects on motion
+            if oni_value > 0.5:  # El Niño - more eastward
+                lon_speed += 0.05
+            elif oni_value < -0.5:  # La Niña - more westward
+                lon_speed -= 0.05
+            
+            # Update position
+            current_lat += lat_speed
+            current_lon += lon_speed
+            
+            # Intensity evolution
+            # Get environmental conditions for intensity change
+            env_conditions = get_environmental_conditions(current_lat, current_lon, month, oni_value)
+            
+            # Intensity change factors
+            sst_factor = max(0, env_conditions['sst'] - 26.5)
+            shear_factor = max(0, (15 - env_conditions['wind_shear']) / 10)
+            
+            # Basic intensity change
+            if hour < 48:  # Development phase
+                intensity_change = 3 + sst_factor + shear_factor + np.random.normal(0, 2)
+            elif hour < 120:  # Mature phase
+                intensity_change = 1 + sst_factor * 0.5 + np.random.normal(0, 1.5)
+            else:  # Weakening phase
+                intensity_change = -2 + sst_factor * 0.3 + np.random.normal(0, 1)
+            
+            # Environmental limits
+            if current_lat > 30:  # Cool waters
+                intensity_change -= 5
+            if current_lon < 120:  # Land interaction
+                intensity_change -= 8
+            
+            current_intensity += intensity_change
+            current_intensity = max(15, min(180, current_intensity))  # Realistic bounds
+            
+            # Calculate pressure
+            pressure = max(900, 1013 - (current_intensity - 25) * 0.9)
+            
+            # Add uncertainty
+            position_uncertainty = 0.5 + (hour / 120) * 1.5  # Growing uncertainty
+            intensity_uncertainty = 5 + (hour / 120) * 15
+            
+            track_points.append({
+                'hour': hour,
+                'day': genesis_day + hour / 24.0,
+                'lat': current_lat,
+                'lon': current_lon,
+                'intensity': current_intensity,
+                'pressure': pressure,
+                'category': categorize_typhoon_enhanced(current_intensity),
+                'position_uncertainty': position_uncertainty,
+                'intensity_uncertainty': intensity_uncertainty
+            })
+            
+            # Stop if storm moves too far or weakens significantly
+            if current_lat > 40 or current_lat < 0 or current_lon < 100 or current_intensity < 20:
+                break
+        
+        return track_points
+        
+    except Exception as e:
+        logging.error(f"Error generating storm track: {e}")
+        return None
+
+def calculate_track_uncertainty(track_points):
+    """Calculate uncertainty metrics for a storm track"""
+    if not track_points:
+        return {'position': 0, 'intensity': 0}
+    
+    # Position uncertainty grows with time
+    position_uncertainty = [point['position_uncertainty'] for point in track_points]
+    
+    # Intensity uncertainty
+    intensity_uncertainty = [point['intensity_uncertainty'] for point in track_points]
+    
+    return {
+        'position_mean': np.mean(position_uncertainty),
+        'position_max': np.max(position_uncertainty),
+        'intensity_mean': np.mean(intensity_uncertainty),
+        'intensity_max': np.max(intensity_uncertainty),
+        'track_length': len(track_points)
+    }
+
+def create_genesis_animation(prediction_data, enable_animation=True):
+    """
+    Create animation showing daily genesis potential and storm development
+    """
+    try:
+        if 'daily_gpi_maps' not in prediction_data or not prediction_data['daily_gpi_maps']:
+            return create_error_plot("No GPI data available for animation")
+        
+        daily_maps = prediction_data['daily_gpi_maps']
+        storm_predictions = prediction_data.get('storm_predictions', [])
+        month = prediction_data['month']
+        oni_value = prediction_data['oni_value']
+        
+        fig = go.Figure()
+        
+        if enable_animation and len(daily_maps) > 1:
+            # Create animated version
+            frames = []
+            
+            for day_idx, day_data in enumerate(daily_maps):
+                day = day_data['day']
+                gpi_field = day_data['gpi_field']
+                lat_range = day_data['lat_range']
+                lon_range = day_data['lon_range']
+                
+                frame_data = []
+                
+                # Add GPI contour
+                frame_data.append(
+                    go.Contour(
+                        z=gpi_field,
+                        x=lon_range,
+                        y=lat_range,
+                        colorscale='Viridis',
+                        showscale=True,
+                        colorbar=dict(title="Genesis Potential Index"),
+                        name=f'GPI Day {day}',
+                        hovertemplate=(
+                            'Longitude: %{x:.1f}°E<br>'
+                            'Latitude: %{y:.1f}°N<br>'
+                            'GPI: %{z:.2f}<br>'
+                            f'Day: {day}<br>'
+                            '<extra></extra>'
+                        )
+                    )
+                )
+                
+                # Add storm tracks up to current day
+                for storm in storm_predictions:
+                    track = storm['track']
+                    # Only show track points up to current day
+                    current_track = [pt for pt in track if pt['day'] <= day]
+                    
+                    if current_track:
+                        lats = [pt['lat'] for pt in current_track]
+                        lons = [pt['lon'] for pt in current_track]
+                        intensities = [pt['intensity'] for pt in current_track]
+                        
+                        # Storm track
+                        frame_data.append(
+                            go.Scatter(
+                                x=lons,
+                                y=lats,
+                                mode='lines+markers',
+                                line=dict(color='red', width=3),
+                                marker=dict(
+                                    size=[max(4, int/10) for int in intensities],
+                                    color='red'
+                                ),
+                                name=f'Storm {storm["storm_id"]}',
+                                hovertemplate=(
+                                    f'Storm {storm["storm_id"]}<br>'
+                                    'Longitude: %{x:.1f}°E<br>'
+                                    'Latitude: %{y:.1f}°N<br>'
+                                    '<extra></extra>'
+                                ),
+                                showlegend=(day_idx == 0)
+                            )
+                        )
+                        
+                        # Current position marker
+                        if current_track:
+                            current_pos = current_track[-1]
+                            frame_data.append(
+                                go.Scatter(
+                                    x=[current_pos['lon']],
+                                    y=[current_pos['lat']],
+                                    mode='markers',
+                                    marker=dict(
+                                        size=15,
+                                        color='yellow',
+                                        symbol='star',
+                                        line=dict(width=2, color='black')
+                                    ),
+                                    name=f'Storm {storm["storm_id"]} Current',
+                                    showlegend=False,
+                                    hovertemplate=(
+                                        f'Storm {storm["storm_id"]} - Day {day:.1f}<br>'
+                                        f'Intensity: {current_pos["intensity"]:.0f} kt<br>'
+                                        f'Category: {current_pos["category"]}<br>'
+                                        f'Pressure: {current_pos["pressure"]:.0f} hPa<br>'
+                                        '<extra></extra>'
+                                    )
+                                )
+                            )
+                
+                frames.append(go.Frame(
+                    data=frame_data,
+                    name=str(day),
+                    layout=go.Layout(
+                        title=f"Genesis Potential & Storm Development - Month {month}, Day {day}<br>ONI: {oni_value:.2f}"
+                    )
+                ))
+            
+            fig.frames = frames
+            
+            # Set initial frame
+            if frames:
+                fig.add_traces(frames[0].data)
+            
+            # Add animation controls
+            fig.update_layout(
+                updatemenus=[{
+                    "buttons": [
+                        {
+                            "args": [None, {"frame": {"duration": 1000, "redraw": True},
+                                          "fromcurrent": True, "transition": {"duration": 300}}],
+                            "label": "▶️ Play",
+                            "method": "animate"
+                        },
+                        {
+                            "args": [[None], {"frame": {"duration": 0, "redraw": True},
+                                            "mode": "immediate", "transition": {"duration": 0}}],
+                            "label": "⏸️ Pause",
+                            "method": "animate"
+                        }
+                    ],
+                    "direction": "left",
+                    "pad": {"r": 10, "t": 87},
+                    "showactive": False,
+                    "type": "buttons",
+                    "x": 0.1,
+                    "xanchor": "right",
+                    "y": 0,
+                    "yanchor": "top"
+                }],
+                sliders=[{
+                    "active": 0,
+                    "yanchor": "top",
+                    "xanchor": "left",
+                    "currentvalue": {
+                        "font": {"size": 16},
+                        "prefix": "Day: ",
+                        "visible": True,
+                        "xanchor": "right"
+                    },
+                    "transition": {"duration": 300, "easing": "cubic-in-out"},
+                    "pad": {"b": 10, "t": 50},
+                    "len": 0.9,
+                    "x": 0.1,
+                    "y": 0,
+                    "steps": [
+                        {
+                            "args": [[str(day_data['day'])], {"frame": {"duration": 300, "redraw": True},
+                                                   "mode": "immediate", "transition": {"duration": 300}}],
+                            "label": f"D{day_data['day']}",
+                            "method": "animate"
+                        }
+                        for day_data in daily_maps[::max(1, len(daily_maps)//15)]
+                    ]
+                }]
+            )
+            
+        else:
+            # Static version showing final day
+            final_day = daily_maps[-1]
+            gpi_field = final_day['gpi_field']
+            lat_range = final_day['lat_range']
+            lon_range = final_day['lon_range']
+            
+            # Add GPI contour
+            fig.add_trace(
+                go.Contour(
+                    z=gpi_field,
+                    x=lon_range,
+                    y=lat_range,
+                    colorscale='Viridis',
+                    showscale=True,
+                    colorbar=dict(title="Genesis Potential Index"),
+                    name='Genesis Potential',
+                    hovertemplate=(
+                        'Longitude: %{x:.1f}°E<br>'
+                        'Latitude: %{y:.1f}°N<br>'
+                        'GPI: %{z:.2f}<br>'
+                        '<extra></extra>'
+                    )
+                )
+            )
+            
+            # Add complete storm tracks
+            for storm in storm_predictions:
+                track = storm['track']
+                if track:
+                    lats = [pt['lat'] for pt in track]
+                    lons = [pt['lon'] for pt in track]
+                    intensities = [pt['intensity'] for pt in track]
+                    
+                    fig.add_trace(
+                        go.Scatter(
+                            x=lons,
+                            y=lats,
+                            mode='lines+markers',
+                            line=dict(color='red', width=3),
+                            marker=dict(
+                                size=[max(4, int/10) for int in intensities],
+                                color=intensities,
+                                colorscale='Reds',
+                                showscale=False
+                            ),
+                            name=f'Storm {storm["storm_id"]}',
+                            hovertemplate=(
+                                f'Storm {storm["storm_id"]}<br>'
+                                'Longitude: %{x:.1f}°E<br>'
+                                'Latitude: %{y:.1f}°N<br>'
+                                '<extra></extra>'
+                            )
+                        )
+                    )
+                    
+                    # Genesis marker
+                    fig.add_trace(
+                        go.Scatter(
+                            x=[lons[0]],
+                            y=[lats[0]],
+                            mode='markers',
+                            marker=dict(
+                                size=20,
+                                color='yellow',
+                                symbol='star',
+                                line=dict(width=2, color='black')
+                            ),
+                            name=f'Genesis {storm["storm_id"]}',
+                            showlegend=False
+                        )
+                    )
+        
+        # Update layout
+        fig.update_layout(
+            title=f"Typhoon Genesis Prediction - Month {month} (ONI: {oni_value:.2f})" + 
+                  (" - Animated" if enable_animation else ""),
+            xaxis_title="Longitude (°E)",
+            yaxis_title="Latitude (°N)",
+            width=1000,
+            height=700,
+            showlegend=True
+        )
+        
+        # Set map bounds
+        fig.update_xaxes(range=[110, 180])
+        fig.update_yaxes(range=[5, 35])
+        
+        return fig
+        
+    except Exception as e:
+        logging.error(f"Error creating genesis animation: {e}")
+        return create_error_plot(f"Animation error: {str(e)}")
+
+def create_error_plot(error_message):
+    """Create a simple error plot"""
+    fig = go.Figure()
+    fig.add_annotation(
+        text=error_message,
+        xref="paper", yref="paper",
+        x=0.5, y=0.5, xanchor='center', yanchor='middle',
+        showarrow=False, font_size=16
+    )
+    fig.update_layout(title="Error in Visualization")
+    return fig
+
+def create_prediction_summary(prediction_data):
+    """Create a comprehensive summary of the prediction"""
+    try:
+        if 'error' in prediction_data:
+            return f"Error in prediction: {prediction_data['error']}"
+        
+        month = prediction_data['month']
+        oni_value = prediction_data['oni_value']
+        summary = prediction_data.get('summary', {})
+        genesis_events = prediction_data.get('genesis_events', [])
+        storm_predictions = prediction_data.get('storm_predictions', [])
+        
+        month_names = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+                      'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+        month_name = month_names[month - 1]
+        
+        summary_text = f"""
+TYPHOON GENESIS PREDICTION SUMMARY - {month_name.upper()} 2025
+{'='*70}
+
+🌊 ENVIRONMENTAL CONDITIONS:
+• Month: {month_name} (Month {month})
+• ONI Value: {oni_value:.2f} {'(El Niño)' if oni_value > 0.5 else '(La Niña)' if oni_value < -0.5 else '(Neutral)'}
+• Season Phase: {'Peak Season' if month in [7,8,9,10] else 'Off Season' if month in [1,2,3,4,11,12] else 'Transition Season'}
+
+📊 GENESIS POTENTIAL ANALYSIS:
+• Peak GPI Day: Day {summary.get('peak_gpi_day', 'Unknown')}
+• Peak GPI Value: {summary.get('peak_gpi_value', 0):.2f}
+• Total Genesis Events: {summary.get('total_genesis_events', 0)}
+• Storm Development Success: {summary.get('total_storm_predictions', 0)}/{summary.get('total_genesis_events', 0)} events
+
+🎯 GENESIS EVENTS BREAKDOWN:
+"""
+        
+        if genesis_events:
+            for i, event in enumerate(genesis_events, 1):
+                summary_text += f"""
+Event {i}:
+• Date: {event['date']}
+• Location: {event['lat']:.1f}°N, {event['lon']:.1f}°E
+• GPI Value: {event['gpi']:.2f}
+• Genesis Probability: {event['probability']*100:.0f}%
+"""
+        else:
+            summary_text += "\n• No significant genesis events predicted for this month\n"
+        
+        summary_text += f"""
+
+🌪️ STORM TRACK PREDICTIONS:
+"""
+        
+        if storm_predictions:
+            for storm in storm_predictions:
+                track = storm['track']
+                if track:
+                    genesis = storm['genesis_event']
+                    max_intensity = max(pt['intensity'] for pt in track)
+                    max_category = categorize_typhoon_enhanced(max_intensity)
+                    track_duration = len(track) * 6  # hours
+                    final_pos = track[-1]
+                    
+                    summary_text += f"""
+Storm {storm['storm_id']}:
+• Genesis: Day {genesis['day']}, {genesis['lat']:.1f}°N {genesis['lon']:.1f}°E
+• Peak Intensity: {max_intensity:.0f} kt ({max_category})
+• Track Duration: {track_duration} hours ({track_duration/24:.1f} days)
+• Final Position: {final_pos['lat']:.1f}°N, {final_pos['lon']:.1f}°E
+• Uncertainty: ±{storm['uncertainty']['position_mean']:.1f}° position, ±{storm['uncertainty']['intensity_mean']:.0f} kt intensity
+"""
+        else:
+            summary_text += "\n• No storm development predicted from genesis events\n"
+        
+        # Add climatological context
+        summary_text += f"""
+
+📈 CLIMATOLOGICAL CONTEXT:
+• {month_name} Typical Activity: {'Very High' if month in [8,9] else 'High' if month in [7,10] else 'Moderate' if month in [6,11] else 'Low'}
+• ENSO Influence: {'Strong suppression expected' if oni_value > 1.0 else 'Moderate suppression' if oni_value > 0.5 else 'Strong enhancement likely' if oni_value < -1.0 else 'Moderate enhancement' if oni_value < -0.5 else 'Near-normal activity'}
+• Regional Focus: Western Pacific Main Development Region (10-25°N, 120-160°E)
+
+🔧 METHODOLOGY DETAILS:
+• Genesis Potential Index: Emanuel & Nolan (2004) formulation
+• Environmental Factors: SST, humidity, vorticity, wind shear, Coriolis effect
+• Temporal Resolution: Daily evolution throughout month
+• Spatial Resolution: 2.5° grid spacing
+• ENSO Modulation: Integrated ONI effects on environmental parameters
+• Track Prediction: Physics-based storm motion and intensity evolution
+
+⚠️  UNCERTAINTY & LIMITATIONS:
+• Genesis timing: ±2-3 days typical uncertainty
+• Track position: Growing uncertainty with time (±0.5° to ±2°)
+• Intensity prediction: ±5-15 kt uncertainty range
+• Environmental assumptions: Based on climatological patterns
+• Model limitations: Simplified compared to operational NWP systems
+
+🎯 FORECAST CONFIDENCE:
+• Genesis Location: {'High' if summary.get('peak_gpi_value', 0) > 2 else 'Moderate' if summary.get('peak_gpi_value', 0) > 1 else 'Low'}
+• Genesis Timing: {'High' if month in [7,8,9] else 'Moderate' if month in [6,10] else 'Low'}
+• Track Prediction: Moderate (physics-based motion patterns)
+• Intensity Evolution: Moderate (environmental constraints applied)
+
+📋 OPERATIONAL IMPLICATIONS:
+• Monitor Days {', '.join([str(event['day']) for event in genesis_events[:3]])} for potential development
+• Focus regions: {', '.join([f"{event['lat']:.0f}°N {event['lon']:.0f}°E" for event in genesis_events[:3]])}
+• Preparedness level: {'High' if len(storm_predictions) > 2 else 'Moderate' if len(storm_predictions) > 0 else 'Routine'}
+
+🔬 RESEARCH APPLICATIONS:
+• Suitable for seasonal planning and climate studies
+• Genesis mechanism investigation
+• ENSO-typhoon relationship analysis
+• Environmental parameter sensitivity studies
+
+⚠️  IMPORTANT DISCLAIMERS:
+• This is a research prediction system, not operational forecast
+• Use official meteorological services for real-time warnings
+• Actual conditions may differ from climatological assumptions
+• Model simplified compared to operational prediction systems
+• Uncertainty grows significantly beyond 5-7 day lead times
+"""
+        
+        return summary_text
+        
+    except Exception as e:
+        logging.error(f"Error creating prediction summary: {e}")
+        return f"Error generating summary: {str(e)}"
+
 # -----------------------------
 # FIXED: ADVANCED ML FEATURES WITH ROBUST ERROR HANDLING
 # -----------------------------
@@ -1508,712 +2255,6 @@ def create_separate_clustering_plots(storm_features, typhoon_data, method='umap'
         )
         return error_fig, error_fig, error_fig, error_fig, f"Error in clustering: {str(e)}"
 
-# -----------------------------
-# ENHANCED: Advanced Prediction System with Route Forecasting
-# -----------------------------
-
-def create_advanced_prediction_model(typhoon_data):
-    """Create advanced ML model for intensity and route prediction"""
-    try:
-        if typhoon_data is None or typhoon_data.empty:
-            return None, "No data available for model training"
-        
-        # Prepare training data
-        features = []
-        targets = []
-        
-        for sid in typhoon_data['SID'].unique():
-            storm_data = typhoon_data[typhoon_data['SID'] == sid].sort_values('ISO_TIME')
-            
-            if len(storm_data) < 3:  # Need at least 3 points for prediction
-                continue
-            
-            for i in range(len(storm_data) - 1):
-                current = storm_data.iloc[i]
-                next_point = storm_data.iloc[i + 1]
-                
-                # Extract features (current state)
-                feature_row = []
-                
-                # Current position
-                feature_row.extend([
-                    current.get('LAT', 20),
-                    current.get('LON', 140)
-                ])
-                
-                # Current intensity
-                feature_row.extend([
-                    current.get('USA_WIND', 30),
-                    current.get('USA_PRES', 1000)
-                ])
-                
-                # Time features
-                if 'ISO_TIME' in current and pd.notna(current['ISO_TIME']):
-                    month = current['ISO_TIME'].month
-                    day_of_year = current['ISO_TIME'].dayofyear
-                else:
-                    month = 9  # Peak season default
-                    day_of_year = 250
-                
-                feature_row.extend([month, day_of_year])
-                
-                # Motion features (if previous point exists)
-                if i > 0:
-                    prev = storm_data.iloc[i - 1]
-                    dlat = current.get('LAT', 20) - prev.get('LAT', 20)
-                    dlon = current.get('LON', 140) - prev.get('LON', 140)
-                    speed = np.sqrt(dlat**2 + dlon**2)
-                    bearing = np.arctan2(dlat, dlon)
-                else:
-                    speed = 0
-                    bearing = 0
-                
-                feature_row.extend([speed, bearing])
-                
-                features.append(feature_row)
-                
-                # Target: next position and intensity
-                targets.append([
-                    next_point.get('LAT', 20),
-                    next_point.get('LON', 140),
-                    next_point.get('USA_WIND', 30)
-                ])
-        
-        if len(features) < 10:  # Need sufficient training data
-            return None, "Insufficient data for model training"
-        
-        # Train model
-        X = np.array(features)
-        y = np.array(targets)
-        
-        # Split data
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-        
-        # Create separate models for position and intensity
-        models = {}
-        
-        # Position model (lat, lon)
-        pos_model = RandomForestRegressor(n_estimators=100, random_state=42)
-        pos_model.fit(X_train, y_train[:, :2])
-        models['position'] = pos_model
-        
-        # Intensity model (wind speed)
-        int_model = RandomForestRegressor(n_estimators=100, random_state=42)
-        int_model.fit(X_train, y_train[:, 2])
-        models['intensity'] = int_model
-        
-        # Calculate model performance
-        pos_pred = pos_model.predict(X_test)
-        int_pred = int_model.predict(X_test)
-        
-        pos_mae = mean_absolute_error(y_test[:, :2], pos_pred)
-        int_mae = mean_absolute_error(y_test[:, 2], int_pred)
-        
-        model_info = f"Position MAE: {pos_mae:.2f}°, Intensity MAE: {int_mae:.2f} kt"
-        
-        return models, model_info
-        
-    except Exception as e:
-        return None, f"Error creating prediction model: {str(e)}"
-
-def get_realistic_genesis_locations():
-    """Get realistic typhoon genesis regions based on climatology"""
-    return {
-        "Western Pacific Main Development Region": {"lat": 12.5, "lon": 145.0, "description": "Peak activity zone (Guam area)"},
-        "South China Sea": {"lat": 15.0, "lon": 115.0, "description": "Secondary development region"},
-        "Philippine Sea": {"lat": 18.0, "lon": 135.0, "description": "Recurving storm region"},
-        "Marshall Islands": {"lat": 8.0, "lon": 165.0, "description": "Eastern development zone"},
-        "Monsoon Trough": {"lat": 10.0, "lon": 130.0, "description": "Monsoon-driven genesis"},
-        "ITCZ Region": {"lat": 6.0, "lon": 140.0, "description": "Near-equatorial development"},
-        "Subtropical Region": {"lat": 22.0, "lon": 125.0, "description": "Late season development"},
-        "Bay of Bengal": {"lat": 15.0, "lon": 88.0, "description": "Indian Ocean cyclones"},
-        "Eastern Pacific": {"lat": 12.0, "lon": -105.0, "description": "Hurricane development zone"},
-        "Atlantic MDR": {"lat": 12.0, "lon": -45.0, "description": "Main Development Region"}
-    }
-
-def predict_storm_route_and_intensity_realistic(genesis_region, month, oni_value, models=None, forecast_hours=72, use_advanced_physics=True):
-    """Realistic prediction with proper typhoon speeds and development"""
-    try:
-        genesis_locations = get_realistic_genesis_locations()
-        
-        if genesis_region not in genesis_locations:
-            genesis_region = "Western Pacific Main Development Region"  # Default
-        
-        genesis_info = genesis_locations[genesis_region]
-        lat = genesis_info["lat"]
-        lon = genesis_info["lon"]
-        
-        results = {
-            'current_prediction': {},
-            'route_forecast': [],
-            'confidence_scores': {},
-            'model_info': 'Realistic Genesis Model',
-            'genesis_info': genesis_info
-        }
-        
-        # REALISTIC starting intensity - Tropical Depression level
-        base_intensity = 30  # Start at TD level (25-35 kt)
-        
-        # Environmental factors for genesis
-        if oni_value > 1.0:  # Strong El Niño - suppressed development
-            intensity_modifier = -6
-        elif oni_value > 0.5:  # Moderate El Niño
-            intensity_modifier = -3
-        elif oni_value < -1.0:  # Strong La Niña - enhanced development
-            intensity_modifier = +8
-        elif oni_value < -0.5:  # Moderate La Niña
-            intensity_modifier = +5
-        else:  # Neutral
-            intensity_modifier = oni_value * 2
-        
-        # Seasonal genesis effects
-        seasonal_factors = {
-            1: -8, 2: -6, 3: -4, 4: -2, 5: 2, 6: 6,
-            7: 10, 8: 12, 9: 15, 10: 10, 11: 4, 12: -5
-        }
-        seasonal_modifier = seasonal_factors.get(month, 0)
-        
-        # Genesis region favorability
-        region_factors = {
-            "Western Pacific Main Development Region": 8,
-            "South China Sea": 4,
-            "Philippine Sea": 5,
-            "Marshall Islands": 7,
-            "Monsoon Trough": 6,
-            "ITCZ Region": 3,
-            "Subtropical Region": 2,
-            "Bay of Bengal": 4,
-            "Eastern Pacific": 6,
-            "Atlantic MDR": 5
-        }
-        region_modifier = region_factors.get(genesis_region, 0)
-        
-        # Calculate realistic starting intensity (TD level)
-        predicted_intensity = base_intensity + intensity_modifier + seasonal_modifier + region_modifier
-        predicted_intensity = max(25, min(40, predicted_intensity))  # Keep in TD-weak TS range
-        
-        # Add realistic uncertainty for genesis
-        intensity_uncertainty = np.random.normal(0, 2)
-        predicted_intensity += intensity_uncertainty
-        predicted_intensity = max(25, min(38, predicted_intensity))  # TD range
-        
-        results['current_prediction'] = {
-            'intensity_kt': predicted_intensity,
-            'pressure_hpa': 1008 - (predicted_intensity - 25) * 0.6,  # Realistic TD pressure
-            'category': categorize_typhoon_enhanced(predicted_intensity),
-            'genesis_region': genesis_region
-        }
-        
-        # REALISTIC route prediction with proper typhoon speeds
-        current_lat = lat
-        current_lon = lon
-        current_intensity = predicted_intensity
-        
-        route_points = []
-        
-        # Track storm development over time with REALISTIC SPEEDS
-        for hour in range(0, forecast_hours + 6, 6):
-            
-            # REALISTIC typhoon motion - much faster speeds
-            # Typical typhoon forward speed: 15-25 km/h (0.14-0.23°/hour)
-            
-            # Base forward speed depends on latitude and storm intensity
-            if current_lat < 20:  # Low latitude - slower
-                base_speed = 0.12  # ~13 km/h
-            elif current_lat < 30:  # Mid latitude - moderate
-                base_speed = 0.18  # ~20 km/h
-            else:  # High latitude - faster
-                base_speed = 0.25  # ~28 km/h
-            
-            # Intensity affects speed (stronger storms can move faster)
-            intensity_speed_factor = 1.0 + (current_intensity - 50) / 200
-            base_speed *= max(0.8, min(1.4, intensity_speed_factor))
-            
-            # Beta drift (Coriolis effect) - realistic values
-            beta_drift_lat = 0.02 * np.sin(np.radians(current_lat))
-            beta_drift_lon = -0.05 * np.cos(np.radians(current_lat))
-            
-            # Seasonal steering patterns with realistic speeds
-            if month in [6, 7, 8, 9]:  # Peak season
-                ridge_strength = 1.2
-                ridge_position = 32 + 4 * np.sin(2 * np.pi * (month - 6) / 4)
-            else:  # Off season
-                ridge_strength = 0.9
-                ridge_position = 28
-            
-            # REALISTIC motion based on position relative to subtropical ridge
-            if current_lat < ridge_position - 10:  # Well south of ridge - westward movement
-                lat_tendency = base_speed * 0.3 + beta_drift_lat  # Slight poleward
-                lon_tendency = -base_speed * 0.9 + beta_drift_lon  # Strong westward
-            elif current_lat > ridge_position - 3:  # Near ridge - recurvature
-                lat_tendency = base_speed * 0.8 + beta_drift_lat  # Strong poleward
-                lon_tendency = base_speed * 0.4 + beta_drift_lon  # Eastward
-            else:  # In between - normal WNW motion
-                lat_tendency = base_speed * 0.4 + beta_drift_lat  # Moderate poleward
-                lon_tendency = -base_speed * 0.7 + beta_drift_lon  # Moderate westward
-            
-            # ENSO steering modulation (realistic effects)
-            if oni_value > 0.5:  # El Niño - more eastward/poleward motion
-                lon_tendency += 0.05
-                lat_tendency += 0.02
-            elif oni_value < -0.5:  # La Niña - more westward motion
-                lon_tendency -= 0.08
-                lat_tendency -= 0.01
-            
-            # Add motion uncertainty that grows with time (realistic error growth)
-            motion_uncertainty = 0.02 + (hour / 120) * 0.04
-            lat_noise = np.random.normal(0, motion_uncertainty)
-            lon_noise = np.random.normal(0, motion_uncertainty)
-            
-            # Update position with realistic speeds
-            current_lat += lat_tendency + lat_noise
-            current_lon += lon_tendency + lon_noise
-            
-            # REALISTIC intensity evolution with proper development cycles
-            
-            # Development phase (first 48-72 hours) - realistic intensification
-            if hour <= 48:
-                if current_intensity < 50:  # Still weak - rapid development possible
-                    if 10 <= current_lat <= 25 and 115 <= current_lon <= 165:  # Favorable environment
-                        intensity_tendency = 4.5 if current_intensity < 35 else 3.0
-                    elif 120 <= current_lon <= 155 and 15 <= current_lat <= 20:  # Best environment
-                        intensity_tendency = 6.0 if current_intensity < 40 else 4.0
-                    else:
-                        intensity_tendency = 2.0
-                elif current_intensity < 80:  # Moderate intensity
-                    intensity_tendency = 2.5 if (120 <= current_lon <= 155 and 10 <= current_lat <= 25) else 1.0
-                else:  # Already strong
-                    intensity_tendency = 1.0
-                    
-            # Mature phase (48-120 hours) - peak intensity maintenance
-            elif hour <= 120:
-                if current_lat < 25 and current_lon > 120:  # Still in favorable waters
-                    if current_intensity < 120:
-                        intensity_tendency = 1.5
-                    else:
-                        intensity_tendency = 0.0  # Maintain intensity
-                else:
-                    intensity_tendency = -1.5
-                    
-            # Extended phase (120+ hours) - gradual weakening
-            else:
-                if current_lat < 30 and current_lon > 115:
-                    intensity_tendency = -2.0  # Slow weakening
-                else:
-                    intensity_tendency = -3.5  # Faster weakening
-            
-            # Environmental modulation (realistic effects)
-            if current_lat > 35:  # High latitude - rapid weakening
-                intensity_tendency -= 12
-            elif current_lat > 30:  # Moderate latitude
-                intensity_tendency -= 5
-            elif current_lon < 110:  # Land interaction
-                intensity_tendency -= 15
-            elif 125 <= current_lon <= 155 and 10 <= current_lat <= 25:  # Warm pool
-                intensity_tendency += 2
-            elif 160 <= current_lon <= 180 and 15 <= current_lat <= 30:  # Still warm
-                intensity_tendency += 1
-            
-            # SST effects (realistic temperature impact)
-            if current_lat < 8:  # Very warm but weak Coriolis
-                intensity_tendency += 0.5
-            elif 8 <= current_lat <= 20:  # Sweet spot for development
-                intensity_tendency += 2.0
-            elif 20 < current_lat <= 30:  # Marginal
-                intensity_tendency -= 1.0
-            elif current_lat > 30:  # Cool waters
-                intensity_tendency -= 4.0
-            
-            # Shear effects (simplified but realistic)
-            if month in [12, 1, 2, 3]:  # High shear season
-                intensity_tendency -= 2.0
-            elif month in [7, 8, 9]:  # Low shear season
-                intensity_tendency += 1.0
-            
-            # Update intensity with realistic bounds and variability
-            intensity_noise = np.random.normal(0, 1.5)  # Small random fluctuations
-            current_intensity += intensity_tendency + intensity_noise
-            current_intensity = max(20, min(185, current_intensity))  # Realistic range
-            
-            # Calculate confidence based on forecast time and environment
-            base_confidence = 0.92
-            time_penalty = (hour / 120) * 0.45
-            environment_penalty = 0.15 if current_lat > 30 or current_lon < 115 else 0
-            confidence = max(0.25, base_confidence - time_penalty - environment_penalty)
-            
-            # Determine development stage
-            if hour <= 24:
-                stage = 'Genesis'
-            elif hour <= 72:
-                stage = 'Development'
-            elif hour <= 120:
-                stage = 'Mature'
-            elif hour <= 240:
-                stage = 'Extended'
-            else:
-                stage = 'Long-term'
-            
-            route_points.append({
-                'hour': hour,
-                'lat': current_lat,
-                'lon': current_lon,
-                'intensity_kt': current_intensity,
-                'category': categorize_typhoon_enhanced(current_intensity),
-                'confidence': confidence,
-                'development_stage': stage,
-                'forward_speed_kmh': base_speed * 111,  # Convert to km/h
-                'pressure_hpa': max(900, 1013 - (current_intensity - 25) * 0.9)
-            })
-        
-        results['route_forecast'] = route_points
-        
-        # Realistic confidence scores
-        results['confidence_scores'] = {
-            'genesis': 0.88,
-            'early_development': 0.82,
-            'position_24h': 0.85,
-            'position_48h': 0.78,
-            'position_72h': 0.68,
-            'intensity_24h': 0.75,
-            'intensity_48h': 0.65,
-            'intensity_72h': 0.55,
-            'long_term': max(0.3, 0.8 - (forecast_hours / 240) * 0.5)
-        }
-        
-        # Model information
-        results['model_info'] = f"Enhanced Realistic Model - {genesis_region}"
-        
-        return results
-        
-    except Exception as e:
-        logging.error(f"Realistic prediction error: {str(e)}")
-        return {
-            'error': f"Prediction error: {str(e)}",
-            'current_prediction': {'intensity_kt': 30, 'category': 'Tropical Depression'},
-            'route_forecast': [],
-            'confidence_scores': {},
-            'model_info': 'Error in prediction'
-        }
-
-# -----------------------------
-# NEW: SIMPLIFIED MULTI-ROUTE PREDICTION FUNCTIONS
-# -----------------------------
-
-def generate_multiple_route_predictions(month, oni_value, num_routes=5):
-    """Generate multiple realistic route predictions for animation"""
-    
-    # Realistic genesis regions for variety
-    genesis_regions = [
-        "Western Pacific Main Development Region",
-        "South China Sea", 
-        "Philippine Sea",
-        "Marshall Islands",
-        "Monsoon Trough"
-    ]
-    
-    all_predictions = []
-    
-    for i in range(num_routes):
-        # Use different genesis regions and slight ONI variations for diversity
-        region = genesis_regions[i % len(genesis_regions)]
-        
-        # Add small random variation to ONI for route diversity
-        oni_variation = oni_value + np.random.normal(0, 0.2)
-        
-        # Generate prediction for this route
-        prediction = predict_storm_route_and_intensity_realistic(
-            region, 
-            month, 
-            oni_variation,
-            forecast_hours=120,  # 5 day forecast
-            use_advanced_physics=True
-        )
-        
-        prediction['route_id'] = i + 1
-        prediction['genesis_region'] = region
-        prediction['oni_used'] = oni_variation
-        all_predictions.append(prediction)
-    
-    return all_predictions
-
-def create_multi_route_animation(all_predictions, enable_animation=True):
-    """Create animated visualization showing multiple predicted routes"""
-    
-    # Route colors for multiple predictions
-    route_colors = ['#FF0066', '#00FF66', '#6600FF', '#FF6600', '#0066FF']
-    
-    if not all_predictions or not any(pred.get('route_forecast') for pred in all_predictions):
-        # Return error plot if no valid predictions
-        fig = go.Figure()
-        fig.add_annotation(
-            text="No valid route predictions generated",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, xanchor='center', yanchor='middle',
-            showarrow=False, font_size=16
-        )
-        return fig
-    
-    fig = go.Figure()
-    
-    if enable_animation:
-        # Find max forecast length for consistent animation
-        max_hours = max(len(pred['route_forecast']) for pred in all_predictions if pred.get('route_forecast'))
-        
-        # Add genesis points for all routes (static background)
-        for i, prediction in enumerate(all_predictions):
-            if prediction.get('route_forecast'):
-                first_point = prediction['route_forecast'][0]
-                color = route_colors[i % len(route_colors)]
-                
-                fig.add_trace(
-                    go.Scattergeo(
-                        lon=[first_point['lon']],
-                        lat=[first_point['lat']],
-                        mode='markers',
-                        marker=dict(
-                            size=20,
-                            color=color,
-                            symbol='star',
-                            line=dict(width=2, color='white')
-                        ),
-                        name=f'Route {prediction["route_id"]} Genesis',
-                        showlegend=True,
-                        hovertemplate=(
-                            f"<b>Route {prediction['route_id']} Genesis</b><br>"
-                            f"Region: {prediction['genesis_region']}<br>"
-                            f"ONI: {prediction['oni_used']:.2f}<br>"
-                            "<extra></extra>"
-                        )
-                    )
-                )
-        
-        # Create animation frames
-        frames = []
-        
-        for frame_idx in range(max_hours):
-            frame_data = []
-            
-            for i, prediction in enumerate(all_predictions):
-                route_data = prediction.get('route_forecast', [])
-                color = route_colors[i % len(route_colors)]
-                
-                if frame_idx < len(route_data):
-                    # Get route points up to current frame
-                    current_points = route_data[:frame_idx + 1]
-                    
-                    if current_points:
-                        lats = [p['lat'] for p in current_points]
-                        lons = [p['lon'] for p in current_points]
-                        intensities = [p['intensity_kt'] for p in current_points]
-                        
-                        # Add route line
-                        frame_data.append(
-                            go.Scattergeo(
-                                lon=lons,
-                                lat=lats,
-                                mode='lines+markers',
-                                line=dict(color=color, width=3),
-                                marker=dict(
-                                    size=[6 + max(0, int/15) for int in intensities],
-                                    color=color,
-                                    opacity=0.8
-                                ),
-                                name=f'Route {prediction["route_id"]}',
-                                showlegend=False,
-                                hovertemplate=(
-                                    f"<b>Route {prediction['route_id']}</b><br>"
-                                    f"Hour {current_points[-1]['hour']}<br>"
-                                    f"Intensity: {current_points[-1]['intensity_kt']:.0f} kt<br>"
-                                    f"Category: {current_points[-1]['category']}<br>"
-                                    "<extra></extra>"
-                                )
-                            )
-                        )
-            
-            frames.append(go.Frame(
-                data=frame_data,
-                name=str(frame_idx),
-                layout=go.Layout(
-                    title=f"Multi-Route Storm Development Animation - Hour {frame_idx * 6}"
-                )
-            ))
-        
-        fig.frames = frames
-        
-        # Add animation controls
-        fig.update_layout(
-            updatemenus=[{
-                "buttons": [
-                    {
-                        "args": [None, {"frame": {"duration": 800, "redraw": True},
-                                      "fromcurrent": True, "transition": {"duration": 300}}],
-                        "label": "▶️ Play",
-                        "method": "animate"
-                    },
-                    {
-                        "args": [[None], {"frame": {"duration": 0, "redraw": True},
-                                        "mode": "immediate", "transition": {"duration": 0}}],
-                        "label": "⏸️ Pause",
-                        "method": "animate"
-                    }
-                ],
-                "direction": "left",
-                "pad": {"r": 10, "t": 87},
-                "showactive": False,
-                "type": "buttons",
-                "x": 0.1,
-                "xanchor": "right", 
-                "y": 0,
-                "yanchor": "top"
-            }],
-            sliders=[{
-                "active": 0,
-                "yanchor": "top",
-                "xanchor": "left",
-                "currentvalue": {
-                    "font": {"size": 16},
-                    "prefix": "Hour: ",
-                    "visible": True,
-                    "xanchor": "right"
-                },
-                "transition": {"duration": 300, "easing": "cubic-in-out"},
-                "pad": {"b": 10, "t": 50},
-                "len": 0.9,
-                "x": 0.1,
-                "y": 0,
-                "steps": [
-                    {
-                        "args": [[str(i)], {"frame": {"duration": 300, "redraw": True},
-                                           "mode": "immediate", "transition": {"duration": 300}}],
-                        "label": f"H{i*6}",
-                        "method": "animate"
-                    }
-                    for i in range(0, max_hours, max(1, max_hours//20))
-                ]
-            }]
-        )
-        
-    else:
-        # Static version showing all complete routes
-        for i, prediction in enumerate(all_predictions):
-            route_data = prediction.get('route_forecast', [])
-            color = route_colors[i % len(route_colors)]
-            
-            if route_data:
-                lats = [p['lat'] for p in route_data]
-                lons = [p['lon'] for p in route_data]
-                intensities = [p['intensity_kt'] for p in route_data]
-                
-                # Add complete route
-                fig.add_trace(
-                    go.Scattergeo(
-                        lon=lons,
-                        lat=lats,
-                        mode='lines+markers',
-                        line=dict(color=color, width=3),
-                        marker=dict(
-                            size=[6 + max(0, int/15) for int in intensities],
-                            color=color,
-                            opacity=0.8
-                        ),
-                        name=f'Route {prediction["route_id"]} - {prediction["genesis_region"][:20]}...',
-                        hovertemplate=(
-                            f"<b>Route {prediction['route_id']}</b><br>"
-                            f"Region: {prediction['genesis_region']}<br>"
-                            f"ONI: {prediction['oni_used']:.2f}<br>"
-                            "<extra></extra>"
-                        )
-                    )
-                )
-                
-                # Add genesis marker
-                fig.add_trace(
-                    go.Scattergeo(
-                        lon=[lons[0]],
-                        lat=[lats[0]],
-                        mode='markers',
-                        marker=dict(
-                            size=20,
-                            color=color,
-                            symbol='star',
-                            line=dict(width=2, color='white')
-                        ),
-                        name=f'Route {prediction["route_id"]} Genesis',
-                        showlegend=False
-                    )
-                )
-    
-    # Update layout
-    fig.update_layout(
-        title="Multiple Route Storm Predictions" + (" (Animated)" if enable_animation else " (Static)"),
-        geo=dict(
-            projection_type="natural earth",
-            showland=True,
-            landcolor="LightGray",
-            showocean=True,
-            oceancolor="LightBlue",
-            showcoastlines=True,
-            coastlinecolor="Gray",
-            center=dict(lat=20, lon=140),
-            projection_scale=2.0
-        ),
-        height=800
-    )
-    
-    return fig
-
-def create_intensity_comparison(all_predictions):
-    """Create intensity comparison plot for multiple routes"""
-    fig = go.Figure()
-    
-    route_colors = ['#FF0066', '#00FF66', '#6600FF', '#FF6600', '#0066FF']
-    
-    for i, prediction in enumerate(all_predictions):
-        route_data = prediction.get('route_forecast', [])
-        if route_data:
-            hours = [p['hour'] for p in route_data]
-            intensities = [p['intensity_kt'] for p in route_data]
-            color = route_colors[i % len(route_colors)]
-            
-            fig.add_trace(
-                go.Scatter(
-                    x=hours,
-                    y=intensities,
-                    mode='lines+markers',
-                    line=dict(color=color, width=3),
-                    marker=dict(size=6, color=color),
-                    name=f'Route {prediction["route_id"]}',
-                    hovertemplate=(
-                        f"<b>Route {prediction['route_id']}</b><br>"
-                        f"Hour: %{{x}}<br>"
-                        f"Intensity: %{{y:.0f}} kt<br>"
-                        "<extra></extra>"
-                    )
-                )
-            )
-    
-    # Add category threshold lines
-    thresholds = [34, 64, 83, 96, 113, 137]
-    threshold_names = ['TS', 'C1', 'C2', 'C3', 'C4', 'C5']
-    
-    for thresh, name in zip(thresholds, threshold_names):
-        fig.add_hline(
-            y=thresh,
-            line_dash="dash",
-            line_color="gray",
-            annotation_text=name,
-            annotation_position="right"
-        )
-    
-    fig.update_layout(
-        title="Intensity Evolution Comparison - All Routes",
-        xaxis_title="Forecast Hour",
-        yaxis_title="Wind Speed (kt)",
-        height=400
-    )
-    
-    return fig
-
 # -----------------------------
 # Regression Functions (Original)
 # -----------------------------
@@ -2791,204 +2832,71 @@ def create_interface():
                 """
                 gr.Markdown(overview_text)
 
-            with gr.Tab("🎯 Simple Multi-Route Prediction"):
-                gr.Markdown("## 🎯 Simple Storm Prediction - Just Month & ONI")
-                gr.Markdown("**Enter just the month and ONI value to see 5 different realistic storm development scenarios with prediction uncertainty**")
+            with gr.Tab("🌊 Monthly Typhoon Genesis Prediction"):
+                gr.Markdown("## 🌊 Monthly Typhoon Genesis Prediction")
+                gr.Markdown("**Enter month (1-12) and ONI value to see realistic typhoon development throughout the month using Genesis Potential Index**")
                 
                 with gr.Row():
                     with gr.Column(scale=1):
-                        simple_pred_month = gr.Slider(
+                        genesis_month = gr.Slider(
                             1, 12, 
-                            label="Prediction Month", 
+                            label="Month", 
                             value=9,
-                            info="Peak typhoon season: Jul-Oct"
+                            step=1,
+                            info="1=Jan, 2=Feb, ..., 12=Dec"
                         )
-                        simple_pred_oni = gr.Number(
+                        genesis_oni = gr.Number(
                             label="ONI Value", 
                             value=0.0,
                             info="El Niño (+) / La Niña (-) / Neutral (0)"
                         )
-                        simple_enable_animation = gr.Checkbox(
+                        enable_genesis_animation = gr.Checkbox(
                             label="Enable Animation", 
                             value=True,
-                            info="Watch storms develop over time"
+                            info="Watch daily genesis potential evolution"
                         )
-                        simple_predict_btn = gr.Button("🌊 Generate 5 Route Predictions", variant="primary", size="lg")
+                        generate_genesis_btn = gr.Button("🌊 Generate Monthly Genesis Prediction", variant="primary", size="lg")
                     
                     with gr.Column(scale=2):
                         gr.Markdown("### 🌊 What You'll Get:")
                         gr.Markdown("""
-                        - **5 Different Routes**: Various genesis regions and development paths
-                        - **Real-time Animation**: Watch all storms develop simultaneously  
-                        - **Intensity Tracking**: See how each route intensifies differently
-                        - **Realistic Physics**: Environmental effects on each route
-                        - **Prediction Errors**: Uncertainty estimates and confidence intervals
-                        - **Comparative Analysis**: See best/worst case scenarios
+                        - **Daily GPI Evolution**: See genesis potential change day-by-day throughout the month
+                        - **Genesis Event Detection**: Automatic identification of likely cyclogenesis times/locations
+                        - **Storm Track Development**: Physics-based tracks from each genesis point
+                        - **Real-time Animation**: Watch storms develop and move with uncertainty visualization
+                        - **Environmental Analysis**: SST, humidity, wind shear, and vorticity effects
+                        - **ENSO Modulation**: How El Niño/La Niña affects monthly patterns
                         """)
                 
                 with gr.Row():
-                    simple_route_animation = gr.Plot(label="🗺️ Multi-Route Animation")
-                
-                with gr.Row():
-                    simple_intensity_comparison = gr.Plot(label="📊 Intensity Evolution Comparison")
+                    genesis_animation = gr.Plot(label="🗺️ Daily Genesis Potential & Storm Development")
                 
                 with gr.Row():
-                    simple_prediction_summary = gr.Textbox(label="📋 Prediction Summary with Error Analysis", lines=20)
+                    genesis_summary = gr.Textbox(label="📋 Monthly Genesis Analysis Summary", lines=25)
                 
-                def run_simplified_prediction(month, oni, animation):
+                def run_genesis_prediction(month, oni, animation):
                     try:
-                        # Generate multiple route predictions
-                        all_predictions = generate_multiple_route_predictions(month, oni, num_routes=5)
-                        
-                        # Create multi-route animation
-                        route_fig = create_multi_route_animation(all_predictions, animation)
-                        
-                        # Create intensity comparison
-                        intensity_fig = create_intensity_comparison(all_predictions)
-                        
-                        # Generate summary text with error analysis
-                        summary_text = f"""
-SIMPLIFIED MULTI-ROUTE PREDICTION SUMMARY WITH ERROR ANALYSIS
-{'='*65}
-
-INPUT CONDITIONS:
-• Month: {month} {'(Peak Season)' if month in [7,8,9,10] else '(Off Season)'}
-• ONI Value: {oni:.2f} {'(El Niño)' if oni > 0.5 else '(La Niña)' if oni < -0.5 else '(Neutral)'}
-
-ROUTE PREDICTIONS GENERATED: 5 scenarios
-
-ROUTE BREAKDOWN:
-"""
-                        
-                        all_max_intensities = []
-                        all_final_intensities = []
-                        genesis_regions = []
+                        # Generate monthly prediction using GPI
+                        prediction_data = generate_genesis_prediction_monthly(month, oni, year=2025)
                         
-                        for i, pred in enumerate(all_predictions):
-                            route_data = pred.get('route_forecast', [])
-                            if route_data:
-                                max_intensity = max(p['intensity_kt'] for p in route_data)
-                                final_intensity = route_data[-1]['intensity_kt']
-                                max_category = max((categorize_typhoon_enhanced(p['intensity_kt']) for p in route_data), 
-                                                 key=lambda x: ['Tropical Depression', 'Tropical Storm', 'C1 Typhoon', 'C2 Typhoon', 'C3 Strong Typhoon', 'C4 Very Strong Typhoon', 'C5 Super Typhoon'].index(x))
-                                
-                                all_max_intensities.append(max_intensity)
-                                all_final_intensities.append(final_intensity)
-                                genesis_regions.append(pred['genesis_region'])
-                                
-                                summary_text += f"""
-ROUTE {pred['route_id']}:
-• Genesis: {pred['genesis_region']}
-• ONI Used: {pred['oni_used']:.2f}
-• Peak Intensity: {max_intensity:.0f} kt ({max_category})
-• Final Intensity: {final_intensity:.0f} kt
-• Duration: {len(route_data)} time steps ({len(route_data)*6} hours)
-• Confidence: {pred.get('confidence_scores', {}).get('long_term', 0.5)*100:.0f}%
-"""
+                        # Create animation
+                        genesis_fig = create_genesis_animation(prediction_data, animation)
                         
-                        # Enhanced scenario analysis with prediction errors
-                        if all_max_intensities:
-                            mean_max = np.mean(all_max_intensities)
-                            std_max = np.std(all_max_intensities)
-                            mean_final = np.mean(all_final_intensities)
-                            std_final = np.std(all_final_intensities)
-                            
-                            # Calculate prediction uncertainty metrics
-                            intensity_range = max(all_max_intensities) - min(all_max_intensities)
-                            prediction_skill = max(0, 1 - (std_max / max(mean_max, 1)))
-                            
-                            # Environmental predictability
-                            if month in [7, 8, 9]:  # Peak season
-                                environmental_predictability = 0.8
-                            elif month in [10, 11, 6]:  # Shoulder season
-                                environmental_predictability = 0.6
-                            else:  # Off season
-                                environmental_predictability = 0.4
-                            
-                            # ENSO influence on predictability
-                            enso_predictability = 0.7 + 0.2 * min(abs(oni), 2.0) / 2.0
-                            
-                            # Overall prediction confidence
-                            overall_confidence = (prediction_skill * 0.4 + 
-                                                environmental_predictability * 0.3 + 
-                                                enso_predictability * 0.3)
-                            
-                            summary_text += f"""
-
-PREDICTION ERROR & UNCERTAINTY ANALYSIS:
-==========================================
-
-INTENSITY STATISTICS:
-• Peak Intensity Range: {min(all_max_intensities):.0f} - {max(all_max_intensities):.0f} kt
-• Mean Peak Intensity: {mean_max:.0f} ± {std_max:.0f} kt
-• Final Intensity Range: {min(all_final_intensities):.0f} - {max(all_final_intensities):.0f} kt
-• Mean Final Intensity: {mean_final:.0f} ± {std_final:.0f} kt
-
-PREDICTION UNCERTAINTY METRICS:
-• Intensity Spread: {intensity_range:.0f} kt (uncertainty range)
-• Prediction Skill: {prediction_skill:.2f} (0=poor, 1=excellent)
-• Environmental Predictability: {environmental_predictability:.2f}
-• ENSO Influence Factor: {enso_predictability:.2f}
-• Overall Confidence: {overall_confidence:.2f} ({overall_confidence*100:.0f}%)
-
-ERROR SOURCES & LIMITATIONS:
-• Genesis Location Uncertainty: ±2-5° lat/lon
-• Steering Flow Variability: ±15-25% track speed
-• Intensity Development: ±20-40 kt at 72h forecast
-• Environmental Interaction: Variable SST/shear effects
-• Model Physics: Simplified compared to full NWP models
-
-INTERPRETATION GUIDE:
-{"🔴 HIGH UNCERTAINTY" if overall_confidence < 0.5 else "🟡 MODERATE UNCERTAINTY" if overall_confidence < 0.7 else "🟢 GOOD CONFIDENCE"}
-• Spread > 40 kt: High uncertainty scenario
-• Spread 20-40 kt: Moderate uncertainty
-• Spread < 20 kt: Good agreement between scenarios
-
-FORECAST SKILL BY TIME:
-• 0-24h: ~85% position accuracy, ~75% intensity
-• 24-48h: ~75% position accuracy, ~65% intensity  
-• 48-72h: ~65% position accuracy, ~55% intensity
-• 72h+: ~50% position accuracy, ~45% intensity
-
-GENESIS REGION DIVERSITY:
-• Primary Regions: {len(set(genesis_regions))} different zones
-• Most Active: {max(set(genesis_regions), key=genesis_regions.count)}
-• Least Represented: {min(set(genesis_regions), key=genesis_regions.count)}
-
-SEASONAL CONTEXT:
-{"Peak season - higher confidence in development patterns" if month in [7,8,9,10] else "Off-season - increased uncertainty in storm behavior"}
-
-ENSO INFLUENCE:
-{"Strong El Niño suppression expected" if oni > 1.0 else "Moderate El Niño effects" if oni > 0.5 else "Strong La Niña enhancement likely" if oni < -1.0 else "Moderate La Niña effects" if oni < -0.5 else "Neutral ENSO - average conditions"}
-
-ANIMATION FEATURES:
-{"✅ Real-time development animation enabled" if animation else "📊 Static multi-route comparison"}
-✅ 5 simultaneous storm tracks with uncertainty
-✅ Color-coded intensity evolution
-✅ Realistic genesis locations and physics
-✅ Environmental coupling effects
-✅ Confidence-weighted predictions
-
-⚠️  IMPORTANT DISCLAIMERS:
-• These are statistical predictions, not operational forecasts
-• Actual storms may behave differently due to unmodeled factors
-• Use for research/planning only, not for emergency decisions
-• Consult official meteorological services for real forecasts
-• Model simplified compared to operational NWP systems
-"""
+                        # Generate summary
+                        summary_text = create_prediction_summary(prediction_data)
                         
-                        return route_fig, intensity_fig, summary_text
+                        return genesis_fig, summary_text
                         
                     except Exception as e:
                         import traceback
-                        error_msg = f"Prediction failed: {str(e)}\n\nDetails:\n{traceback.format_exc()}"
+                        error_msg = f"Genesis prediction failed: {str(e)}\n\nDetails:\n{traceback.format_exc()}"
                         logging.error(error_msg)
-                        return None, None, error_msg
+                        return create_error_plot(error_msg), error_msg
                 
-                simple_predict_btn.click(
-                    fn=run_simplified_prediction,
-                    inputs=[simple_pred_month, simple_pred_oni, simple_enable_animation],
-                    outputs=[simple_route_animation, simple_intensity_comparison, simple_prediction_summary]
+                generate_genesis_btn.click(
+                    fn=run_genesis_prediction,
+                    inputs=[genesis_month, genesis_oni, enable_genesis_animation],
+                    outputs=[genesis_animation, genesis_summary]
                 )
 
             with gr.Tab("🔬 Advanced ML Clustering"):