Update app.py

app.py

@@ -107,8 +107,9 @@ class TyphoonAnalyzer:
                 raise
 
         print("All required data files are ready")
-        
+
     def load_initial_data(self):
+        """Initialize all required data"""
         print("Loading initial data...")
         self.update_oni_data()
         self.oni_df = self.fetch_oni_data_from_csv()
@@ -120,261 +121,102 @@ class TyphoonAnalyzer:
         self.merged_data = self.merge_data()
         print("Initial data loading complete")
 
-    def fetch_oni_data_from_csv(self):
-       """Load ONI data from CSV"""
-       df = pd.read_csv(ONI_DATA_PATH)
-       df = df.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
-       
-       # Convert month numbers to month names
-       month_map = {
-           '01': 'Jan', '02': 'Feb', '03': 'Mar', '04': 'Apr',
-           '05': 'May', '06': 'Jun', '07': 'Jul', '08': 'Aug',
-           '09': 'Sep', '10': 'Oct', '11': 'Nov', '12': 'Dec'
-       }
-       df['Month'] = df['Month'].map(month_map)
-       
-       # Now create the date
-       df['Date'] = pd.to_datetime(df['Year'].astype(str) + df['Month'], format='%Y%b')
-       return df.set_index('Date')
-
-    def should_update_oni(self):
-        today = datetime.now()
-        return (today.day == 1 or today.day == 15 or 
-                today.day == (today.replace(day=1, month=today.month%12+1) - timedelta(days=1)).day)
     def convert_typhoondata(self, input_file, output_file):
-       """Convert IBTrACS data to processed format"""
-       print(f"Converting typhoon data from {input_file} to {output_file}")
-       with open(input_file, 'r') as infile:
-           # Skip the header lines
-           next(infile)
-           next(infile)
-           
-           reader = csv.reader(infile)
-           sid_data = defaultdict(list)
-           
-           for row in reader:
-               if not row:  # Skip blank lines
-                   continue
-               
-               sid = row[0]
-               iso_time = row[6]
-               sid_data[sid].append((row, iso_time))
-
-       with open(output_file, 'w', newline='') as outfile:
-           fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 
-                        'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 
-                        'START_DATE', 'END_DATE']
-           writer = csv.DictWriter(outfile, fieldnames=fieldnames)
-           writer.writeheader()
-           
-           for sid, data in sid_data.items():
-               start_date = min(data, key=lambda x: x[1])[1]
-               end_date = max(data, key=lambda x: x[1])[1]
-               
-               for row, iso_time in data:
-                   writer.writerow({
-                       'SID': row[0],
-                       'ISO_TIME': iso_time,
-                       'LAT': row[8],
-                       'LON': row[9],
-                       'SEASON': row[1],
-                       'NAME': row[5],
-                       'WMO_WIND': row[10].strip() or ' ',
-                       'WMO_PRES': row[11].strip() or ' ',
-                       'USA_WIND': row[23].strip() or ' ',
-                       'USA_PRES': row[24].strip() or ' ',
-                       'START_DATE': start_date,
-                       'END_DATE': end_date
-                   })
-    def update_oni_data(self):
-        if not self.should_update_oni():
-            return
-
-        url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
-        temp_file = os.path.join(DATA_PATH, "temp_oni.ascii.txt")
-        
-        try:
-            response = requests.get(url)
-            response.raise_for_status()
-            with open(temp_file, 'wb') as f:
-                f.write(response.content)
-            self.convert_oni_ascii_to_csv(temp_file, ONI_DATA_PATH)
-            self.last_oni_update = date.today()
-        except Exception as e:
-            print(f"Error updating ONI data: {e}")
-        finally:
-            if os.path.exists(temp_file):
-                os.remove(temp_file)
-    def create_wind_analysis(self, data):
-        """Create wind speed analysis plot"""
-        fig = px.scatter(data,
-            x='ONI',
-            y='USA_WIND',
-            color='Category',
-            color_discrete_map=COLOR_MAP,
-            title='Wind Speed vs ONI Index',
-            labels={
-                'ONI': 'Oceanic Niño Index',
-                'USA_WIND': 'Maximum Wind Speed (kt)'
-            },
-            hover_data=['NAME', 'ISO_TIME', 'Category']
-        )
-        
-        # Add regression line
-        x = data['ONI']
-        y = data['USA_WIND']
-        slope, intercept = np.polyfit(x, y, 1)
-        fig.add_trace(
-            go.Scatter(
-                x=x,
-                y=slope * x + intercept,
-                mode='lines',
-                name=f'Regression (slope={slope:.2f})',
-                line=dict(color='black', dash='dash')
-            )
-        )
-        
-        return fig
-    def create_typhoon_animation(self, year, typhoon_id):
-        """Create animated visualization of typhoon path"""
-        # Create default empty figure
-        empty_fig = go.Figure()
-        empty_fig.update_layout(
-            title="No Data Available",
-            showlegend=False,
-            geo=dict(
-                projection_type='mercator',
-                showland=True,
-                showcoastlines=True,
-                landcolor='rgb(243, 243, 243)',
-                countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
-                showocean=True,
-                oceancolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140)
-            )
-        )
-
-        # Input validation
-        if not typhoon_id:
-            return empty_fig, "Please select a typhoon"
+        """Convert IBTrACS data to processed format"""
+        print(f"Converting typhoon data from {input_file} to {output_file}")
+        with open(input_file, 'r') as infile:
+            # Skip the header lines
+            next(infile)
+            next(infile)
+            
+            reader = csv.reader(infile)
+            sid_data = defaultdict(list)
             
-        # Get storm data
-        storm_data = self.typhoon_data[self.typhoon_data['SID'] == typhoon_id]
-        if storm_data.empty:
-            return empty_fig, "No data available for selected typhoon"
+            for row in reader:
+                if not row:  # Skip blank lines
+                    continue
+                
+                sid = row[0]
+                iso_time = row[6]
+                sid_data[sid].append((row, iso_time))
+
+        with open(output_file, 'w', newline='') as outfile:
+            fieldnames = ['SID', 'ISO_TIME', 'LAT', 'LON', 'SEASON', 'NAME', 
+                         'WMO_WIND', 'WMO_PRES', 'USA_WIND', 'USA_PRES', 
+                         'START_DATE', 'END_DATE']
+            writer = csv.DictWriter(outfile, fieldnames=fieldnames)
+            writer.writeheader()
             
