Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,164 +1,170 @@
 import streamlit as st
 import pandas as pd
-import requests
-import plotly.express as px
-import time
+from obspy import UTCDateTime
+from obspy.clients.fdsn import Client
+import matplotlib.pyplot as plt
 
-# --- Page Configuration ---
+# --- App Configuration ---
 st.set_page_config(
-    page_title="Taiwan CWA Earthquake Alarms",
-    page_icon="🚨",
-    layout="wide",
+    page_title="Taiwan Earthquake Explorer 🇹🇼",
+    page_icon="🌋",
+    layout="wide"
 )
 
-# --- Data Fetching and Processing ---
-@st.cache_data(ttl=60)
-def fetch_cwa_alarms():
+# --- FDSN Client & Caching ---
+# Initialize the IRIS FDSN client
+client = Client("IRIS")
+
+@st.cache_data
+def search_earthquakes(start_time, end_time, min_mag, min_lat, max_lat, min_lon, max_lon):
     """
-    Fetches earthquake alarm data from the CWA API.
+    Searches for earthquake events using the ObsPy client.
+    Results are cached to prevent re-running the same query.
     """
-    API_URL = "https://app-2.cwa.gov.tw/api/v1/earthquake/alarm/list"
     try:
-        response = requests.get(API_URL, timeout=10)
-        response.raise_for_status()
-        raw_data = response.json().get('data', [])
-        
-        if not raw_data:
-            return pd.DataFrame()
-
-        return pd.DataFrame(raw_data)
-
-    except requests.exceptions.RequestException as e:
-        st.error(f"Failed to fetch data from CWA API: {e}")
-        return pd.DataFrame()
-
-# --- Main Application UI ---
-st.title("🚨 Taiwan CWA Earthquake Alarm Viewer")
-st.markdown(f"This app displays the latest earthquake early-warning alarms. Last updated: **{pd.Timestamp.now(tz='Asia/Taipei').strftime('%Y-%m-%d %H:%M:%S')}** (https://cwadayi-streamlit-alarm-taiwan.hf.space)")
-
-# Manual refresh button is still useful
-if st.button("Refresh Data Now"):
-    st.cache_data.clear()
-    st.rerun()
-
-df = fetch_cwa_alarms()
-
-# --- Sidebar for Filters and Controls ---
-with st.sidebar:
-    st.header("⚙️ Controls & Filters")
-    
-    # --- Auto-Refresh Controls ---
-    st.subheader("Auto-Refresh")
-    auto_refresh = st.checkbox("Enable Auto-Refresh", value=False)
-    refresh_interval = st.number_input(
-        "Refresh Interval (seconds)",
-        min_value=10,
-        max_value=300,
-        value=60,
-        step=5,
-        disabled=not auto_refresh,
-        help="Set how often the app should automatically refresh data. Must be between 10 and 300 seconds."
-    )
-
-    st.divider()
-    
-    # --- Data Filters ---
-    st.subheader("Data Filters")
-    if not df.empty:
-        # Ensure 'msgType' and 'msgNo' are strings for consistent sorting and filtering
-        df['msgType'] = df['msgType'].astype(str)
-        df['msgNo'] = df['msgNo'].astype(str)
-        
-        msg_types = sorted(df['msgType'].unique())
-        msg_numbers = sorted(df['msgNo'].unique())
-
-        selected_types = st.multiselect('Message Type(s)', options=msg_types, default=msg_types)
-        selected_numbers = st.multiselect('Message Number(s)', options=msg_numbers, default=msg_numbers)
-    else:
-        st.info("Waiting for data to load filters...")
-        # Define empty lists to prevent errors when df is empty
-        selected_types = []
-        selected_numbers = []
-
-
-# --- Main Content Area ---
-if df.empty:
-    st.warning("No alarm data is currently available or the API could not be reached.")
-else:
-    # Apply filters from the sidebar
-    filtered_df = df[
-        df['msgType'].isin(selected_types) &
-        df['msgNo'].isin(selected_numbers)
-    ].copy() # Use .copy() to avoid SettingWithCopyWarning
-
-    if filtered_df.empty:
-        st.warning("No data matches your current filter settings. Please adjust the filters in the sidebar.")
-    else:
-        # Prepare data for display
-        filtered_df['originTime'] = pd.to_datetime(filtered_df['originTime'])
-        filtered_df['magnitudeValue'] = pd.to_numeric(filtered_df['magnitudeValue'])
-        filtered_df['depth'] = pd.to_numeric(filtered_df['depth'])
-
-        # --- Interactive Map Display ---
-        st.header("Earthquake Epicenter Map")
-        map_df = filtered_df.sort_values('magnitudeValue', ascending=False).drop_duplicates(subset='originTime').copy()
-        
-        # Check if 'locationDesc' column exists and is not empty
-        if 'locationDesc' in filtered_df.columns and not filtered_df['locationDesc'].apply(lambda x: isinstance(x, list) and len(x) == 0).all():
-            table_df_for_hover = filtered_df.explode('locationDesc')
-            hover_areas = table_df_for_hover.groupby('originTime')['locationDesc'].apply(lambda x: ', '.join(set(x))).reset_index(name="Affected Areas")
-            map_df = pd.merge(map_df, hover_areas, on='originTime', how='left')
-            map_df['Affected Areas'] = map_df['Affected Areas'].fillna('N/A')
-            hover_data_config = {"Affected Areas": True, "magnitudeValue": ':.1f', "depth": True, "epicenterLat": False, "epicenterLon": False}
-        else:
-            map_df['Affected Areas'] = 'N/A'
-            hover_data_config = {"magnitudeValue": ':.1f', "depth": True, "epicenterLat": False, "epicenterLon": False}
+        catalog = client.get_events(
+            starttime=start_time,
+            endtime=end_time,
+            minlatitude=min_lat,
+            maxlatitude=max_lat,
+            minlongitude=min_lon,
+            maxlongitude=max_lon,
+            minmagnitude=min_mag,
+            orderby="time-asc"  # Order by time, ascending
+        )
+        return catalog
+    except Exception as e:
+        st.error(f"Could not retrieve event data: {e}")
+        return None
+
+@st.cache_data
+def get_waveforms_for_event(_event): # Caching requires hashable arguments
+    """
+    Retrieves and processes seismic waveforms for a given event.
+    _event is a tuple of event properties to make it hashable for caching.
+    """
+    event_time_str, event_lat, event_lon, event_depth = _event
+    event_time = UTCDateTime(event_time_str)
 
