docs: refactor event handling and streamline data loading in app.py

app.py

@@ -1,33 +1,21 @@
 import gradio as gr
-import numpy as np
 import matplotlib.pyplot as plt
-from obspy import read
-import xarray as xr
+import numpy as np
+import pandas as pd
+import plotly.graph_objs as go
 import torch
-import torch.nn as nn
+import xarray as xr
+from huggingface_hub import hf_hub_download
+from loguru import logger
+from obspy import read
 from scipy.signal import detrend, iirfilter, sosfilt, zpk2sos
 from scipy.spatial import cKDTree
-import pandas as pd
-from loguru import logger
-import plotly.graph_objs as go
+
+from model import get_full_model
 
 # 設定 matplotlib 中文字體支援
-plt.rcParams['font.sans-serif'] = ['Arial Unicode MS', 'DejaVu Sans']
-plt.rcParams['axes.unicode_minus'] = False  # 解決負號顯示問題
-
-# GPU/CPU 設定
-if torch.cuda.is_available():
-    device = torch.device("cuda")
-    logger.info("使用 GPU")
-elif torch.mps.is_available():
-    device = torch.device("mps")
-    logger.info("使用 Apple MPS")
-else:
-    device = torch.device("cpu")
-    logger.info("使用 CPU")
-
-# 載入 Vs30 資料集（從 Hugging Face 下載）
-from huggingface_hub import hf_hub_download
+plt.rcParams["font.sans-serif"] = ["Arial Unicode MS", "DejaVu Sans"]
+plt.rcParams["axes.unicode_minus"] = False  # 解決負號顯示問題
 
 tree = None
 vs30_table = None
@@ -35,16 +23,16 @@ vs30_table = None
 try:
     logger.info("從 Hugging Face 載入 Vs30 資料...")
     vs30_file = hf_hub_download(
-        repo_id="SeisBlue/TaiwanVs30",
-        filename="Vs30ofTaiwan.nc",
+        repo_id="SeisBlue/TaiwanVs30", filename="Vs30ofTaiwan.nc",
         repo_type="dataset"
     )
     ds = xr.open_dataset(vs30_file)
-    lat_flat = ds['lat'].values.flatten()
-    lon_flat = ds['lon'].values.flatten()
-    vs30_flat = ds['vs30'].values.flatten()
+    lat_flat = ds["lat"].values.flatten()
+    lon_flat = ds["lon"].values.flatten()
+    vs30_flat = ds["vs30"].values.flatten()
 
-    vs30_table = pd.DataFrame({'lat': lat_flat, 'lon': lon_flat, 'Vs30': vs30_flat})
+    vs30_table = pd.DataFrame(
+        {"lat": lat_flat, "lon": lon_flat, "Vs30": vs30_flat})
     vs30_table = vs30_table.replace([np.inf, -np.inf], np.nan).dropna()
     tree = cKDTree(vs30_table[["lat", "lon"]])
     logger.info("Vs30 資料載入完成")
@@ -61,13 +49,18 @@ try:
 
     # 驗證 site_info.csv 必要欄位
     required_site_fields = ["Station", "Latitude", "Longitude", "Elevation"]
-    missing_site_fields = [f for f in required_site_fields if f not in site_info.columns]
+    missing_site_fields = [
+        f for f in required_site_fields if f not in site_info.columns
+    ]
     if missing_site_fields:
-        logger.error(f"{site_info_file} 缺少必要欄位: {missing_site_fields}")
-        raise ValueError(f"site_info.csv 缺少必要欄位: {missing_site_fields}")
+        logger.error(
+            f"{site_info_file} 缺少必要欄位: {missing_site_fields}")
+        raise ValueError(
+            f"site_info.csv 缺少必要欄位: {missing_site_fields}")
 
     # 只保留唯一的測站（去除重複的分量）
-    site_info = site_info.drop_duplicates(subset=['Station']).reset_index(drop=True)
+    site_info = site_info.drop_duplicates(subset=["Station"]).reset_index(
+        drop=True)
     logger.info(f"{site_info_file} 載入完成，共 {len(site_info)} 個測站")
 except FileNotFoundError:
     logger.warning(f"{site_info_file} 找不到")
@@ -81,11 +74,15 @@ try:
     target_df = pd.read_csv(target_file)
 
     # 驗證 eew_target.csv 必要欄位
-    required_target_fields = ["station", "latitude", "longitude", "elevation"]
-    missing_target_fields = [f for f in required_target_fields if f not in target_df.columns]
+    required_target_fields = ["station", "latitude", "longitude",
+                              "elevation"]
+    missing_target_fields = [
+        f for f in required_target_fields if f not in target_df.columns
+    ]
     if missing_target_fields:
         logger.error(f"{target_file} 缺少必要欄位: {missing_target_fields}")
-        raise ValueError(f"eew_target.csv 缺少必要欄位: {missing_target_fields}")
+        raise ValueError(
+            f"eew_target.csv 缺少必要欄位: {missing_target_fields}")
 
     target_dict = target_df.to_dict(orient="records")
     logger.info(f"{target_file} 載入完成（共 {len(target_dict)} 個目標點）")
@@ -94,375 +91,61 @@ except FileNotFoundError:
 except Exception as e:
     logger.error(f"{target_file} 載入失敗: {e}")
 
-# 預設地震事件
-EARTHQUAKE_EVENTS = {
-    "0403花蓮地震 (2024)": "waveform/20240403.mseed",
-}
-
 
 # ============ 震央資訊管理 ============
 