-        storm_data = storm_data.sort_values('ISO_TIME')
-        storm_name = storm_data['NAME'].iloc[0] if not storm_data.empty else "Unknown"
+            for sid, data in sid_data.items():
+                start_date = min(data, key=lambda x: x[1])[1]
+                end_date = max(data, key=lambda x: x[1])[1]
+                
+                for row, iso_time in data:
+                    writer.writerow({
+                        'SID': row[0],
+                        'ISO_TIME': iso_time,
+                        'LAT': row[8],
+                        'LON': row[9],
+                        'SEASON': row[1],
+                        'NAME': row[5],
+                        'WMO_WIND': row[10].strip() or ' ',
+                        'WMO_PRES': row[11].strip() or ' ',
+                        'USA_WIND': row[23].strip() or ' ',
+                        'USA_PRES': row[24].strip() or ' ',
+                        'START_DATE': start_date,
+                        'END_DATE': end_date
+                    })
+
+    def fetch_oni_data_from_csv(self):
+        """Load ONI data from CSV"""
+        df = pd.read_csv(ONI_DATA_PATH)
+        df = df.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
         
-        fig = go.Figure()
+        # Convert month numbers to month names
+        month_map = {
+            '01': 'Jan', '02': 'Feb', '03': 'Mar', '04': 'Apr',
+            '05': 'May', '06': 'Jun', '07': 'Jul', '08': 'Aug',
+            '09': 'Sep', '10': 'Oct', '11': 'Nov', '12': 'Dec'
+        }
+        df['Month'] = df['Month'].map(month_map)
         
-        # Base map settings
-        fig.update_layout(
-            title=f"Typhoon Path Animation - {storm_name}",
-            showlegend=True,
-            geo=dict(
-                projection_type='mercator',
-                showland=True,
-                showcoastlines=True,
-                landcolor='rgb(243, 243, 243)',
-                countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
-                showocean=True,
-                oceancolor='rgb(230, 250, 255)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140)
-            )
-        )
-
-        # Create animation frames
-        frames = []
-        for i in range(len(storm_data)):
-            frame = go.Frame(
-                data=[
-                    go.Scattergeo(
-                        lon=storm_data['LON'].iloc[:i+1],
-                        lat=storm_data['LAT'].iloc[:i+1],
-                        mode='lines+markers',
-                        line=dict(width=2, color='red'),
-                        marker=dict(size=8, color='red'),
-                        name='Path',
-                        hovertemplate=(
-                            f"Time: {storm_data['ISO_TIME'].iloc[i]:%Y-%m-%d %H:%M}<br>" +
-                            f"Wind: {storm_data['USA_WIND'].iloc[i]:.1f} kt<br>" +
-                            f"Pressure: {storm_data['WMO_PRES'].iloc[i]:.1f} hPa<br>" +
-                            f"Lat: {storm_data['LAT'].iloc[i]:.2f}°N<br>" +
-                            f"Lon: {storm_data['LON'].iloc[i]:.2f}°E"
-                        )
-                    )
-                ],
-                name=f'frame{i}'
-            )
-            frames.append(frame)
+        # Now create the date
+        df['Date'] = pd.to_datetime(df['Year'].astype(str) + df['Month'], format='%Y%b')
+        return df.set_index('Date')
 
-        fig.frames = frames
-
-        # Add animation controls
-        fig.update_layout(
-            updatemenus=[{
-                'buttons': [
-                    {
-                        'args': [None, {'frame': {'duration': 100, 'redraw': True},
-                                      'fromcurrent': True}],
-                        'label': 'Play',
-                        'method': 'animate'
-                    },
-                    {
-                        'args': [[None], {'frame': {'duration': 0, 'redraw': True},
-                                        'mode': 'immediate',
-                                        'transition': {'duration': 0}}],
-                        'label': 'Pause',
-                        'method': 'animate'
-                    }
-                ],
-                'type': 'buttons',
-                'showactive': False,
-                'x': 0.1,
-                'y': 0,
-                'xanchor': 'right',
-                'yanchor': 'top'
-            }]
-        )
-
-        # Add initial data
-        fig.add_trace(
-            go.Scattergeo(
-                lon=[storm_data['LON'].iloc[0]],
-                lat=[storm_data['LAT'].iloc[0]],
-                mode='markers',
-                marker=dict(size=8, color='red'),
-                name='Start Point',
-                showlegend=True
-            )
-        )
+    def update_oni_data(self):
+        """Update ONI data from NOAA"""
+        if not self._should_update_oni():
+            return
+        
+        url = "https://www.cpc.ncep.noaa.gov/data/indices/oni.ascii.txt"
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            try:
+                response = requests.get(url)
+                response.raise_for_status()
+                temp_file.write(response.content)
+                self.convert_oni_ascii_to_csv(temp_file.name, ONI_DATA_PATH)
+                self.last_oni_update = date.today()
+            except Exception as e:
+                print(f"Error updating ONI data: {e}")
+            finally:
+                if os.path.exists(temp_file.name):
+                    os.remove(temp_file.name)
 
-        info_text = f"""
-        ### Typhoon Information
-        - Name: {storm_name}
-        - Start Date: {storm_data['ISO_TIME'].iloc[0]:%Y-%m-%d %H:%M}
-        - End Date: {storm_data['ISO_TIME'].iloc[-1]:%Y-%m-%d %H:%M}
-        - Maximum Wind Speed: {storm_data['USA_WIND'].max():.1f} kt
-        - Minimum Pressure: {storm_data['WMO_PRES'].min():.1f} hPa
-        - Duration: {(storm_data['ISO_TIME'].iloc[-1] - storm_data['ISO_TIME'].iloc[0]).total_seconds() / 3600:.1f} hours
-        """
+    def _should_update_oni(self):
+        """Check if ONI data should be updated"""
+        today = datetime.now()
+        return (today.day in [1, 15] or 
+                today.day == (today.replace(day=1, month=today.month%12+1) - timedelta(days=1)).day)
 
-        return fig, info_text
-    
     def convert_oni_ascii_to_csv(self, input_file, output_file):