+    # Define a time window around the event origin time
+    t_start = event_time - 30  # 30 seconds before
+    t_end = event_time + 5 * 60   # 5 minutes after
 
-        fig = px.scatter_map(
-            map_df, lat="epicenterLat", lon="epicenterLon", size="magnitudeValue", color="depth",
-            color_continuous_scale=px.colors.sequential.OrRd, size_max=25, zoom=6.5,
-            center={"lat": 23.9, "lon": 121.5},
-            hover_name="originTime",
-            hover_data=hover_data_config,
-            labels={"depth": "Depth (km)", "magnitudeValue": "Magnitude"}
+    try:
+        # Fetch waveforms from the TW network for broadband channels
+        stream = client.get_waveforms(
+            network="TW",
+            station="*",
+            location="*",
+            channel="BH*",  # Broadband High Gain channels (BHZ, BHN, BHE)
+            starttime=t_start,
+            endtime=t_end,
+            attach_response=True  # Attach instrument response
         )
-
-        fig.update_layout(margin={"r": 0, "t": 40, "l": 0, "b": 0}, legend_title_text='Magnitude')
-        st.plotly_chart(fig, use_container_width=True)
-        
-        # --- FIX: Add vertical space to prevent overlap ---
-        st.markdown("<br>", unsafe_allow_html=True)
-        
-        # --- Detailed Table Display ---
-        st.header("Detailed Alarm Reports")
-        
-        if 'locationDesc' in filtered_df.columns:
-            filtered_df['Alarm Areas'] = filtered_df['locationDesc'].apply(lambda areas: ', '.join(areas) if isinstance(areas, list) else 'N/A')
+        if len(stream) > 0:
+            # Pre-processing: Detrend, taper, and remove instrument response
+            stream.detrend("linear")
+            stream.taper(max_percentage=0.05, type="cosine")
+            stream.remove_response(output="VEL") # Convert to velocity (m/s)
+            return stream
         else:
-            filtered_df['Alarm Areas'] = 'N/A'
+            return None
+    except Exception:
+        # Return None if no data is available or an error occurs
+        return None
+
+
+# --- Streamlit User Interface ---
+st.title("🌋 Taiwan Earthquake Explorer")
+st.markdown("Search, map, and visualize seismic data from the TW network via IRIS FDSN.")
+
+# --- Sidebar for Search Controls ---
+st.sidebar.header("🔍 Search Parameters")
+
+# Date and Time Inputs
+default_start = UTCDateTime("2024-04-02T23:00:00")
+default_end = UTCDateTime("2024-04-03T01:00:00")
+start_date = st.sidebar.date_input("Start Date", value=default_start.date)
+start_time_str = st.sidebar.text_input("Start Time (UTC)", value=default_start.strftime("%H:%M:%S"))
+end_date = st.sidebar.date_input("End Date", value=default_end.date)
+end_time_str = st.sidebar.text_input("End Time (UTC)", value=default_end.strftime("%H:%M:%S"))
+
+# Combine date and time
+start_utc = UTCDateTime(f"{start_date}T{start_time_str}")
+end_utc = UTCDateTime(f"{end_date}T{end_time_str}")
+
+# Magnitude and Location Inputs
+st.sidebar.markdown("---")
+min_mag = st.sidebar.slider("Minimum Magnitude", 2.0, 8.0, 5.5)
+
+st.sidebar.markdown("---")
+st.sidebar.subheader("Geographical Region (Taiwan)")
+min_lat = st.sidebar.number_input("Min Latitude", value=21.5, format="%.2f")
+max_lat = st.sidebar.number_input("Max Latitude", value=25.5, format="%.2f")
+min_lon = st.sidebar.number_input("Min Longitude", value=120.0, format="%.2f")
+max_lon = st.sidebar.number_input("Max Longitude", value=122.5, format="%.2f")
+
+# --- Main App Logic ---
+if st.sidebar.button("Search for Earthquakes", type="primary"):
+    catalog = search_earthquakes(start_utc, end_utc, min_mag, min_lat, max_lat, min_lon, max_lon)
+
+    if catalog and len(catalog) > 0:
+        st.success(f"✅ Found {len(catalog)} earthquake(s).")
+
+        # --- Process and Display Data ---
+        event_data = []
+        for event in catalog:
+            origin = event.preferred_origin() or event.origins[0]
+            magnitude = event.preferred_magnitude() or event.magnitudes[0]
+            event_data.append({
+                "Time (UTC)": origin.time.strftime('%Y-%m-%d %H:%M:%S'),
+                "Latitude": origin.latitude,
+                "Longitude": origin.longitude,
+                "Depth (km)": origin.depth / 1000.0,
+                "Magnitude": magnitude.mag,
+                "Mag Type": magnitude.magnitude_type
+            })
+
+        event_df = pd.DataFrame(event_data)
+
+        st.subheader("🗺️ Earthquake Map")
+        st.map(event_df, latitude='Latitude', longitude='Longitude', size='Magnitude', zoom=6)
+
+        st.subheader("📊 Earthquake Catalog Table")
+        st.dataframe(event_df)
+
+        st.markdown("---")
+        st.subheader(" seismograph Seismic Waveform Viewer")
+
+        # --- Waveform Selection and Display ---
+        event_options = {f"{row['Time (UTC)']} - Mag: {row['Magnitude']:.1f}": index for index, row in event_df.iterrows()}
+        selected_event_str = st.selectbox("Select an event to view waveforms:", options=event_options.keys())
+
+        if selected_event_str:
+            selected_index = event_options[selected_event_str]
+            selected_event = catalog[selected_index]
+            origin = selected_event.preferred_origin() or selected_event.origins[0]
             
-        display_df = filtered_df[[
-            "originTime", "identifier", "msgType", "msgNo", "magnitudeValue",
-            "depth", "epicenterLat", "epicenterLon", "Alarm Areas"
-        ]].rename(columns={
-            "originTime": "Origin Time", "identifier": "Report ID", "msgType": "Message Type",
-            "msgNo": "Message No.", "magnitudeValue": "Magnitude", "depth": "Depth (km)",
-            "epicenterLat": "Latitude", "epicenterLon": "Longitude"
-        })
-        
-        st.dataframe(
-            display_df.sort_values(by=["Origin Time", "Message No."], ascending=[False, True]),
-            use_container_width=True, hide_index=True,
-            column_config={"Origin Time": st.column_config.DatetimeColumn(format="YYYY-MM-DD HH:mm:ss")}
-        )
+            # Create a hashable tuple for caching
+            event_tuple = (
+                str(origin.time),
+                origin.latitude,
+                origin.longitude,
+                origin.depth
+            )
+
+            with st.spinner("Fetching waveforms from TW network... This may take a moment."):
+                waveforms = get_waveforms_for_event(event_tuple)
+
+            if waveforms and len(waveforms) > 0:
+                st.success(f"📊 Found and processed {len(waveforms)} waveform traces.")
+                # Plotting the waveforms
+                fig, ax = plt.subplots(figsize=(12, len(waveforms) * 1.5))
+                waveforms.plot(fig=fig, handle=True)
+                ax.set_title(f"Seismic Waveforms for Event: {selected_event_str}")
+                st.pyplot(fig)
+            else:
+                st.warning("Could not retrieve any waveform data for the selected event from the TW network.")
 
-# --- Auto-Refresh Logic ---
-if auto_refresh:
-    with st.sidebar:
-        placeholder = st.empty()
-        for i in range(refresh_interval, 0, -1):
-            placeholder.info(f"⏳ Refreshing in {i} seconds...")
-            time.sleep(1)
-        placeholder.empty()
-    st.rerun()
+    else:
+        st.warning("No earthquakes found matching your criteria. Try expanding the search window or lowering the magnitude.")