-def load_earthquake_metadata(event_json_path="waveform/event.json"):
-    """
-    從 JSON 檔案讀取地震事件元資料（震央經緯度、深度等）
-
-    參數：
-        event_json_path: event.json 的相對或絕對路徑
-
-    返回：
-        dict: {event_name -> {"epicenter_lat", "epicenter_lon", "depth_km", ...}}
-        若檔案缺失或無效，使用預設座標 (121.57, 23.88) 並記錄警��
-    """
-    earthquake_metadata = {}
-
-    try:
-        import json
-        with open(event_json_path, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-
-        if "events" not in data:
-            logger.warning(f"{event_json_path} 缺少 'events' 鍵，使用預設座標")
-            return {}
-
-        # 將事件列表轉換為以 event_name 為鍵的字典
-        for event in data["events"]:
-            event_name = event.get("event_name")
-            if event_name:
-                earthquake_metadata[event_name] = {
-                    "epicenter_lat": event.get("epicenter_lat", 23.88),
-                    "epicenter_lon": event.get("epicenter_lon", 121.57),
-                    "depth_km": event.get("depth_km", None),
-                    "magnitude": event.get("magnitude", None),
-                }
-                logger.info(f"載入事件: {event_name} | 震央: ({event.get('epicenter_lon', 121.57)}, {event.get('epicenter_lat', 23.88)})")
-
-        logger.info(f"地震事件元資料載入完成（共 {len(earthquake_metadata)} 個事件）")
-        return earthquake_metadata
-
-    except FileNotFoundError:
-        logger.error(f"事件元資料檔案缺失: {event_json_path}")
-        logger.warning("將使用預設震央座標 (121.57, 23.88)")
-        return {}
-
-    except Exception as e:
-        logger.error(f"讀取事件元資料時發生錯誤: {e}")
-        logger.warning("將使用預設震央座標 (121.57, 23.88)")
-        return {}
-
-
-def _get_epicenter_coords(event_name):
-    """
-    從全域 earthquake_metadata 獲取指定事件的震央座標
-
-    參數：
-        event_name: 事件名稱（EARTHQUAKE_EVENTS 的鍵值）
+earthquake_metadata = {}
+event_json_path="waveform/event.json"
 
-    返回：
-        tuple: (epicenter_lat, epicenter_lon)
-        若事件不存在或座標缺失，返回預設座標 (23.88, 121.57)
-    """
-    if event_name in earthquake_metadata:
-        metadata = earthquake_metadata[event_name]
-        lat = metadata.get("epicenter_lat", 23.88)
-        lon = metadata.get("epicenter_lon", 121.57)
-        return lat, lon
-    else:
-        logger.warning(f"未找到事件 '{event_name}' 的元資料，使用預設震央座標")
-        return 23.88, 121.57
-
-
-# 載入地震事件元資料
-earthquake_metadata = load_earthquake_metadata("waveform/event.json")
-if not earthquake_metadata:
-    logger.warning("無法載入事件元資料，應用將使用預設震央座標")
-
-
-# ============ 模型定義（從 ttsam_realtime.py 複製） ============
-
-class LambdaLayer(nn.Module):
-    def __init__(self, lambd, eps=1e-4):
-        super(LambdaLayer, self).__init__()
-        self.lambd = lambd
-        self.eps = eps
-
-    def forward(self, x):
-        return self.lambd(x) + self.eps
-
-
-class MLP(nn.Module):
-    def __init__(self, input_shape, dims=(500, 300, 200, 150), activation=nn.ReLU(),
-                 last_activation=None):
-        super(MLP, self).__init__()
-        if last_activation is None:
-            last_activation = activation
-        self.dims = dims
-        self.first_fc = nn.Linear(input_shape[0], dims[0])
-        self.first_activation = activation
-
-        more_hidden = []
-        if len(self.dims) > 2:
-            for i in range(1, len(self.dims) - 1):
-                more_hidden.append(nn.Linear(self.dims[i - 1], self.dims[i]))
-                more_hidden.append(nn.ReLU())
-
-        self.more_hidden = nn.ModuleList(more_hidden)
-        self.last_fc = nn.Linear(dims[-2], dims[-1])
-        self.last_activation = last_activation
-
-    def forward(self, x):
-        output = self.first_fc(x)
-        output = self.first_activation(output)
-        if self.more_hidden:
-            for layer in self.more_hidden:
-                output = layer(output)
-        output = self.last_fc(output)
-        output = self.last_activation(output)
-        return output
-
-
-class CNN(nn.Module):
-    def __init__(self, input_shape=(-1, 6000, 3), activation=nn.ReLU(), downsample=1,
-                 mlp_input=11665, mlp_dims=(500, 300, 200, 150), eps=1e-8):
-        super(CNN, self).__init__()
-        self.input_shape = input_shape
-        self.activation = activation
-        self.downsample = downsample
-        self.mlp_input = mlp_input
-        self.mlp_dims = mlp_dims
-        self.eps = eps
-
-        self.lambda_layer_1 = LambdaLayer(
-            lambda t: t / (
-                        torch.max(torch.max(torch.abs(t), dim=1, keepdim=True).values,
-                                  dim=2, keepdim=True).values + self.eps)
-        )
-        self.unsqueeze_layer1 = LambdaLayer(lambda t: torch.unsqueeze(t, dim=1))
-        self.lambda_layer_2 = LambdaLayer(
-            lambda t: torch.log(torch.max(torch.max(torch.abs(t), dim=1).values,
-                                          dim=1).values + self.eps) / 100
-        )
-        self.unsqueeze_layer2 = LambdaLayer(lambda t: torch.unsqueeze(t, dim=1))
-        self.conv2d1 = nn.Sequential(
-            nn.Conv2d(1, 8, kernel_size=(1, downsample), stride=(1, downsample)),
-            nn.ReLU())
-        self.conv2d2 = nn.Sequential(
-            nn.Conv2d(8, 32, kernel_size=(16, 3), stride=(1, 3)), nn.ReLU())
-        self.conv1d1 = nn.Sequential(nn.Conv1d(32, 64, kernel_size=16), nn.ReLU())
-        self.maxpooling = nn.MaxPool1d(2)
-        self.conv1d2 = nn.Sequential(nn.Conv1d(64, 128, kernel_size=16), nn.ReLU())
-        self.conv1d3 = nn.Sequential(nn.Conv1d(128, 32, kernel_size=8), nn.ReLU())
-        self.conv1d4 = nn.Sequential(nn.Conv1d(32, 32, kernel_size=8), nn.ReLU())
-        self.conv1d5 = nn.Sequential(nn.Conv1d(32, 16, kernel_size=4), nn.ReLU())
-        self.mlp = MLP((self.mlp_input,), dims=self.mlp_dims)
-
-    def forward(self, x):
-        output = self.lambda_layer_1(x)
-        output = self.unsqueeze_layer1(output)
-        scale = self.lambda_layer_2(x)
-        scale = self.unsqueeze_layer2(scale)
-        output = self.conv2d1(output)
-        output = self.conv2d2(output)
-        output = torch.squeeze(output, dim=-1)
-        output = self.conv1d1(output)
-        output = self.maxpooling(output)
-        output = self.conv1d2(output)
-        output = self.maxpooling(output)
-        output = self.conv1d3(output)
-        output = self.maxpooling(output)
-        output = self.conv1d4(output)
-        output = self.conv1d5(output)
-        output = torch.flatten(output, start_dim=1)
-        output = torch.cat((output, scale), dim=1)
-        output = self.mlp(output)
-        return output
-
-
-class PositionEmbeddingVs30(nn.Module):
-    def __init__(self, wavelengths=((5, 30), (110, 123), (0.01, 5000), (100, 1600)),
-                 emb_dim=500):
-        super(PositionEmbeddingVs30, self).__init__()
-        self.wavelengths = wavelengths
-        self.emb_dim = emb_dim
-
-        min_lat, max_lat = wavelengths[0]
-        min_lon, max_lon = wavelengths[1]
-        min_depth, max_depth = wavelengths[2]
-        min_vs30, max_vs30 = wavelengths[3]
-
-        assert emb_dim % 10 == 0
-        lat_dim = emb_dim // 5
-        lon_dim = emb_dim // 5
-        depth_dim = emb_dim // 10
-        vs30_dim = emb_dim // 10
-
-        self.lat_coeff = 2 * np.pi * 1.0 / min_lat * (
-                    (min_lat / max_lat) ** (np.arange(lat_dim) / lat_dim))
-        self.lon_coeff = 2 * np.pi * 1.0 / min_lon * (
-                    (min_lon / max_lon) ** (np.arange(lon_dim) / lon_dim))
-        self.depth_coeff = 2 * np.pi * 1.0 / min_depth * (
-                    (min_depth / max_depth) ** (np.arange(depth_dim) / depth_dim))
-        self.vs30_coeff = 2 * np.pi * 1.0 / min_vs30 * (
-                    (min_vs30 / max_vs30) ** (np.arange(vs30_dim) / vs30_dim))
-
-        lat_sin_mask = np.arange(emb_dim) % 5 == 0
-        lat_cos_mask = np.arange(emb_dim) % 5 == 1
-        lon_sin_mask = np.arange(emb_dim) % 5 == 2
-        lon_cos_mask = np.arange(emb_dim) % 5 == 3
-        depth_sin_mask = np.arange(emb_dim) % 10 == 4
-        depth_cos_mask = np.arange(emb_dim) % 10 == 9
-        vs30_sin_mask = np.arange(emb_dim) % 10 == 5
-        vs30_cos_mask = np.arange(emb_dim) % 10 == 8
-
-        self.mask = np.zeros(emb_dim)
-        self.mask[lat_sin_mask] = np.arange(lat_dim)
-        self.mask[lat_cos_mask] = lat_dim + np.arange(lat_dim)
-        self.mask[lon_sin_mask] = 2 * lat_dim + np.arange(lon_dim)
-        self.mask[lon_cos_mask] = 2 * lat_dim + lon_dim + np.arange(lon_dim)
-        self.mask[depth_sin_mask] = 2 * lat_dim + 2 * lon_dim + np.arange(depth_dim)
-        self.mask[depth_cos_mask] = 2 * lat_dim + 2 * lon_dim + depth_dim + np.arange(
-            depth_dim)
-        self.mask[
-            vs30_sin_mask] = 2 * lat_dim + 2 * lon_dim + 2 * depth_dim + np.arange(
-            vs30_dim)
-        self.mask[
-            vs30_cos_mask] = 2 * lat_dim + 2 * lon_dim + 2 * depth_dim + vs30_dim + np.arange(
-            vs30_dim)
-        self.mask = self.mask.astype("int32")
-
-    def forward(self, x):
-        lat_base = x[:, :, 0:1].to(device) * torch.Tensor(self.lat_coeff).to(device)
-        lon_base = x[:, :, 1:2].to(device) * torch.Tensor(self.lon_coeff).to(device)
-        depth_base = x[:, :, 2:3].to(device) * torch.Tensor(self.depth_coeff).to(device)
-        vs30_base = x[:, :, 3:4] * torch.Tensor(self.vs30_coeff).to(device)
-
-        output = torch.cat([
-            torch.sin(lat_base), torch.cos(lat_base),
-            torch.sin(lon_base), torch.cos(lon_base),
-            torch.sin(depth_base), torch.cos(depth_base),
-            torch.sin(vs30_base), torch.cos(vs30_base),
-        ], dim=-1)
-
-        maskk = torch.from_numpy(np.array(self.mask)).long()
-        index = (maskk.unsqueeze(0).unsqueeze(0)).expand(x.shape[0], 1,
-                                                         self.emb_dim).to(device)
-        output = torch.gather(output, -1, index).to(device)
-        return output
-
-
-class TransformerEncoder(nn.Module):
-    def __init__(self, d_model=150, nhead=10, batch_first=True, activation="gelu",
-                 dropout=0.0, dim_feedforward=1000):
-        super(TransformerEncoder, self).__init__()
-        self.encoder_layer = nn.TransformerEncoderLayer(
-            d_model=d_model, nhead=nhead, batch_first=batch_first,
-            activation=activation, dropout=dropout, dim_feedforward=dim_feedforward
-        ).to(device)
-        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, 6).to(
-            device)
-
-    def forward(self, x, src_key_padding_mask=None):
-        return self.transformer_encoder(x, src_key_padding_mask=src_key_padding_mask)
-
-
-class MDN(nn.Module):
-    def __init__(self, input_shape=(150,), n_hidden=20, n_gaussians=5):
-        super(MDN, self).__init__()
-        self.z_h = nn.Sequential(nn.Linear(input_shape[0], n_hidden), nn.Tanh())
-        self.z_weight = nn.Linear(n_hidden, n_gaussians)
-        self.z_sigma = nn.Linear(n_hidden, n_gaussians)
-        self.z_mu = nn.Linear(n_hidden, n_gaussians)
-
-    def forward(self, x):
-        z_h = self.z_h(x)
-        weight = nn.functional.softmax(self.z_weight(z_h), -1)
-        sigma = torch.exp(self.z_sigma(z_h))
-        mu = self.z_mu(z_h)
-        return weight, sigma, mu
-
-
-class FullModel(nn.Module):
-    def __init__(self, model_cnn, model_position, model_transformer, model_mlp,
-                 model_mdn,
-                 max_station=25, pga_targets=15, emb_dim=150, data_length=6000):
-        super(FullModel, self).__init__()
-        self.data_length = data_length
-        self.model_CNN = model_cnn
-        self.model_Position = model_position
-        self.model_Transformer = model_transformer
-        self.model_mlp = model_mlp
-        self.model_MDN = model_mdn
-        self.max_station = max_station
-        self.pga_targets = pga_targets
-        self.emb_dim = emb_dim
-
-    def forward(self, data):
-        cnn_output = self.model_CNN(
-            torch.DoubleTensor(
-                data["waveform"].reshape(-1, self.data_length, 3)).float().to(device)
-        )
-        cnn_output_reshape = torch.reshape(cnn_output,
-                                           (-1, self.max_station, self.emb_dim))
-
-        emb_output = self.model_Position(
-            torch.DoubleTensor(
-                data["station"].reshape(-1, 1, data["station"].shape[2])).float().to(
-                device)
-        )
-        emb_output = emb_output.reshape(-1, self.max_station, self.emb_dim)
-
-        station_pad_mask = data["station"] == 0
-        station_pad_mask = torch.all(station_pad_mask, 2)
-
-        pga_pos_emb_output = self.model_Position(
-            torch.DoubleTensor(
-                data["target"].reshape(-1, 1, data["target"].shape[2])).float().to(
-                device)
-        )
-        pga_pos_emb_output = pga_pos_emb_output.reshape(-1, self.pga_targets,
-                                                        self.emb_dim)
-
-        target_pad_mask = torch.ones_like(data["target"], dtype=torch.bool)
-        target_pad_mask = torch.all(target_pad_mask, 2)
-        pad_mask = torch.cat((station_pad_mask, target_pad_mask), dim=1).to(device)
-
-        add_pe_cnn_output = torch.add(cnn_output_reshape, emb_output)
-        transformer_input = torch.cat((add_pe_cnn_output, pga_pos_emb_output), dim=1)
-        transformer_output = self.model_Transformer(transformer_input, pad_mask)
+try:
+    import json
+
+    with open(event_json_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+
+    if "events" not in data:
+        logger.error(f"{event_json_path} 缺少 'events' 鍵")
+
+    # 將事件列表轉換為以 event_name 為鍵的字典
+    for event in data["events"]:
+        event_name = event.get("event_name")
+        if event_name:
+            earthquake_metadata[event_name] = {
+                "event_id": event.get("event_id"),
+                "event_name": event.get("event_name"),
+                "timestamp": event.get("timestamp"),
+                "first_pick": event.get("first_pick"),
+                "mseed_file": event.get("mseed_file"),
+                "intensity_map_file": event.get("intensity_map_file"),
+                "epicenter_lat": event.get("epicenter_lat"),
+                "epicenter_lon": event.get("epicenter_lon"),
+                "depth_km": event.get("depth_km"),
+                "magnitude": event.get("magnitude"),
+            }
+            logger.info(
+                f"載入事件: {event_name} | 震央: ({event.get('epicenter_lon')}, {event.get('epicenter_lat')})"
+            )
 
-        mlp_input = transformer_output[:, -self.pga_targets:, :].to(device)
-        mlp_output = self.model_mlp(mlp_input)
-        weight, sigma, mu = self.model_MDN(mlp_output)
+    logger.info(f"地震事件元資料載入完成（共 {len(earthquake_metadata)} 個事件）")
 
-        return weight, sigma, mu
+except FileNotFoundError:
+    logger.error(f"事件元資料檔案缺失: {event_json_path}")
 
 
-def get_full_model(model_path):
-    emb_dim = 150
-    mlp_dims = (150, 100, 50, 30, 10)
-    cnn_model = CNN(mlp_input=5665).to(device)
-    pos_emb_model = PositionEmbeddingVs30(emb_dim=emb_dim).to(device)
-    transformer_model = TransformerEncoder()
-    mlp_model = MLP(input_shape=(emb_dim,), dims=mlp_dims).to(device)
-    mdn_model = MDN(input_shape=(mlp_dims[-1],)).to(device)
-    full_model = FullModel(
-        cnn_model, pos_emb_model, transformer_model, mlp_model, mdn_model,
-        pga_targets=25, data_length=3000
-    ).to(device)
-    full_model.load_state_dict(
-        torch.load(model_path, weights_only=True, map_location=device))
-    return full_model
+except Exception as e:
+    logger.error(f"讀取事件元資料時發生錯誤: {e}")
 
 
 # 載入模型
 model_path = hf_hub_download(
-    repo_id="SeisBlue/TTSAM",
-    filename="ttsam_trained_model_11.pt"
+    repo_id="SeisBlue/TTSAM", filename="ttsam_trained_model_11.pt"
 )
 model = get_full_model(model_path)
 
 
 # ============ 輔助函數 ============
 
+
 def lowpass(data, freq=10, df=100, corners=4):
     fe = 0.5 * df
     f = freq / fe
@@ -490,7 +173,6 @@ def get_vs30(lat, lon, user_vs30=600):
     return float(vs30)
 
 
-
 def calculate_intensity(pga, label=False):
     intensity_label = ["0", "1", "2", "3", "4", "5-", "5+", "6-", "6+", "7"]
     pga_level = np.log10([1e-5, 0.008, 0.025, 0.080, 0.250, 0.80, 1.4, 2.5, 4.4, 8.0])
@@ -506,16 +188,10 @@ def calculate_intensity(pga, label=False):
 
 # ============ Gradio 介面函數 ============
 
-def load_waveform(event_name):
-    """載入完整的 mseed 檔案（包含所有測站）"""
-    file_path = EARTHQUAKE_EVENTS[event_name]
-    st = read(file_path)
-    return st
-
 
 def calculate_distance(lat1, lon1, lat2, lon2):
     """計算兩點間的距離（簡化的平面距離，單位：度）"""
-    return np.sqrt((lat1 - lat2)**2 + (lon1 - lon2)**2)
+    return np.sqrt((lat1 - lat2) ** 2 + (lon1 - lon2) ** 2)
 
 
 def select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25):