+        """Convert ONI ASCII data to CSV format"""
         data = defaultdict(lambda: [''] * 12)
         season_to_month = {
             'DJF': 12, 'JFM': 1, 'FMA': 2, 'MAM': 3, 'AMJ': 4, 'MJJ': 5,
             'JJA': 6, 'JAS': 7, 'ASO': 8, 'SON': 9, 'OND': 10, 'NDJ': 11
         }
-
+        
         with open(input_file, 'r') as f:
             next(f)  # Skip header
             for line in f:
@@ -394,6 +236,7 @@ class TyphoonAnalyzer:
                 writer.writerow([year] + data[year])
 
     def load_ibtracs_data(self):
+        """Load IBTrACS data with caching"""
         if os.path.exists(CACHE_FILE):
             cache_time = datetime.fromtimestamp(os.path.getmtime(CACHE_FILE))
             if datetime.now() - cache_time < timedelta(days=CACHE_EXPIRY_DAYS):
@@ -402,24 +245,25 @@ class TyphoonAnalyzer:
 
         if os.path.exists(LOCAL_iBtrace_PATH):
             ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs', 
-                                        ibtracs_url=LOCAL_iBtrace_PATH)
+                                         ibtracs_url=LOCAL_iBtrace_PATH)
         else:
             response = requests.get(iBtrace_uri)
             response.raise_for_status()
             with open(LOCAL_iBtrace_PATH, 'w') as f:
                 f.write(response.text)
             ibtracs = tracks.TrackDataset(basin='west_pacific', source='ibtracs',
-                                        ibtracs_url=LOCAL_iBtrace_PATH)
+                                         ibtracs_url=LOCAL_iBtrace_PATH)
 
         with open(CACHE_FILE, 'wb') as f:
             pickle.dump(ibtracs, f)
         return ibtracs
 
     def update_typhoon_data(self):
+        """Update typhoon data from IBTrACS"""
         try:
             response = requests.head(iBtrace_uri)
             remote_modified = datetime.strptime(response.headers['Last-Modified'], 
-                                              '%a, %d %b %Y %H:%M:%S GMT')
+                                               '%a, %d %b %Y %H:%M:%S GMT')
             local_modified = (datetime.fromtimestamp(os.path.getmtime(LOCAL_iBtrace_PATH)) 
                             if os.path.exists(LOCAL_iBtrace_PATH) else datetime.min)
             
@@ -428,10 +272,12 @@ class TyphoonAnalyzer:
                 response.raise_for_status()
                 with open(LOCAL_iBtrace_PATH, 'w') as f:
                     f.write(response.text)
+                print("Typhoon data updated successfully")
         except Exception as e:
             print(f"Error updating typhoon data: {e}")
 
     def load_data(self):
+        """Load ONI and typhoon data"""
         oni_data = pd.read_csv(ONI_DATA_PATH)
         typhoon_data = pd.read_csv(TYPHOON_DATA_PATH, low_memory=False)
         typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'])
@@ -439,7 +285,7 @@ class TyphoonAnalyzer:
 
     def process_oni_data(self, oni_data):
         """Process ONI data"""
-        oni_long = pd.melt(oni_data, id_vars=['Year'], var_name='Month', value_name='ONI')
+        oni_long = oni_data.melt(id_vars=['Year'], var_name='Month', value_name='ONI')
         
         # Create a mapping for month numbers
         month_map = {
@@ -454,6 +300,7 @@ class TyphoonAnalyzer:
         return oni_long
 
     def process_typhoon_data(self, typhoon_data):
+        """Process typhoon data"""
         typhoon_data['USA_WIND'] = pd.to_numeric(typhoon_data['USA_WIND'], errors='coerce')
         typhoon_data['WMO_PRES'] = pd.to_numeric(typhoon_data['WMO_PRES'], errors='coerce')
         typhoon_data['ISO_TIME'] = pd.to_datetime(typhoon_data['ISO_TIME'])
@@ -473,9 +320,13 @@ class TyphoonAnalyzer:
         return typhoon_max
 
     def merge_data(self):
+        """Merge ONI and typhoon data"""
         return pd.merge(self.typhoon_max, self.oni_long, on=['Year', 'Month'])
 
     def categorize_typhoon(self, wind_speed):
+        """Categorize typhoon based on wind speed"""
+        if np.isnan(wind_speed):
+            return 'Unknown'
         if wind_speed >= 137:
             return 'C5 Super Typhoon'
         elif wind_speed >= 113:
@@ -492,6 +343,7 @@ class TyphoonAnalyzer:
             return 'Tropical Depression'
 
     def analyze_typhoon(self, start_year, start_month, end_year, end_month, enso_value='all'):
+        """Main analysis function"""
         start_date = datetime(start_year, start_month, 1)
         end_date = datetime(end_year, end_month, 28)
         
@@ -511,7 +363,6 @@ class TyphoonAnalyzer:
             'tracks': self.create_tracks_plot(filtered_data),
             'wind': self.create_wind_analysis(filtered_data),
             'pressure': self.create_pressure_analysis(filtered_data),
-            'clusters': self.create_cluster_analysis(filtered_data, 5),
             'stats': self.generate_statistics(filtered_data)
         }
 
@@ -586,6 +437,96 @@ class TyphoonAnalyzer:
 
         return fig
 