@@ -542,9 +218,13 @@ def select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25):
 
             # 驗證必要欄位存在
             required_fields = ["Latitude", "Longitude", "Elevation"]
-            missing_fields = [f for f in required_fields if f not in station_data.columns]
+            missing_fields = [
+                f for f in required_fields if f not in station_data.columns
+            ]
             if missing_fields:
-                logger.warning(f"測站 {station_code} 缺少必要欄位: {missing_fields}，跳過")
+                logger.warning(
+                    f"測站 {station_code} 缺少必要欄位: {missing_fields}，跳過"
+                )
                 continue
 
             lat = station_data["Latitude"].values[0]
@@ -557,7 +237,7 @@ def select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25):
                 "distance": distance,
                 "latitude": lat,
                 "longitude": lon,
-                "elevation": elev
+                "elevation": elev,
             }
         except Exception as e:
             logger.warning(f"測站 {station_code} 資訊查詢失敗: {e}")
@@ -571,14 +251,20 @@ def select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25):
     # 記錄實際可用的測站數（少於 25 站也允許繼續）
     actual_count = len(selected_stations)
     if actual_count < n_stations:
-        logger.warning(f"僅找到 {actual_count} 個可用測站（目標 {n_stations} 個），將繼續處理")
+        logger.warning(
+            f"僅找到 {actual_count} 個可用測站（目標 {n_stations} 個），將繼續處理"
+        )
     else:
-        logger.info(f"從 {len(station_list)} 個輸入測站中選擇了最近的 {actual_count} 個")
+        logger.info(
+            f"從 {len(station_list)} 個輸入測站中選擇了最近的 {actual_count} 個"
+        )
 
     return selected_stations
 
 
-def extract_waveforms_from_stream(st, selected_stations, start_time, duration, vs30_input):
+def extract_waveforms_from_stream(event_name,
+    st, selected_stations, duration, vs30_input
+):
     """
     從 Stream 中提取選定測站的波形資料
 
@@ -608,18 +294,21 @@ def extract_waveforms_from_stream(st, selected_stations, start_time, duration, v
     sampling_rate = 100  # 100 Hz
     min_duration = 30.0  # 最小時間長度 30 秒
     target_length = 3000  # 30 秒 @ 100 Hz = 3000 samples
+    first_pick = earthquake_metadata[event_name]["first_pick"]
 
     # 內部計算 end_time（接受 start/duration 參數）
-    end_time = start_time + duration
+    end_time = first_pick + duration
 
-    start_idx = int(start_time * sampling_rate)
+    start_idx = 0
     end_idx = int(end_time * sampling_rate)
     actual_samples = end_idx - start_idx
 
     # 檢查是否需要零填充：長度不足 30 秒時尾段以 0 遮罩補齊
     needs_padding = duration < min_duration
     if needs_padding:
-        logger.info(f"時間長度 {duration} 秒 < 30 秒，將以 0 遮罩補齊至 {min_duration} 秒")
+        logger.info(
+            f"時間長度 {duration} 秒 < 30 秒，將以 0 遮罩補齊至 {min_duration} 秒"
+        )
 
     for station_data in selected_stations:
         station_code = station_data["station"]
@@ -634,8 +323,12 @@ def extract_waveforms_from_stream(st, selected_stations, start_time, duration, v
 
             # 嘗試取得 Z, N, E 分量
             z_trace = st_station.select(component="Z")
-            n_trace = st_station.select(component="N") or st_station.select(component="1")
-            e_trace = st_station.select(component="E") or st_station.select(component="2")
+            n_trace = st_station.select(component="N") or st_station.select(
+                component="1"
+            )
+            e_trace = st_station.select(component="E") or st_station.select(
+                component="2"
+            )
 
             # 檢查 Z 分量（必須存在）
             if len(z_trace) > 0:
@@ -684,13 +377,17 @@ def extract_waveforms_from_stream(st, selected_stations, start_time, duration, v
             waveforms.append(waveform_3c)
 
             # 準備測站資訊
-            vs30 = get_vs30(station_data["latitude"], station_data["longitude"], vs30_input)
-            station_info_list.append([
-                station_data["latitude"],
-                station_data["longitude"],
-                station_data["elevation"],
-                vs30
-            ])
+            vs30 = get_vs30(
+                station_data["latitude"], station_data["longitude"], vs30_input
+            )
+            station_info_list.append(
+                [
+                    station_data["latitude"],
+                    station_data["longitude"],
+                    station_data["elevation"],
+                    vs30,
+                ]
+            )
             valid_stations.append(station_data)
 
         except Exception as e:
@@ -699,10 +396,13 @@ def extract_waveforms_from_stream(st, selected_stations, start_time, duration, v
 
     logger.info(f"成功提取 {len(waveforms)} 個測站的波形")
     if missing_components_count > 0:
-        logger.info(f"其中 {missing_components_count} 個測站缺少 N 或 E 分量（已以 Z 分量代替）")
+        logger.info(
+            f"其中 {missing_components_count} 個測站缺少 N 或 E 分量（已以 Z 分量代替）"
+        )
 
     return waveforms, station_info_list, valid_stations, missing_components_count
 
+
 def create_input_station_map(selected_stations, epicenter_lat, epicenter_lon):
     """創建輸入測站分布地圖：顯示所有測站 + 突顯被選中的 25 個（使用 Plotly）"""
 
@@ -722,9 +422,21 @@ def create_input_station_map(selected_stations, epicenter_lat, epicenter_lon):
             all_stations_text.append(station_code)
 
     # 準備選中測站資料（按距離分組）
-    selected_group1_lat, selected_group1_lon, selected_group1_text = [], [], []  # 前 5 近
-    selected_group2_lat, selected_group2_lon, selected_group2_text = [], [], []  # 6-15 近
-    selected_group3_lat, selected_group3_lon, selected_group3_text = [], [], []  # 16-25 近
+    selected_group1_lat, selected_group1_lon, selected_group1_text = (
+        [],
+        [],
+        [],
+    )  # 前 5 近
+    selected_group2_lat, selected_group2_lon, selected_group2_text = (
+        [],
+        [],
+        [],
+    )  # 6-15 近
+    selected_group3_lat, selected_group3_lon, selected_group3_text = (
+        [],
+        [],
+        [],
+    )  # 16-25 近
 
     for i, station_data in enumerate(selected_stations):
         station_code = station_data["station"]
@@ -751,82 +463,94 @@ def create_input_station_map(selected_stations, epicenter_lat, epicenter_lon):
     fig = go.Figure()
 
     # 添加所有測站（灰色小點）
-    fig.add_trace(go.Scattermap(
-        lat=all_stations_lat,
-        lon=all_stations_lon,
-        mode='markers',
-        marker=dict(size=6, color='gray', opacity=0.6),
-        text=all_stations_text,
-        hovertemplate='%{text}<extra></extra>',
-        name=f'所有測站 ({len(all_stations_lat)} 個)',
-        showlegend=True
-    ))
+    fig.add_trace(
+        go.Scattermap(
+            lat=all_stations_lat,
+            lon=all_stations_lon,
+            mode="markers",
+            marker=dict(size=6, color="gray", opacity=0.6),
+            text=all_stations_text,
+            hovertemplate="%{text}<extra></extra>",
+            name=f"所有測站 ({len(all_stations_lat)} 個)",
+            showlegend=True,
+        )
+    )
 
     # 添加選中測站 - 前 5 近（綠色）
     if selected_group1_lat:
-        fig.add_trace(go.Scattermap(
-            lat=selected_group1_lat,
-            lon=selected_group1_lon,
-            mode='markers',
-            marker=dict(size=12, color='green', opacity=0.8),
-            text=selected_group1_text,
-            hovertemplate='%{text}<extra></extra>',
-            name='前 5 近',
-            showlegend=True
-        ))
+        fig.add_trace(
+            go.Scattermap(
+                lat=selected_group1_lat,
+                lon=selected_group1_lon,
+                mode="markers",
+                marker=dict(size=12, color="green", opacity=0.8),
+                text=selected_group1_text,
+                hovertemplate="%{text}<extra></extra>",
+                name="前 5 近",
+                showlegend=True,
+            )
+        )
 
     # 添加選中測站 - 6-15 近（藍色）
     if selected_group2_lat:
-        fig.add_trace(go.Scattermap(
-            lat=selected_group2_lat,
-            lon=selected_group2_lon,
-            mode='markers',
-            marker=dict(size=12, color='blue', opacity=0.8),
-            text=selected_group2_text,
-            hovertemplate='%{text}<extra></extra>',
-            name='6-15 近',
-            showlegend=True
-        ))
+        fig.add_trace(
+            go.Scattermap(
+                lat=selected_group2_lat,
+                lon=selected_group2_lon,
+                mode="markers",
+                marker=dict(size=12, color="blue", opacity=0.8),
+                text=selected_group2_text,
+                hovertemplate="%{text}<extra></extra>",
+                name="6-15 近",
+                showlegend=True,
+            )
+        )
 
     # 添加選中測站 - 16-25 近（橘色）
     if selected_group3_lat:
-        fig.add_trace(go.Scattermap(
-            lat=selected_group3_lat,
-            lon=selected_group3_lon,
-            mode='markers',
-            marker=dict(size=12, color='orange', opacity=0.8),
-            text=selected_group3_text,
-            hovertemplate='%{text}<extra></extra>',
-            name='16-25 近',
-            showlegend=True
-        ))
+        fig.add_trace(
+            go.Scattermap(
+                lat=selected_group3_lat,
+                lon=selected_group3_lon,
+                mode="markers",
+                marker=dict(size=12, color="orange", opacity=0.8),
+                text=selected_group3_text,
+                hovertemplate="%{text}<extra></extra>",
+                name="16-25 近",
+                showlegend=True,
+            )
+        )
 
     # 添加震央（紅色大點）
-    fig.add_trace(go.Scattermap(
-        lat=[epicenter_lat],
-        lon=[epicenter_lon],
-        mode='markers',
-        marker=dict(size=25, color='red'),
-        text=[f'震央<br>({epicenter_lat:.3f}, {epicenter_lon:.3f})'],
-        hovertemplate='%{text}<extra></extra>',
-        name='震央',
-        showlegend=True
-    ))
-
-    fig.add_trace(go.Scattermap(
-        lat=[epicenter_lat],
-        lon=[epicenter_lon],
-        mode='markers',
-        marker=dict(size=10, color='white'),
-        showlegend=False
-    ))
+    fig.add_trace(
+        go.Scattermap(
+            lat=[epicenter_lat],
+            lon=[epicenter_lon],
+            mode="markers",
+            marker=dict(size=25, color="red"),
+            text=[f"震央<br>({epicenter_lat:.3f}, {epicenter_lon:.3f})"],
+            hovertemplate="%{text}<extra></extra>",
+            name="震央",
+            showlegend=True,
+        )
+    )
+
+    fig.add_trace(
+        go.Scattermap(
+            lat=[epicenter_lat],
+            lon=[epicenter_lon],
+            mode="markers",
+            marker=dict(size=10, color="white"),
+            showlegend=False,
+        )
+    )
 
     # 設置地圖佈局
     fig.update_layout(
         map=dict(
             style="open-street-map",
             center=dict(lat=epicenter_lat, lon=epicenter_lon),
-            zoom=7
+            zoom=7,
         ),
         height=500,  # 設置固定高度以適應 Gradio 容器
         margin=dict(l=0, r=0, t=0, b=0),
@@ -836,14 +560,14 @@ def create_input_station_map(selected_stations, epicenter_lat, epicenter_lon):
             y=0.95,
             xanchor="left",
             x=0.01,
-            bgcolor="rgba(255, 255, 255, 0.8)"
-        )
+            bgcolor="rgba(255, 255, 255, 0.8)",
+        ),
     )
 
     return fig
 
 
-def plot_waveform(st, selected_stations, start_time, duration):
+def plot_waveform(st, selected_stations, first_pick, duration):
     """
     繪製選定測站的波形圖（距離-時間圖，可顯示全部 25 個測站）
 