+    def create_wind_analysis(self, data):
+        """Create wind speed analysis plot"""
+        fig = px.scatter(data,
+            x='ONI',
+            y='USA_WIND',
+            color='Category',
+            color_discrete_map=COLOR_MAP,
+            title='Wind Speed vs ONI Index',
+            labels={
+                'ONI': 'Oceanic Niño Index',
+                'USA_WIND': 'Maximum Wind Speed (kt)'
+            },
+            hover_data=['NAME', 'ISO_TIME', 'Category']
+        )
+        
+        # Add regression line
+        x = data['ONI']
+        y = data['USA_WIND']
+        slope, intercept = np.polyfit(x, y, 1)
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=slope * x + intercept,
+                mode='lines',
+                name=f'Regression (slope={slope:.2f})',
+                line=dict(color='black', dash='dash')
+            )
+        )
+        
+        return fig
+
+    def create_pressure_analysis(self, data):
+        """Create pressure analysis plot"""
+        fig = px.scatter(data,
+            x='ONI',
+            y='WMO_PRES',
+            color='Category',
+            color_discrete_map=COLOR_MAP,
+            title='Pressure vs ONI Index',
+            labels={
+                'ONI': 'Oceanic Niño Index',
+                'WMO_PRES': 'Minimum Pressure (hPa)'
+            },
+            hover_data=['NAME', 'ISO_TIME', 'Category']
+        )
+        
+        # Add regression line
+        x = data['ONI']
+        y = data['WMO_PRES']
+        slope, intercept = np.polyfit(x, y, 1)
+        fig.add_trace(
+            go.Scatter(
+                x=x,
+                y=slope * x + intercept,
+                mode='lines',
+                name=f'Regression (slope={slope:.2f})',
+                line=dict(color='black', dash='dash')
+            )
+        )
+        
+        return fig
+
+    def generate_statistics(self, data):
+        """Generate statistical summary"""
+        stats = {
+            'total_typhoons': len(data['SID'].unique()),
+            'avg_wind': data['USA_WIND'].mean(),
+            'max_wind': data['USA_WIND'].max(),
+            'avg_pressure': data['WMO_PRES'].mean(),
+            'min_pressure': data['WMO_PRES'].min(),
+            'oni_correlation_wind': data['ONI'].corr(data['USA_WIND']),
+            'oni_correlation_pressure': data['ONI'].corr(data['WMO_PRES']),
+            'category_counts': data['Category'].value_counts().to_dict()
+        }
+        
+        return f"""
+### Statistical Summary
+
+- Total Typhoons: {stats['total_typhoons']}
+- Average Wind Speed: {stats['avg_wind']:.2f} kt
+- Maximum Wind Speed: {stats['max_wind']:.2f} kt
+- Average Pressure: {stats['avg_pressure']:.2f} hPa
+- Minimum Pressure: {stats['min_pressure']:.2f} hPa
+- ONI-Wind Speed Correlation: {stats['oni_correlation_wind']:.3f}
+- ONI-Pressure Correlation: {stats['oni_correlation_pressure']:.3f}
+
+### Category Distribution
+{chr(10).join(f'- {cat}: {count}' for cat, count in stats['category_counts'].items())}
+"""
+
     def analyze_clusters(self, year, n_clusters):
         """Analyze typhoon clusters for a specific year"""
         year_data = self.typhoon_data[self.typhoon_data['SEASON'] == year]
@@ -669,369 +610,321 @@ class TyphoonAnalyzer:
             stats_text += f"- Cluster {i+1}: {cluster_counts[i]} typhoons\n"
         
         return fig, stats_text
+
     def get_typhoons_for_year(self, year):
         """Get list of typhoons for a specific year"""
-        year_data = self.typhoon_data[self.typhoon_data['ISO_TIME'].dt.year == year]
-        typhoons = year_data.groupby('SID').first()
-        return [{'label': f"{row['NAME']} ({row.name})", 'value': row.name} 
-                for _, row in typhoons.iterrows()]
+        try:
+            season = self.ibtracs.get_season(year)
+            storm_summary = season.summary()
+            
+            typhoon_options = []
+            for i in range(storm_summary['season_storms']):
+                storm_id = storm_summary['id'][i]
+                storm_name = storm_summary['name'][i]
+                typhoon_options.append({'label': f"{storm_name} ({storm_id})", 'value': storm_id})
+            
+            return typhoon_options
+        except Exception as e:
+            print(f"Error getting typhoons for year {year}: {str(e)}")
+            return []
 
-    def create_typhoon_animation(self, year, typhoon_id):
+    def create_typhoon_animation(self, year, storm_id, standard='atlantic'):
         """Create animated visualization of typhoon path"""