@@ -854,7 +578,7 @@ def plot_waveform(st, selected_stations, start_time, duration):
     - duration: 時間長度（秒）
     """
     # 計算結束時間
-    end_time = start_time + duration
+    end_time = first_pick + duration
 
     fig, ax = plt.subplots(figsize=(14, 10))
 
@@ -876,12 +600,22 @@ def plot_waveform(st, selected_stations, start_time, duration):
                 times = tr.times()
                 data = tr.data
 
+                # 只顯示從資料開始到 30 秒內的波形
+                time_mask = times <= 120.0
+                times = times[time_mask]
+                data = data[time_mask]
+
                 # 正規化波形振幅
                 data_normalized = data / (np.max(np.abs(data)) + 1e-10)
 
                 # 繪製波形，Y軸位置為距離
-                ax.plot(times, distance + data_normalized * amplitude_scale,
-                       'black', linewidth=0.3, alpha=0.8)
+                ax.plot(
+                    times,
+                    distance + data_normalized * amplitude_scale,
+                    "black",
+                    linewidth=0.3,
+                    alpha=0.8,
+                )
 
                 distances.append(distance)
                 station_names.append(station_code)
@@ -890,23 +624,34 @@ def plot_waveform(st, selected_stations, start_time, duration):
         except Exception as e:
             logger.warning(f"無法繪製測站 {station_code}: {e}")
 
+    ax.axvline(first_pick, color="blue", linestyle="--", linewidth=2, alpha=0.7, label="初動時間")
+
     # 標記選取時間範圍
-    ax.axvline(start_time, color='red', linestyle='--', linewidth=2,
-              alpha=0.7, label='選取範圍')
-    ax.axvline(end_time, color='red', linestyle='--', linewidth=2, alpha=0.7)
-    ax.axvspan(start_time, end_time, alpha=0.15, color='blue')
+    ax.axvline(
+        0,
+        color="red",
+        linestyle="--",
+        linewidth=2,
+        alpha=0.7,
+        label="選取範圍",
+    )
+    ax.axvline(end_time, color="red", linestyle="--", linewidth=2, alpha=0.7)
+    ax.axvspan(0, end_time, alpha=0.15, color="blue")
 
     # 設定軸標籤和標題
-    ax.set_xlabel('Time (s)', fontsize=12)
-    ax.set_ylabel('Distance from Epicenter (°)', fontsize=12)
-    ax.set_title(f'Record Section - {plotted_count} Stations Sorted by Distance',
-                fontsize=14, fontweight='bold')
+    ax.set_xlabel("Time (s)", fontsize=12)
+    ax.set_ylabel("Distance from Epicenter (°)", fontsize=12)
+    ax.set_title(
+        f"Record Section - {plotted_count} Stations Sorted by Distance",
+        fontsize=14,
+        fontweight="bold",
+    )
 
     # 在右側標註測站名稱
     if distances:
         ax2 = ax.twinx()
         ax2.set_ylim(ax.get_ylim())
-        ax2.set_ylabel('Station Code', fontsize=12)
+        ax2.set_ylabel("Station Code", fontsize=12)
 
         # 每隔幾個測站標註一次（避免過於擁擠）
         step = max(1, len(distances) // 10)
@@ -915,8 +660,8 @@ def plot_waveform(st, selected_stations, start_time, duration):
         ax2.set_yticks(tick_positions)
         ax2.set_yticklabels(tick_labels, fontsize=8)
 
-    ax.grid(True, alpha=0.3, axis='x')
-    ax.legend(loc='upper right')
+    ax.grid(True, alpha=0.3, axis="x")
+    ax.legend(loc="upper right")
     plt.tight_layout()
 
     return fig
@@ -939,31 +684,54 @@ def get_intensity_color(intensity):
     return color_map.get(intensity, "#ffffff")
 
 
-def create_intensity_map(pga_list, target_names, epicenter_lat=None, epicenter_lon=None):
+def create_intensity_map(
+    pga_list, target_names, epicenter_lat=None, epicenter_lon=None
+):
     """使用 Plotly 創建互動式震度分布地圖"""
 
     # 按震度等級分組資料
-    intensity_groups = {i: {'lat': [], 'lon': [], 'text': [], 'color': get_intensity_color(i)}
-                       for i in range(10)}
+    intensity_groups = {
+        i: {"lat": [], "lon": [], "text": [], "color": get_intensity_color(i)}
+        for i in range(10)
+    }
 
     # 添加震度測站標記
+    all_lats = []
+    all_lons = []
     for i, target_name in enumerate(target_names):
         target = next((t for t in target_dict if t["station"] == target_name), None)
         if target:
             lat = target["latitude"]
             lon = target["longitude"]
+            all_lats.append(lat)
+            all_lons.append(lon)
             intensity = calculate_intensity(pga_list[i])
             intensity_label = calculate_intensity(pga_list[i], label=True)
             pga = pga_list[i]
 
-            hover_text = (f"{target_name}<br>"
-                         f"震度: {intensity_label}<br>"
-                         f"PGA: {pga:.4f} m/s²<br>"
-                         f"位置: ({lat:.3f}, {lon:.3f})")
+            hover_text = (
+                f"{target_name}<br>"
+                f"震度: {intensity_label}<br>"
+                f"PGA: {pga:.4f} m/s²<br>"
+                f"位置: ({lat:.3f}, {lon:.3f})"
+            )
 
-            intensity_groups[intensity]['lat'].append(lat)
-            intensity_groups[intensity]['lon'].append(lon)
-            intensity_groups[intensity]['text'].append(hover_text)
+            intensity_groups[intensity]["lat"].append(lat)
+            intensity_groups[intensity]["lon"].append(lon)
+            intensity_groups[intensity]["text"].append(hover_text)
+
+    # 決定地圖中心（優先使用 epicenter，否則計算平均值）
+    if epicenter_lat is not None and epicenter_lon is not None:
+        map_center_lat = epicenter_lat
+        map_center_lon = epicenter_lon
+    elif all_lats and all_lons:
+        map_center_lat = np.mean(all_lats)
+        map_center_lon = np.mean(all_lons)
+    else:
+        # 如果沒有任何測站資料，使用台灣的中心
+        map_center_lat = 23.5
+        map_center_lon = 121.0
+        logger.warning("無法決定地圖中心，使用台灣預設中心")
 
     # 創建 Plotly 地圖
     fig = go.Figure()
@@ -972,44 +740,39 @@ def create_intensity_map(pga_list, target_names, epicenter_lat=None, epicenter_l
     intensity_labels = ["0", "1", "2", "3", "4", "5-", "5+", "6-", "6+", "7"]
     for intensity_level in range(10):
         group = intensity_groups[intensity_level]
-        if group['lat']:  # 有資料的震度等級
-            fig.add_trace(go.Scattermap(
-                lat=group['lat'],
-                lon=group['lon'],
-                mode='markers',
-                marker=dict(
-                    size=14,
-                    color=group['color'],
-                    opacity=0.8
-                ),
-                text=group['text'],
-                hovertemplate='%{text}<extra></extra>',
-                name=f'震度 {intensity_labels[intensity_level]}',
-                showlegend=True
-            ))
+        if group["lat"]:  # 有資料的震度等級
+            fig.add_trace(
+                go.Scattermap(
+                    lat=group["lat"],
+                    lon=group["lon"],
+                    mode="markers",
+                    marker=dict(size=14, color=group["color"], opacity=0.8),
+                    text=group["text"],
+                    hovertemplate="%{text}<extra></extra>",
+                    name=f"震度 {intensity_labels[intensity_level]}",
+                    showlegend=True,
+                )
+            )
         else:
             # 沒有資料的震度等級：添加隱形標記只為了顯示圖例
-            fig.add_trace(go.Scattermap(
-                lat=[None],
-                lon=[None],
-                mode='markers',
-                marker=dict(
-                    size=14,
-                    color=group['color'],
-                    opacity=0.8
-                ),
-                name=f'震度 {intensity_labels[intensity_level]}',
-                showlegend=True,
-                hoverinfo='skip'
-            ))
+            fig.add_trace(
+                go.Scattermap(
+                    lat=[None],
+                    lon=[None],
+                    mode="markers",
+                    marker=dict(size=14, color=group["color"], opacity=0.8),
+                    name=f"震度 {intensity_labels[intensity_level]}",
+                    showlegend=True,
+                    hoverinfo="skip",
+                )
+            )
 
     # 設置地圖佈局
     fig.update_layout(
         map=dict(
             style="open-street-map",
-            center=dict(lat=23.5,
-                       lon=121),
-            zoom=7
+            center=dict(lat=map_center_lat, lon=map_center_lon),
+            zoom=7,
         ),
         height=800,  # 設置固定高度以適應 Gradio 容器
         margin=dict(l=0, r=0, t=0, b=0),
@@ -1019,14 +782,13 @@ def create_intensity_map(pga_list, target_names, epicenter_lat=None, epicenter_l
             y=0.95,
             xanchor="left",
             x=0.01,
-            bgcolor="rgba(255, 255, 255, 0.8)"
-        )
+            bgcolor="rgba(255, 255, 255, 0.8)",
+        ),
     )
 
     return fig
 
 
-
 def load_observed_intensity_image(event_name):
     """
     從 intensity_map 資料夾載入對應的實際觀測震度圖
@@ -1035,23 +797,16 @@ def load_observed_intensity_image(event_name):
     """
     import os
 
-    event_file = EARTHQUAKE_EVENTS[event_name]
-    event_date = os.path.basename(event_file).replace('.mseed', '')
-
-    intensity_map_dir = "intensity_map"
-    possible_extensions = ['.png', '.jpg', '.jpeg', '.gif']
+    image_path = earthquake_metadata[event_name]["intensity_map_file"]
+    if os.path.exists(image_path):
+        logger.info(f"載入實際觀測震度圖: {image_path}")
+        return image_path
 
-    for ext in possible_extensions:
-        image_path = os.path.join(intensity_map_dir, f"{event_date}{ext}")
-        if os.path.exists(image_path):
-            logger.info(f"載入實際觀測震度圖: {image_path}")
-            return image_path
-
-    logger.warning(f"找不到實際震度圖: {event_date}（將顯示空白占位）")
+    logger.warning(f"找不到實際震度圖: {event_name}（將顯示空白占位）")
     return None
 
 
-def load_and_display_waveform(event_name, start_time, duration):
+def load_and_display_waveform(event_name, duration):
     """載入並顯示波形，讓使用者確認範圍
 
     從全域 earthquake_metadata 讀取震央座標
@@ -1060,28 +815,39 @@ def load_and_display_waveform(event_name, start_time, duration):
     """
     try:
         # 從全域 earthquake_metadata 讀取震央座標
-        epicenter_lat, epicenter_lon = _get_epicenter_coords(event_name)
+        epicenter_lat = earthquake_metadata[event_name]["epicenter_lat"]
+        epicenter_lon = earthquake_metadata[event_name]["epicenter_lon"]
+        mseed_file = earthquake_metadata[event_name]["mseed_file"]
+        first_pick = earthquake_metadata[event_name]["first_pick"]
 
         # 計算結束時間（用於顯示資訊）
-        end_time = start_time + duration
+
 
         # 1. 載入完整的 mseed 檔案
         logger.info(f"載入地震事件: {event_name}")
-        st = load_waveform(event_name)
+        st = read(mseed_file)
         logger.info(f"��入了 {len(st)} 個 trace")
 
         # 2. 根據震央距離選擇最近的 25 個測站
         logger.info(f"選擇距離震央 ({epicenter_lat}, {epicenter_lon}) 最近的測站...")
-        selected_stations = select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25)
+        selected_stations = select_nearest_stations(
+            st, epicenter_lat, epicenter_lon, n_stations=25
+        )
 
         if len(selected_stations) == 0:
-            return None, None, "錯誤：找不到有效的測站資料", gr.update(interactive=False)
+            return (
+                None,
+                None,
+                "錯誤：找不到有效的測站資料",
+                gr.update(interactive=False),
+            )
 
-        # 3. 繪製波形（傳入 start_time 和 duration）
-        waveform_plot = plot_waveform(st, selected_stations, start_time, duration)
+        waveform_plot = plot_waveform(st, selected_stations, first_pick, duration)
 
         # 4. 創建輸入測站地圖
-        station_map = create_input_station_map(selected_stations, epicenter_lat, epicenter_lon)
+        station_map = create_input_station_map(
+            selected_stations, epicenter_lat, epicenter_lon
+        )
 
         logger.info("波形載入完成")
         return station_map, waveform_plot, gr.update(interactive=True)
@@ -1089,11 +855,12 @@ def load_and_display_waveform(event_name, start_time, duration):
     except Exception as e:
         logger.error(f"波形載入發生錯誤: {e}")
         import traceback
+
         traceback.print_exc()
         return None, None, gr.update(interactive=False)
 
 
-def predict_intensity(event_name, start_time, duration):
+def predict_intensity(event_name, duration):
     """
     執行震度預測
 