-        # Create default empty figure
-        empty_fig = go.Figure()
-        empty_fig.update_layout(
-            title="No Data Available",
-            showlegend=False,
+        if not storm_id:
+            return go.Figure(), "Please select a typhoon"
+            
+        storm = self.ibtracs.get_storm(storm_id)
+        
+        fig = go.Figure()
+
+        # Base map setup with correct scaling
+        fig.update_layout(
+            title=f"{year} - {storm.name} Typhoon Path",
             geo=dict(
-                projection_type='mercator',
+                projection_type='natural earth',
                 showland=True,
-                showcoastlines=True,
                 landcolor='rgb(243, 243, 243)',
                 countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
+                coastlinecolor='rgb(100, 100, 100)',
                 showocean=True,
                 oceancolor='rgb(230, 250, 255)',
                 lataxis=dict(range=[0, 50]),
                 lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140)
-            )
+                center=dict(lat=20, lon=140),
+            ),
+            updatemenus=[{
+                "buttons": [
+                    {
+                        "args": [None, {"frame": {"duration": 100, "redraw": True},
+                                        "fromcurrent": True,
+                                        "transition": {"duration": 0}}],
+                        "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"
+            }]
         )
 
-        # Input validation
-        if not typhoon_id:
-            return empty_fig, "Please select a typhoon"
+        # Create animation frames
+        frames = []
+        for i in range(len(storm.time)):
+            category, color = self.categorize_typhoon_by_standard(storm.vmax[i], standard)
             
-        # Get storm data
-        try:
-            storm_data = self.typhoon_data[self.typhoon_data['SID'] == typhoon_id]
-            if len(storm_data) == 0:
-                return empty_fig, "No data available for selected typhoon"
+            # Get extra radius data if available
+            radius_info = ""
+            if hasattr(storm, 'dict'):
+                r34_ne = storm.dict.get('USA_R34_NE', [None])[i] if 'USA_R34_NE' in storm.dict else None
+                r34_se = storm.dict.get('USA_R34_SE', [None])[i] if 'USA_R34_SE' in storm.dict else None
+                r34_sw = storm.dict.get('USA_R34_SW', [None])[i] if 'USA_R34_SW' in storm.dict else None
+                r34_nw = storm.dict.get('USA_R34_NW', [None])[i] if 'USA_R34_NW' in storm.dict else None
+                rmw = storm.dict.get('USA_RMW', [None])[i] if 'USA_RMW' in storm.dict else None
+                eye = storm.dict.get('USA_EYE', [None])[i] if 'USA_EYE' in storm.dict else None
                 
-            storm_data = storm_data.sort_values('ISO_TIME')
-            
-            # Get the name safely
-            storm_name = storm_data['NAME'].values[0] if len(storm_data) > 0 else "Unknown"
-            
-            fig = go.Figure()
+                if any([r34_ne, r34_se, r34_sw, r34_nw, rmw, eye]):
+                    radius_info = f"<br>R34: NE={r34_ne}, SE={r34_se}, SW={r34_sw}, NW={r34_nw}<br>"
+                    radius_info += f"RMW: {rmw}<br>Eye Diameter: {eye}"
             
-            # Base map settings
-            fig.update_layout(
-                title=f"Typhoon Path Animation - {storm_name}",
-                showlegend=True,
-                geo=dict(
-                    projection_type='mercator',
-                    showland=True,
-                    showcoastlines=True,
-                    landcolor='rgb(243, 243, 243)',
-                    countrycolor='rgb(204, 204, 204)',
-                    coastlinecolor='rgb(214, 214, 214)',
-                    showocean=True,
-                    oceancolor='rgb(230, 250, 255)',
-                    lataxis=dict(range=[0, 50]),
-                    lonaxis=dict(range=[100, 180]),
-                    center=dict(lat=20, lon=140)
-                )
-            )
-
-            # Create animation frames
-            frames = []
-            for i in range(len(storm_data)):
-                frame = go.Frame(
-                    data=[
-                        go.Scattergeo(
-                            lon=storm_data['LON'].values[:i+1],
-                            lat=storm_data['LAT'].values[:i+1],
-                            mode='lines+markers',
-                            line=dict(width=2, color='red'),
-                            marker=dict(size=8, color='red'),
-                            name='Path',
-                            hovertemplate=(
-                                f"Time: {pd.to_datetime(storm_data['ISO_TIME'].values[i]).strftime('%Y-%m-%d %H:%M')}<br>" +
-                                f"Wind: {storm_data['USA_WIND'].values[i]:.1f} kt<br>" +
-                                f"Pressure: {storm_data['WMO_PRES'].values[i]:.1f} hPa<br>" +
-                                f"Lat: {storm_data['LAT'].values[i]:.2f}°N<br>" +
-                                f"Lon: {storm_data['LON'].values[i]:.2f}°E"
-                            )
-                        )
-                    ],
-                    name=f'frame{i}'
-                )
-                frames.append(frame)
-
-            fig.frames = frames
-
-            # Add animation controls
-            fig.update_layout(
-                updatemenus=[{
-                    'buttons': [
-                        {
-                            'args': [None, {'frame': {'duration': 100, 'redraw': True},
-                                          'fromcurrent': True}],
-                            'label': 'Play',
-                            'method': 'animate'
-                        },
-                        {
-                            'args': [[None], {'frame': {'duration': 0, 'redraw': True},
-                                            'mode': 'immediate',
-                                            'transition': {'duration': 0}}],
-                            'label': 'Pause',
-                            'method': 'animate'
-                        }
-                    ],
-                    'type': 'buttons',
-                    'showactive': False,
-                    'x': 0.1,
-                    'y': 0,
-                    'xanchor': 'right',
-                    'yanchor': 'top'
-                }]
-            )
-
-            # Add initial data
-            fig.add_trace(
-                go.Scattergeo(
-                    lon=[storm_data['LON'].values[0]],
-                    lat=[storm_data['LAT'].values[0]],
-                    mode='markers',
-                    marker=dict(size=8, color='red'),
-                    name='Start Point',
-                    showlegend=True
-                )
+            frame = go.Frame(
+                data=[
+                    go.Scattergeo(
+                        lon=storm.lon[:i+1],
+                        lat=storm.lat[:i+1],
+                        mode='lines',
+                        line=dict(width=2, color='blue'),
+                        name='Path Traveled',
+                        showlegend=False,
+                    ),
+                    go.Scattergeo(
+                        lon=[storm.lon[i]],
+                        lat=[storm.lat[i]],
+                        mode='markers+text',
+                        marker=dict(size=10, color=color, symbol='star'),
+                        text=category,
+                        textposition="top center",
+                        textfont=dict(size=12, color=color),
+                        name='Current Location',
+                        hovertemplate=(
+                            f"{storm.time[i].strftime('%Y-%m-%d %H:%M')}<br>"
+                            f"Category: {category}<br>"
+                            f"Wind Speed: {storm.vmax[i]:.1f} kt<br>"
+                            f"{radius_info}"
+                        ),
+                    ),
+                ],name=f"frame{i}"
             )
+            frames.append(frame)
 
-            start_time = pd.to_datetime(storm_data['ISO_TIME'].values[0])
-            end_time = pd.to_datetime(storm_data['ISO_TIME'].values[-1])
-            duration = (end_time - start_time).total_seconds() / 3600
-
-            info_text = f"""
-            ### Typhoon Information
-            - Name: {storm_name}
-            - Start Date: {start_time.strftime('%Y-%m-%d %H:%M')}
-            - End Date: {end_time.strftime('%Y-%m-%d %H:%M')}
-            - Maximum Wind Speed: {storm_data['USA_WIND'].max():.1f} kt
-            - Minimum Pressure: {storm_data['WMO_PRES'].min():.1f} hPa
-            - Duration: {duration:.1f} hours
-            """
-
-            return fig, info_text
-            
-        except Exception as e:
-            print(f"Error in create_typhoon_animation: {str(e)}")
-            return empty_fig, f"Error processing typhoon data: {str(e)}"
-
-        return fig, info_text
-    def create_pressure_analysis(self, data):
-        fig = px.scatter(data,
-            x='ONI',
-            y='WMO_PRES',
-            color='Category',
-            color_discrete_map=COLOR_MAP,
-            title='Pressure vs ONI Index',
-            labels={
-                'ONI': 'Oceanic Niño Index',
-                'WMO_PRES': 'Minimum Pressure (hPa)'
-            },
-            hover_data=['NAME', 'ISO_TIME']
-        )
+        fig.frames = frames
         
-        # Add regression line
-        x = data['ONI']
-        y = data['WMO_PRES']
-        slope, intercept = np.polyfit(x, y, 1)
+        # Add initial track and starting point
         fig.add_trace(
-            go.Scatter(
-                x=x,
-                y=slope * x + intercept,
+            go.Scattergeo(
+                lon=storm.lon,
+                lat=storm.lat,
                 mode='lines',
-                name=f'Regression (slope={slope:.2f})',
-                line=dict(color='black', dash='dash')
+                line=dict(width=2, color='gray'),
+                name='Complete Path',
+                showlegend=True,
             )
         )
-        
-        return fig
 
-    def create_cluster_analysis(self, data, n_clusters=5):
-        # Prepare data for clustering
-        routes = []
-        for _, storm in data.groupby('SID'):
-            if len(storm) > 1:
-                # Standardize route length
-                t = np.linspace(0, 1, len(storm))
-                t_new = np.linspace(0, 1, 100)
-                lon_interp = interp1d(t, storm['LON'], kind='linear')(t_new)
-                lat_interp = interp1d(t, storm['LAT'], kind='linear')(t_new)
-                routes.append(np.column_stack((lon_interp, lat_interp)))
-        
-        if not routes:
-            return go.Figure()
-
-        # Perform clustering
-        routes_array = np.array(routes)
-        routes_reshaped = routes_array.reshape(routes_array.shape[0], -1)
-        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
-        clusters = kmeans.fit_predict(routes_reshaped)
+        fig.add_trace(
+            go.Scattergeo(
+                lon=[storm.lon[0]],
+                lat=[storm.lat[0]],
+                mode='markers',
+                marker=dict(size=10, color='green', symbol='star'),
+                name='Starting Point',
+                text=storm.time[0].strftime('%Y-%m-%d %H:%M'),
+                hoverinfo='text+name',
+            )
+        )
 
-        # Create visualization
-        fig = go.Figure()
+        # Add slider for frame selection
+        sliders = [{
+            "active": 0,
+            "yanchor": "top",
+            "xanchor": "left",
+            "currentvalue": {
+                "font": {"size": 20},
+                "prefix": "Time: ",
+                "visible": True,
+                "xanchor": "right"
+            },
+            "transition": {"duration": 100, "easing": "cubic-in-out"},
+            "pad": {"b": 10, "t": 50},
+            "len": 0.9,
+            "x": 0.1,
+            "y": 0,
+            "steps": [
+                {
+                    "args": [[f"frame{k}"],
+                            {"frame": {"duration": 100, "redraw": True},
+                            "mode": "immediate",
+                            "transition": {"duration": 0}}
+                            ],
+                    "label": storm.time[k].strftime('%Y-%m-%d %H:%M'),
+                    "method": "animate"
+                }
+                for k in range(len(storm.time))
+            ]
+        }]
         
-        # Plot original routes colored by cluster
-        for route, cluster_id in zip(routes, clusters):
-            fig.add_trace(go.Scattergeo(
-                lon=route[:, 0],
-                lat=route[:, 1],
-                mode='lines',
-                line=dict(width=1, color=f'hsl({cluster_id * 360/n_clusters}, 50%, 50%)'),
-                showlegend=False
-            ))
+        fig.update_layout(sliders=sliders)
 
-        # Plot cluster centers
-        for i in range(n_clusters):
-            center = kmeans.cluster_centers_[i].reshape(-1, 2)
-            fig.add_trace(go.Scattergeo(
-                lon=center[:, 0],
-                lat=center[:, 1],
-                mode='lines',
-                name=f'Cluster {i+1} Center',
-                line=dict(width=3, color=f'hsl({i * 360/n_clusters}, 100%, 50%)')
-            ))
+        info_text = f"""
+        ### Typhoon Information
+        - **Name:** {storm.name}
+        - **Start Date:** {storm.time[0].strftime('%Y-%m-%d %H:%M')}
+        - **End Date:** {storm.time[-1].strftime('%Y-%m-%d %H:%M')}
+        - **Duration:** {(storm.time[-1] - storm.time[0]).total_seconds() / 3600:.1f} hours
+        - **Maximum Wind Speed:** {max(storm.vmax):.1f} kt
+        - **Minimum Pressure:** {min(storm.mslp):.1f} hPa
+        - **Peak Category:** {self.categorize_typhoon_by_standard(max(storm.vmax), standard)[0]}
+        """
 
-        fig.update_layout(
-            title='Typhoon Route Clusters',
-            showlegend=True,
-            geo=dict(
-                projection_type='mercator',
-                showland=True,
-                showcoastlines=True,
-                landcolor='rgb(243, 243, 243)',
-                countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
-                lataxis=dict(range=[0, 50]),
-                lonaxis=dict(range=[100, 180]),
-            )
-        )
-        
-        return fig
-    def get_typhoons_for_year(self, year):
-        """Get list of typhoons for a specific year"""
-        year_data = self.typhoon_data[self.typhoon_data['SEASON'] == year]
-        unique_typhoons = year_data.groupby('SID').first().reset_index()
-        return [
-            {'label': f"{row['NAME']} ({row['ISO_TIME'].strftime('%Y-%m-%d')})", 
-             'value': row['SID']} 
-            for _, row in unique_typhoons.iterrows()
-        ]
+        return fig, info_text
 
-    def search_typhoon_details(self, year, typhoon_id):
-        """Get detailed information for a specific typhoon"""
-        if not typhoon_id:
-            return None, "Please select a typhoon"
-            
-        storm_data = self.typhoon_data[self.typhoon_data['SID'] == typhoon_id]
-        storm_data = storm_data.sort_values('ISO_TIME')
+    def search_typhoons(self, query):
+        """Search for typhoons by name"""
+        if not query:
+            return go.Figure(), "Please enter a typhoon name to search"
         
-        # Create track plot
-        fig = self.create_single_typhoon_plot(storm_data)
+        # Find all typhoons matching the query
+        matching_storms = []
         
-        # Create detailed information text
-        info = self.create_typhoon_info_text(storm_data)
+        # Limit search to last 30 years to improve performance
+        current_year = datetime.now().year
+        start_year = current_year - 30
         
-        return fig, info
-
-    def create_single_typhoon_plot(self, storm_data):
-        """Create a detailed plot for a single typhoon"""
+        for year in range(start_year, current_year + 1):
+            try:
+                season = self.ibtracs.get_season(year)
+                for storm_id in season.summary()['id']:
+                    storm = self.ibtracs.get_storm(storm_id)
+                    if query.lower() in storm.name.lower():
+                        matching_storms.append((year, storm))
+            except Exception as e:
+                print(f"Error searching year {year}: {str(e)}")
+                continue
+        
+        if not matching_storms:
+            return go.Figure(), "No typhoons found matching your search"
+        
+        # Create visualization of all matching typhoons
         fig = go.Figure()
         
         fig.update_layout(
-            title=f"Typhoon Track - {storm_data['NAME'].iloc[0]} ({storm_data['SEASON'].iloc[0]})",
-            showlegend=True,
+            title=f"Typhoons Matching: '{query}'",
             geo=dict(
-                projection_type='mercator',
+                projection_type='natural earth',
                 showland=True,
-                showcoastlines=True,
                 landcolor='rgb(243, 243, 243)',
                 countrycolor='rgb(204, 204, 204)',
-                coastlinecolor='rgb(214, 214, 214)',
+                coastlinecolor='rgb(100, 100, 100)',
                 showocean=True,
                 oceancolor='rgb(230, 250, 255)',
                 lataxis=dict(range=[0, 50]),
                 lonaxis=dict(range=[100, 180]),
-                center=dict(lat=20, lon=140)
+                center=dict(lat=20, lon=140),
             )
         )
         
-        # Add main track
-        fig.add_trace(go.Scattergeo(
-            lon=storm_data['LON'],
-            lat=storm_data['LAT'],
-            mode='lines+markers',
-            line=dict(width=2, color='red'),
-            marker=dict(
-                size=8,
-                color=storm_data['USA_WIND'],
-                colorscale='Viridis',
-                showscale=True,
-                colorbar=dict(title='Wind Speed (kt)')
-            ),
-            text=[f"Time: {time:%Y-%m-%d %H:%M}<br>Wind: {wind:.1f} kt<br>Pressure: {pres:.1f} hPa"
-                  for time, wind, pres in zip(storm_data['ISO_TIME'], 
-                                            storm_data['USA_WIND'],
-                                            storm_data['WMO_PRES'])],
-            hoverinfo='text'
-        ))
+        # Plot each matching storm with a different color
+        colors = px.colors.qualitative.Plotly
         
-        return fig
-
-    def create_typhoon_info_text(self, storm_data):
-        """Create detailed information text for a typhoon"""
-        max_wind = storm_data['USA_WIND'].max()
-        min_pressure = storm_data['WMO_PRES'].min()
-        duration = (storm_data['ISO_TIME'].max() - storm_data['ISO_TIME'].min()).total_seconds() / 3600  # hours
-        
-        return f"""
-        ### Typhoon Details: {storm_data['NAME'].iloc[0]}
+        for i, (year, storm) in enumerate(matching_storms):
+            color = colors[i % len(colors)]
+            
+            fig.add_trace(go.Scattergeo(
+                lon=storm.lon,
+                lat=storm.lat,
+                mode='lines',
+                line=dict(width=3, color=color),
+                name=f"{storm.name} ({year})",
+                hovertemplate=(
+                    f"Name: {storm.name}<br>"
+                    f"Year: {year}<br>"
+                    f"Max Wind: {max(storm.vmax):.1f} kt<br>"
+                    f"Min Pressure: {min(storm.mslp):.1f} hPa<br>"
+                    f"Position: %{lat:.2f}°N, %{lon:.2f}°E"
+                )
+            ))
         
-        **Timing Information:**
-        - Start: {storm_data['ISO_TIME'].min():%Y-%m-%d %H:%M}
-        - End: {storm_data['ISO_TIME'].max():%Y-%m-%d %H:%M}
-        - Duration: {duration:.1f} hours
+        # Add starting points
+        for i, (year, storm) in enumerate(matching_storms):
+            color = colors[i % len(colors)]
+            
+            fig.add_trace(go.Scattergeo(
+                lon=[storm.lon[0]],
+                lat=[storm.lat[0]],
+                mode='markers',
+                marker=dict(size=10, color=color, symbol='circle'),
+                name=f"Start: {storm.name} ({year})",
+                showlegend=False,
+                hoverinfo='name'
+            ))
         
-        **Intensity Metrics:**
-        - Maximum Wind Speed: {max_wind:.1f} kt
-        - Minimum Pressure: {min_pressure:.1f} hPa
-        - Maximum Category: {self.categorize_typhoon(max_wind)}
+        # Create information text
+        info_text = f"### Found {len(matching_storms)} typhoons matching '{query}':\n\n"
         
-        **Track Information:**
-        - Starting Position: {storm_data['LAT'].iloc[0]:.1f}°N, {storm_data['LON'].iloc[0]:.1f}°E
-        - Ending Position: {storm_data['LAT'].iloc[-1]:.1f}°N, {storm_data['LON'].iloc[-1]:.1f}°E
-        - Total Track Points: {len(storm_data)}
-        """
-    def generate_statistics(self, data):
-        stats = {
-            'total_typhoons': len(data['SID'].unique()),
-            'avg_wind': data['USA_WIND'].mean(),
-            'max_wind': data['USA_WIND'].max(),
-            'avg_pressure': data['WMO_PRES'].mean(),
-            'min_pressure': data['WMO_PRES'].min(),
-            'oni_correlation_wind': data['ONI'].corr(data['USA_WIND']),
-            'oni_correlation_pressure': data['ONI'].corr(data['WMO_PRES']),
-            'category_counts': data['Category'].value_counts().to_dict()
-        }
+        for year, storm in matching_storms:
+            info_text += f"- **{storm.name} ({year})**\n"
+            info_text += f"  - Time: {storm.time[0].strftime('%Y-%m-%d')} to {storm.time[-1].strftime('%Y-%m-%d')}\n"
+            info_text += f"  - Max Wind: {max(storm.vmax):.1f} kt\n"
+            info_text += f"  - Min Pressure: {min(storm.mslp):.1f} hPa\n"
+            info_text += f"  - Category: {self.categorize_typhoon_by_standard(max(storm.vmax))[0]}\n\n"
         
-        return f"""
-### Statistical Summary
-
-- Total Typhoons: {stats['total_typhoons']}
-- Average Wind Speed: {stats['avg_wind']:.2f} kt
-- Maximum Wind Speed: {stats['max_wind']:.2f} kt
-- Average Pressure: {stats['avg_pressure']:.2f} hPa
-- Minimum Pressure: {stats['min_pressure']:.2f} hPa
-- ONI-Wind Speed Correlation: {stats['oni_correlation_wind']:.3f}
-- ONI-Pressure Correlation: {stats['oni_correlation_pressure']:.3f}
+        return fig, info_text
 
-### Category Distribution
-{chr(10).join(f'- {cat}: {count}' for cat, count in stats['category_counts'].items())}
-"""
+    def categorize_typhoon_by_standard(self, wind_speed, standard='atlantic'):
+        """
+        Categorize typhoon based on wind speed and chosen standard
+        wind_speed is in knots
+        """
+        if standard == 'taiwan':
+            # Convert knots to m/s for Taiwan standard
+            wind_speed_ms = wind_speed * 0.514444
+            
+            if wind_speed_ms >= 51.0:
+                return 'Strong Typhoon', 'rgb(255, 0, 0)'
+            elif wind_speed_ms >= 33.7:
+                return 'Medium Typhoon', 'rgb(255, 127, 0)'
+            elif wind_speed_ms >= 17.2:
+                return 'Mild Typhoon', 'rgb(255, 255, 0)'
+            else:
+                return 'Tropical Depression', 'rgb(173, 216, 230)'
+        else:
+            # Atlantic standard uses knots
+            if wind_speed >= 137:
+                return 'C5 Super Typhoon', 'rgb(255, 0, 0)'
+            elif wind_speed >= 113:
+                return 'C4 Very Strong Typhoon', 'rgb(255, 63, 0)'
+            elif wind_speed >= 96:
+                return 'C3 Strong Typhoon', 'rgb(255, 127, 0)'
+            elif wind_speed >= 83:
+                return 'C2 Typhoon', 'rgb(255, 191, 0)'
+            elif wind_speed >= 64:
+                return 'C1 Typhoon', 'rgb(255, 255, 0)'
+            elif wind_speed >= 34:
+                return 'Tropical Storm', 'rgb(0, 255, 255)'
+            else:
+                return 'Tropical Depression', 'rgb(173, 216, 230)'
 
 def create_interface():
     analyzer = TyphoonAnalyzer()
@@ -1058,31 +951,21 @@ def create_interface():
                 
                 analyze_btn = gr.Button("Analyze")
                 
-                with gr.Row():
-                    tracks_plot = gr.Plot()
-                with gr.Row():
-                    wind_plot = gr.Plot()
-                    pressure_plot = gr.Plot()
+                tracks_plot = gr.Plot(label="Typhoon Tracks")
                 
-                stats_text = gr.Markdown()
-
-            # Clustering Analysis Tab
-            with gr.Tab("Clustering Analysis"):
                 with gr.Row():
-                    cluster_year = gr.Slider(1900, 2024, 2000, label="Year")
-                    n_clusters = gr.Slider(2, 20, 5, label="Number of Clusters")
+                    wind_plot = gr.Plot(label="Wind Speed Analysis")
+                    pressure_plot = gr.Plot(label="Pressure Analysis")
                 
-                cluster_btn = gr.Button("Analyze Clusters")
-                cluster_plot = gr.Plot()
-                cluster_stats = gr.Markdown()
+                stats_text = gr.Markdown()
 
-            # Animation Tab
+            # Typhoon Animation Tab
             with gr.Tab("Typhoon Animation"):
                 with gr.Row():
                     animation_year = gr.Slider(
-                        minimum=1900,
-                        maximum=2024,
-                        value=2024,
+                        minimum=1950, 
+                        maximum=2024, 
+                        value=2020,
                         step=1,
                         label="Select Year"
                     )
@@ -1093,31 +976,27 @@ def create_interface():
                         label="Select Typhoon",
                         interactive=True
                     )
+                    
+                    standard_dropdown = gr.Dropdown(
+                        choices=[
+                            {"label": "Atlantic Standard", "value": "atlantic"},
+                            {"label": "Taiwan Standard", "value": "taiwan"}
+                        ],
+                        value="atlantic",
+                        label="Classification Standard"
+                    )
                 
-                animation_btn = gr.Button("Animate Typhoon Path", variant="primary")
-                animation_plot = gr.Plot()
+                animation_btn = gr.Button("Show Typhoon Path", variant="primary")
+                animation_plot = gr.Plot(label="Typhoon Path Animation")
                 animation_info = gr.Markdown()
 
             # Search Tab
             with gr.Tab("Typhoon Search"):
                 with gr.Row():
-                    search_year = gr.Slider(
-                        minimum=1900,
-                        maximum=2024,
-                        value=2024,
-                        step=1,
-                        label="Select Year"
-                    )
-                
-                with gr.Row():
-                    search_typhoon = gr.Dropdown(
-                        choices=[],
-                        label="Select Typhoon",
-                        interactive=True
-                    )
+                    search_input = gr.Textbox(label="Search Typhoon Name")
+                    search_btn = gr.Button("Search Typhoons", variant="primary")
                 
-                search_btn = gr.Button("Show Typhoon Details", variant="primary")
-                search_plot = gr.Plot()
+                search_results = gr.Plot(label="Search Results")
                 search_info = gr.Markdown()
 
         # Event handlers
@@ -1130,9 +1009,6 @@ def create_interface():
                 results['stats']
             ]
 
-        def cluster_callback(year, n_clusters):
-            return analyzer.analyze_clusters(year, n_clusters)
-
         def update_typhoon_choices(year):
             typhoons = analyzer.get_typhoons_for_year(year)
             return gr.update(choices=typhoons, value=None)
@@ -1144,13 +1020,6 @@ def create_interface():
             outputs=[tracks_plot, wind_plot, pressure_plot, stats_text]
         )
 
-        # Connect events for clustering
-        cluster_btn.click(
-            cluster_callback,
-            inputs=[cluster_year, n_clusters],
-            outputs=[cluster_plot, cluster_stats]
-        )
-
         # Connect events for Animation tab
         animation_year.change(
             update_typhoon_choices,
@@ -1160,21 +1029,15 @@ def create_interface():
 
         animation_btn.click(
             analyzer.create_typhoon_animation,
-            inputs=[animation_year, animation_typhoon],
+            inputs=[animation_year, animation_typhoon, standard_dropdown],
             outputs=[animation_plot, animation_info]
         )
 
         # Connect events for Search tab
-        search_year.change(
-            update_typhoon_choices,
-            inputs=[search_year],
-            outputs=[search_typhoon]
-        )
-
         search_btn.click(
-            analyzer.search_typhoon_details,
-            inputs=[search_year, search_typhoon],
-            outputs=[search_plot, search_info]
+            analyzer.search_typhoons,
+            inputs=[search_input],
+            outputs=[search_results, search_info]
         )
 
     return demo