@@ -1105,27 +872,33 @@ def predict_intensity(event_name, start_time, duration):
     """
     try:
         # 從全域 earthquake_metadata 讀取震央座標
-        epicenter_lat, epicenter_lon = _get_epicenter_coords(event_name)
+        epicenter_lat = earthquake_metadata[event_name]["epicenter_lat"]
+        epicenter_lon = earthquake_metadata[event_name]["epicenter_lon"]
+        mseed_file = earthquake_metadata[event_name]["mseed_file"]
 
-        # 計算結束時間（內部處理）
-        end_time = start_time + duration
 
         # 1. 載入完整的 mseed 檔案
         logger.info(f"載入地震事件: {event_name}")
-        st = load_waveform(event_name)
+        st = read(mseed_file)
         logger.info(f"載入了 {len(st)} 個 trace")
 
         # 2. 根據震央距離選擇最近的 25 個測站
         logger.info(f"選擇距離震央 ({epicenter_lat}, {epicenter_lon}) 最近的測站...")
-        selected_stations = select_nearest_stations(st, epicenter_lat, epicenter_lon, n_stations=25)
+        selected_stations = select_nearest_stations(
+            st, epicenter_lat, epicenter_lon, n_stations=25
+        )
 
         if len(selected_stations) == 0:
             return None, None, "錯誤：找不到有效的測站資料"
 
         # 3. 從選定的測站提取波形（vs30_input 使用預設值 600，會被資料庫值覆蓋）
-        logger.info(f"提取波形資料（時間範圍: {start_time} 秒起，持續 {duration} 秒）...")
-        waveforms, station_info_list, valid_stations, missing_components_count = extract_waveforms_from_stream(
-            st, selected_stations, start_time, duration, vs30_input=600
+        logger.info(
+            f"提取波形資料（時間範圍: 初動後 {duration} 秒）..."
+        )
+        waveforms, station_info_list, valid_stations, missing_components_count = (
+            extract_waveforms_from_stream(
+                event_name, st, selected_stations, duration, vs30_input=600
+            )
         )
 
         if len(waveforms) == 0:
@@ -1149,25 +922,33 @@ def predict_intensity(event_name, start_time, duration):
         total_targets = len(target_dict)
         num_batches = (total_targets + batch_size - 1) // batch_size
 
-        logger.info(f"開始分批預測 {total_targets} 個目標測站（共 {num_batches} 批）...")
+        logger.info(
+            f"開始分批預測 {total_targets} 個目標測站（共 {num_batches} 批）..."
+        )
 
         for batch_idx in range(num_batches):
             start_idx = batch_idx * batch_size
             end_idx = min((batch_idx + 1) * batch_size, total_targets)
             batch_targets = target_dict[start_idx:end_idx]
 
-            logger.info(f"預測第 {batch_idx + 1}/{num_batches} 批（測站 {start_idx + 1}-{end_idx}）...")
+            logger.info(
+                f"預測第 {batch_idx + 1}/{num_batches} 批（測站 {start_idx + 1}-{end_idx}）..."
+            )
 
             # 準備這批目標測站資訊
             target_list = []
             target_names = []
             for target in batch_targets:
-                target_list.append([
-                    target["latitude"],
-                    target["longitude"],
-                    target["elevation"],
-                    get_vs30(target["latitude"], target["longitude"], user_vs30=600)
-                ])
+                target_list.append(
+                    [
+                        target["latitude"],
+                        target["longitude"],
+                        target["elevation"],
+                        get_vs30(
+                            target["latitude"], target["longitude"], user_vs30=600
+                        ),
+                    ]
+                )
                 target_names.append(target["station"])
 
             # Padding 到 25 個（如果不足 25 個）
@@ -1185,10 +966,17 @@ def predict_intensity(event_name, start_time, duration):
             # 7. 執行預測
             with torch.no_grad():
                 weight, sigma, mu = model(tensor_data)
-                batch_pga = torch.sum(weight * mu, dim=2).cpu().detach().numpy().flatten().tolist()
+                batch_pga = (
+                    torch.sum(weight * mu, dim=2)
+                    .cpu()
+                    .detach()
+                    .numpy()
+                    .flatten()
+                    .tolist()
+                )
 
             # 只取實際有資料的部分
-            all_pga_list.extend(batch_pga[:len(target_names)])
+            all_pga_list.extend(batch_pga[: len(target_names)])
             all_target_names.extend(target_names)
 
         logger.info(f"完成所有 {len(all_target_names)} 個測站的預測！")
@@ -1196,7 +984,9 @@ def predict_intensity(event_name, start_time, duration):
         target_names = all_target_names
 
         # 繪製互動式地圖（固定高度 800）
-        intensity_map = create_intensity_map(pga_list, target_names, epicenter_lat, epicenter_lon)
+        intensity_map = create_intensity_map(
+            pga_list, target_names, epicenter_lat, epicenter_lon
+        )
 
         # 載入實際觀測震度圖（filepath；左側以 800 高顯示）
         observed_intensity_path = load_observed_intensity_image(event_name)
@@ -1207,11 +997,12 @@ def predict_intensity(event_name, start_time, duration):
     except Exception as e:
         logger.error(f"預測過程發生錯誤: {e}")
         import traceback
+
         traceback.print_exc()
         return None, None
 
 
-def on_full_workflow(event_name, start_time, duration):
+def on_full_workflow(event_name,  duration):
     """
     執行完整的工作流：波形載入 → 測站選擇 → 推論 → 結果展示
 
@@ -1229,7 +1020,7 @@ def on_full_workflow(event_name, start_time, duration):
         # 步驟 1: 載入波形
         logger.info(f"[on_full_workflow] 步驟 1/3: 波形載入...")
         station_map, waveform_plot, _ = load_and_display_waveform(
-            event_name, start_time, duration
+            event_name, duration
         )
 
         if station_map is None:
@@ -1239,7 +1030,7 @@ def on_full_workflow(event_name, start_time, duration):
         # 步驟 2: 執行推論
         logger.info(f"[on_full_workflow] 步驟 2/3: 模型推論...")
         observed_img, predicted_map = predict_intensity(
-            event_name, start_time, duration
+            event_name, duration
         )
 
         if predicted_map is None:
@@ -1253,12 +1044,11 @@ def on_full_workflow(event_name, start_time, duration):
     except Exception as e:
         logger.error(f"[on_full_workflow] 完整工作流發生錯誤: {e}")
         import traceback
+
         traceback.print_exc()
         return None, None, f"錯誤: {str(e)}", None, f"錯誤: {str(e)}", None
 
-
 # ============ Gradio 介面 ============
-
 with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
     gr.Markdown("# 🌏 TTSAM 震度預測系統")
 
@@ -1267,19 +1057,21 @@ with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
         # 左上：使用步驟與狀態顯示
         with gr.Column(scale=1):
             gr.Markdown("## 使用步驟")
-            gr.Markdown("""
+            gr.Markdown(
+                """
                 1. 選擇地震事件和時間範圍
                 2. 輸入震央位置和場址參數
                 3. 點擊載入波形確認波形範圍
                 4. 確認無誤後點擊執行預測
                 
                 系統會自動選擇距離震央最近的 25 個測站
-            """)
+            """
+            )
         with gr.Column(scale=1):
             event_dropdown = gr.Dropdown(
-                choices=list(EARTHQUAKE_EVENTS.keys()),
-                value=list(EARTHQUAKE_EVENTS.keys())[0],
-                label="選擇地震事件"
+                choices=list(earthquake_metadata.keys()),
+                value=list(earthquake_metadata.keys())[0],
+                label="選擇地震事件",
             )
     # ========== 中層：輸入測站地圖與波形圖 ==========
     with gr.Row():
@@ -1288,8 +1080,9 @@ with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
             gr.Markdown("## 輸入測站分布")
             input_station_map = gr.Plot(label="輸入測站地圖")
             load_waveform_btn = gr.Button("📊 載入波形", variant="secondary", scale=1)
-            predict_btn = gr.Button("🔮 執行預測", variant="primary", scale=1,
-                                    interactive=False)
+            predict_btn = gr.Button(
+                "🔮 執行預測", variant="primary", scale=1, interactive=False
+            )
 
         # 中右：輸入波形
         with gr.Column(scale=1):
@@ -1298,9 +1091,9 @@ with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
                 label="地震波形（選定的 25 個測站）",
             )
             with gr.Row():
-                start_slider = gr.Slider(0, 300, value=0, step=1, label="開始時間 (秒)")
-                duration_slider = gr.Slider(0, 30, value=30, step=1, label="時間長度 (秒)")
-
+                duration_slider = gr.Slider(
+                    2, 15, value=15, step=1, label="P 波後時間 (秒)"
+                )
 
     # ========== 下層：實際觀測 vs 預測結果 ==========
     with gr.Row():
@@ -1309,7 +1102,6 @@ with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
             gr.Markdown("## 預測震度分布")
             predicted_intensity_map = gr.Plot(label="互動式震度地圖")
 
-
         # 右下：實際觀測震度圖
         with gr.Column(scale=1):
             gr.Markdown("## 實際觀測震度分布")
@@ -1317,37 +1109,47 @@ with gr.Blocks(title="TTSAM 震度預測系統", fill_height=True) as demo:
                 label="實際觀測震度",
                 type="filepath",
                 height=800,
-                value=load_observed_intensity_image(list(EARTHQUAKE_EVENTS.keys())[0])
+                value=load_observed_intensity_image(list(earthquake_metadata.keys())[0]),
             )
 
     # 綁定事件
     event_dropdown.change(
-        fn=lambda event_name, start_time, duration: (
-            *on_full_workflow(event_name, start_time, duration),
+        fn=lambda event_name,  duration: (
+            *on_full_workflow(event_name,  duration),
         ),
-        inputs=[event_dropdown, start_slider, duration_slider],
-        outputs=[input_station_map, waveform_plot, predicted_intensity_map, observed_intensity_image]
+        inputs=[event_dropdown, duration_slider],
+        outputs=[
+            input_station_map,
+            waveform_plot,
+            predicted_intensity_map,
+            observed_intensity_image,
+        ],
     )
 
     load_waveform_btn.click(
         fn=load_and_display_waveform,
-        inputs=[event_dropdown, start_slider, duration_slider],
-        outputs=[input_station_map, waveform_plot, predict_btn]
+        inputs=[event_dropdown, duration_slider],
+        outputs=[input_station_map, waveform_plot, predict_btn],
     )
 
     predict_btn.click(
         fn=predict_intensity,
-        inputs=[event_dropdown, start_slider, duration_slider],
-        outputs=[observed_intensity_image, predicted_intensity_map]
+        inputs=[event_dropdown, duration_slider],
+        outputs=[observed_intensity_image, predicted_intensity_map],
     )
 
     # 應用啟動時自動執行完整工作流
     demo.load(
-        fn=lambda event_name, start_time, duration: (
-            *on_full_workflow(event_name, start_time, duration),
+        fn=lambda event_name, duration: (
+            *on_full_workflow(event_name, duration),
         ),
-        inputs=[event_dropdown, start_slider, duration_slider],
-        outputs=[input_station_map, waveform_plot, predicted_intensity_map, observed_intensity_image]
+        inputs=[event_dropdown, duration_slider],
+        outputs=[
+            input_station_map,
+            waveform_plot,
+            predicted_intensity_map,
+            observed_intensity_image,
+        ],
     )
 
 demo.launch()

waveform/20211024.mseed

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c02a7754ae0ad6a45a5a5bef3220220e47bd4b867be89d34b5df94cf33862a8
+size 11558912

waveform/20220918.mseed

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c4683e99abd8e69f7fc6d8f16aa7c7da3de7522320bbb3483930c16415ee90b
+size 17133568

waveform/20240403.mseed

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2706992997b8eb30e568c3470e6f1d8c99654b8a4b1a12b33099fe91900cd51a
-size 37216256
+oid sha256:6e8beedc2a60382dd657ca588271db0f6808d45fbd7e4704ff2c09ef76f0e6f0
+size 22388736

waveform/20250120.mseed

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:199bae2e8477f06ea53d085dc3573407a6f8e50b4c798edd999751340d61d4e7
+size 20357120

waveform/event.json

@@ -1,16 +1,52 @@
 {
   "events": [
     {
-      "event_id": "20240403",
-      "event_name": "0403花蓮地震 (2024)",
-      "epicenter_lat": 23.88,
-      "epicenter_lon": 121.57,
-      "depth_km": 25.0,
-      "magnitude": 7.2,
-      "timestamp": "2024-04-03T07:58:00Z",
+      "event_id": "20211024051134",
+      "event_name": "1024 宜蘭外海地震 (2021)",
+      "timestamp": "2021-10-24T05:11:34Z",
+      "first_pick": 11.15,
+      "mseed_file": "waveform/20211024.mseed",
+      "intensity_map_file": "intensity_map/2021102413113465103_H.png",
+      "epicenter_lat": 24.53,
+      "epicenter_lon": 121.79,
+      "depth_km": 66.8,
+      "magnitude": 6.5
+    },
+    {
+      "event_id": "20220918064415",
+      "event_name": "0918 池上地震 (2022)",
+      "timestamp": "2022-09-18T06:44:15Z",
+      "first_pick": 2.0,
+      "mseed_file": "waveform/20220918.mseed",
+      "intensity_map_file": "intensity_map/2022091814441568111_H.png",
+      "epicenter_lat": 23.14,
+      "epicenter_lon": 121.2,
+      "depth_km": 7.0,
+      "magnitude": 6.8
+    },
+    {
+      "event_id": "20240402235809",
+      "event_name": "0403 花蓮地震 (2024)",
+      "timestamp": "2024-04-02T23:58:09Z",
+      "first_pick": 5.3,
       "mseed_file": "waveform/20240403.mseed",
-      "intensity_map_file": "intensity_map/20240403.png"
+      "intensity_map_file": "intensity_map/2024040307580972019_H.png",
+      "epicenter_lat": 23.77,
+      "epicenter_lon": 121.67,
+      "depth_km": 15.5,
+      "magnitude": 7.2
+    },
+    {
+      "event_id": "20250120161727",
+      "event_name": "0120 大埔地震 (2025)",
+      "timestamp": "2025-01-20T16:17:27Z",
+      "first_pick": 3.55,
+      "mseed_file": "waveform/20250120.mseed",
+      "intensity_map_file": "intensity_map/2025012100172764007_H.png",
+      "epicenter_lat": 23.23,
+      "epicenter_lon": 120.57,
+      "depth_km": 9.7,
+      "magnitude": 6.4
     }
   ]
 }
-