Gradio_app.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on local URL:  http://127.0.0.1:7901\n",
      "\n",
      "To create a public link, set `share=True` in `launch()`.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div><iframe src=\"http://127.0.0.1:7901/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": []
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gradio app that takes seismic waveform as input and marks 2 phases on the waveform as output.\n",
    "\n",
    "import gradio as gr\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from phasehunter.data_preparation import prepare_waveform\n",
    "import torch\n",
    "import io\n",
    "\n",
    "from scipy.stats import gaussian_kde\n",
    "from bmi_topography import Topography\n",
    "import earthpy.spatial as es\n",
    "\n",
    "import obspy\n",
    "from obspy.clients.fdsn import Client\n",
    "from obspy.clients.fdsn.header import FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException\n",
    "from obspy.geodetics.base import locations2degrees\n",
    "from obspy.taup import TauPyModel\n",
    "from obspy.taup.helper_classes import SlownessModelError\n",
    "\n",
    "from obspy.clients.fdsn.header import URL_MAPPINGS\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.dates as mdates\n",
    "from mpl_toolkits.axes_grid1 import ImageGrid\n",
    "\n",
    "from glob import glob\n",
    "\n",
    "def make_prediction(waveform):\n",
    "    waveform = np.load(waveform)\n",
    "    processed_input = prepare_waveform(waveform)\n",
    "    \n",
    "    # Make prediction\n",
    "    with torch.inference_mode():\n",
    "        output = model(processed_input)\n",
    "\n",
    "    p_phase = output[:, 0]\n",
    "    s_phase = output[:, 1]\n",
    "\n",
    "    return processed_input, p_phase, s_phase\n",
    "\n",
    "def mark_phases(waveform, uploaded_file):\n",
    "\n",
    "    if uploaded_file is not None:\n",
    "        waveform = uploaded_file.name\n",
    "\n",
    "    processed_input, p_phase, s_phase = make_prediction(waveform)\n",
    "\n",
    "    # Create a plot of the waveform with the phases marked\n",
    "    if sum(processed_input[0][2] == 0): #if input is 1C\n",
    "        fig, ax = plt.subplots(nrows=2, figsize=(10, 2), sharex=True)\n",
    "\n",
    "        ax[0].plot(processed_input[0][0], color='black', lw=1)\n",
    "        ax[0].set_ylabel('Norm. Ampl.')\n",
    "\n",
    "    else: #if input is 3C\n",
    "        fig, ax = plt.subplots(nrows=4, figsize=(10, 6), sharex=True)\n",
    "        ax[0].plot(processed_input[0][0], color='black', lw=1)\n",
    "        ax[1].plot(processed_input[0][1], color='black', lw=1)\n",
    "        ax[2].plot(processed_input[0][2], color='black', lw=1)\n",
    "\n",
    "        ax[0].set_ylabel('Z')\n",
    "        ax[1].set_ylabel('N')\n",
    "        ax[2].set_ylabel('E')\n",
    "\n",
    "    p_phase_plot = p_phase*processed_input.shape[-1]\n",
    "    p_kde = gaussian_kde(p_phase_plot)\n",
    "    p_dist_space = np.linspace( min(p_phase_plot)-10, max(p_phase_plot)+10, 500 )\n",
    "    ax[-1].plot( p_dist_space, p_kde(p_dist_space), color='r')\n",
    "\n",
    "    s_phase_plot = s_phase*processed_input.shape[-1]\n",
    "    s_kde = gaussian_kde(s_phase_plot)\n",
    "    s_dist_space = np.linspace( min(s_phase_plot)-10, max(s_phase_plot)+10, 500 )\n",
    "    ax[-1].plot( s_dist_space, s_kde(s_dist_space), color='b')\n",
    "\n",
    "    for a in ax:\n",
    "        a.axvline(p_phase.mean()*processed_input.shape[-1], color='r', linestyle='--', label='P')\n",
    "        a.axvline(s_phase.mean()*processed_input.shape[-1], color='b', linestyle='--', label='S')\n",
    "\n",
    "    ax[-1].set_xlabel('Time, samples')\n",
    "    ax[-1].set_ylabel('Uncert., samples')\n",
    "    ax[-1].legend()\n",
    "\n",
    "    plt.subplots_adjust(hspace=0., wspace=0.)\n",
    "\n",
    "    # Convert the plot to an image and return it\n",
    "    fig.canvas.draw()\n",
    "    image = np.array(fig.canvas.renderer.buffer_rgba())\n",
    "    plt.close(fig)\n",
    "    return image\n",
    "\n",
    "def bin_distances(distances, bin_size=10):\n",
    "    # Bin the distances into groups of `bin_size` kilometers\n",
    "    binned_distances = {}\n",
    "    for i, distance in enumerate(distances):\n",
    "        bin_index = distance // bin_size\n",
    "        if bin_index not in binned_distances:\n",
    "            binned_distances[bin_index] = (distance, i)\n",
    "        elif i < binned_distances[bin_index][1]:\n",
    "            binned_distances[bin_index] = (distance, i)\n",
    "\n",
    "    # Select the first distance in each bin and its index\n",
    "    first_distances = []\n",
    "    for bin_index in binned_distances:\n",
    "        first_distance, first_distance_index = binned_distances[bin_index]\n",
    "        first_distances.append(first_distance_index)\n",
    "    \n",
    "    return first_distances\n",
    "\n",
    "def variance_coefficient(residuals):\n",
    "    # calculate the variance of the residuals\n",
    "    var = residuals.var()\n",
    "    # scale the variance to a coefficient between 0 and 1\n",
    "    coeff = 1 - (var / (residuals.max() - residuals.min()))\n",
    "    return coeff\n",
    "\n",
    "def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model, max_waveforms, conf_thres_P, conf_thres_S):\n",
    "    distances, t0s, st_lats, st_lons, waveforms, names = [], [], [], [], [], []\n",
    "    \n",
    "    taup_model = TauPyModel(model=velocity_model)\n",
    "    client = Client(client_name)\n",
    "\n",
    "    window = radius_km / 111.2\n",
    "    max_waveforms = int(max_waveforms)\n",
    "\n",
    "    assert eq_lat - window > -90 and eq_lat + window < 90, \"Latitude out of bounds\"\n",
    "    assert eq_lon - window > -180 and eq_lon + window < 180, \"Longitude out of bounds\"\n",
    "\n",
    "    starttime = obspy.UTCDateTime(timestamp)\n",
    "    endtime = starttime + 120\n",
    "\n",
    "    try:\n",
    "        print('Starting to download inventory')\n",
    "        inv = client.get_stations(network=\"*\", station=\"*\", location=\"*\", channel=\"*H*\", \n",
    "                            starttime=starttime, endtime=endtime, \n",
    "                            minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),\n",
    "                            minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), \n",
    "                            level='station')\n",
    "        print('Finished downloading inventory')\n",
    "        \n",
    "    except (IndexError, FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException):\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.text(0.5,0.5,'Something is wrong with the data provider, try another')\n",
    "        fig.canvas.draw();\n",
    "        image = np.array(fig.canvas.renderer.buffer_rgba())\n",
    "        plt.close(fig)\n",
    "        return image\n",
    "    \n",
    "    waveforms = []\n",
    "    cached_waveforms = glob(\"data/cached/*.mseed\")\n",
    "\n",
    "    for network in inv:\n",
    "        if network.code == 'SY':\n",
    "            continue\n",
    "        for station in network:\n",
    "            print(f\"Processing {network.code}.{station.code}...\")\n",
    "            distance = locations2degrees(eq_lat, eq_lon, station.latitude, station.longitude)\n",
    "\n",
    "            arrivals = taup_model.get_travel_times(source_depth_in_km=source_depth_km, \n",
    "                                                    distance_in_degree=distance, \n",
    "                                                    phase_list=[\"P\", \"S\"])\n",
    "\n",
    "            if len(arrivals) > 0:\n",
    "\n",
    "                starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15\n",
    "                endtime = starttime + 60\n",
    "                try:\n",
    "                    filename=f'{network.code}_{station.code}_{starttime}'\n",
    "                    if f\"data/cached/{filename}.mseed\" not in cached_waveforms:\n",
    "                        print(f'Downloading waveform for {filename}')\n",
    "                        waveform = client.get_waveforms(network=network.code, station=station.code, location=\"*\", channel=\"*\", \n",
    "                                                    starttime=starttime, endtime=endtime)\n",
    "                        waveform.write(f\"data/cached/{network.code}_{station.code}_{starttime}.mseed\", format=\"MSEED\")\n",
    "                        print('Finished downloading and caching waveform')\n",
    "                    else:\n",
    "                        print('Reading cached waveform')\n",
    "                        waveform = obspy.read(f\"data/cached/{network.code}_{station.code}_{starttime}.mseed\")\n",
    "                        \n",
    "\n",
    "                except (IndexError, FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException):\n",
    "                    print(f'Skipping {network.code}_{station.code}_{starttime}')\n",
    "                    continue\n",
    "            \n",
    "                waveform = waveform.select(channel=\"H[BH][ZNE]\")\n",
    "                waveform = waveform.merge(fill_value=0)\n",
    "                waveform = waveform[:3].sort(keys=['channel'], reverse=True)\n",
    "\n",
    "                len_check = [len(x.data) for x in waveform]\n",
    "                if len(set(len_check)) > 1:\n",
    "                    continue\n",
    "\n",
    "                if len(waveform) == 3:\n",
    "                    try:\n",
    "                        waveform = prepare_waveform(np.stack([x.data for x in waveform]))\n",
    "\n",
    "                        distances.append(distance)\n",
    "                        t0s.append(starttime)\n",
    "                        st_lats.append(station.latitude)\n",
    "                        st_lons.append(station.longitude)\n",
    "                        waveforms.append(waveform)\n",
    "                        names.append(f\"{network.code}.{station.code}\")\n",
    "\n",
    "                        print(f\"Added {network.code}.{station.code} to the list of waveforms\")\n",
    "\n",
    "                    except:\n",
    "                        continue\n",
    "                \n",
    "    \n",
    "    # If there are no waveforms, return an empty plot\n",
    "    if len(waveforms) == 0:\n",
    "        print('No waveforms found')\n",
    "        fig, ax = plt.subplots()\n",
    "        ax.text(0.5,0.5,'No waveforms found')\n",
    "        fig.canvas.draw();\n",
    "        image = np.array(fig.canvas.renderer.buffer_rgba())\n",
    "        plt.close(fig)\n",
    "        output_picks = pd.DataFrame()\n",
    "        output_picks.to_csv('data/picks.csv', index=False)\n",
    "        output_csv = 'data/picks.csv'\n",
    "        return image, output_picks, output_csv\n",
    "    \n",
    "\n",
    "    first_distances = bin_distances(distances, bin_size=10/111.2)\n",
    "\n",
    "    # Edge case when there are way too many waveforms to process\n",
    "    selection_indexes = np.random.choice(first_distances, \n",
    "                                         np.min([len(first_distances), max_waveforms]),\n",
    "                                         replace=False)\n",
    "\n",
    "    waveforms = np.array(waveforms)[selection_indexes]\n",
    "    distances = np.array(distances)[selection_indexes]\n",
    "    t0s = np.array(t0s)[selection_indexes]\n",
    "    st_lats = np.array(st_lats)[selection_indexes]\n",
    "    st_lons = np.array(st_lons)[selection_indexes]\n",
    "    names = np.array(names)[selection_indexes]\n",
    "\n",
    "    waveforms = [torch.tensor(waveform) for waveform in waveforms]\n",
    "\n",
    "    print('Starting to run predictions')\n",
    "    with torch.no_grad():\n",
    "        waveforms_torch = torch.vstack(waveforms)\n",
    "        output = model(waveforms_torch)\n",
    "\n",
    "    p_phases = output[:, 0]\n",
    "    s_phases = output[:, 1]\n",
    "\n",
    "    p_phases = p_phases.reshape(len(waveforms),-1)\n",
    "    s_phases = s_phases.reshape(len(waveforms),-1)\n",
    "\n",
    "    # Max confidence - min variance    \n",
    "    p_max_confidence = p_phases.std(axis=-1).min()\n",
    "    s_max_confidence = s_phases.std(axis=-1).min()\n",
    "\n",
    "    print(f\"Starting plotting {len(waveforms)} waveforms\")\n",
    "    fig, ax = plt.subplots(ncols=3, figsize=(10, 3))\n",
    "    \n",
    "    # Plot topography\n",
    "    print('Fetching topography')\n",
    "    params = Topography.DEFAULT.copy()\n",
    "    extra_window = 0.5\n",
    "    params[\"south\"] = np.min([st_lats.min(), eq_lat])-extra_window\n",
    "    params[\"north\"] = np.max([st_lats.max(), eq_lat])+extra_window\n",
    "    params[\"west\"] = np.min([st_lons.min(), eq_lon])-extra_window\n",
    "    params[\"east\"] = np.max([st_lons.max(), eq_lon])+extra_window\n",
    "\n",
    "    topo_map = Topography(**params)\n",
    "    topo_map.fetch()\n",
    "    topo_map.load()\n",
    "\n",
    "    print('Plotting topo')\n",
    "    hillshade = es.hillshade(topo_map.da[0], altitude=10)\n",
    "    \n",
    "    topo_map.da.plot(ax = ax[1], cmap='Greys', add_colorbar=False, add_labels=False)\n",
    "    topo_map.da.plot(ax = ax[2], cmap='Greys', add_colorbar=False, add_labels=False)\n",
    "    ax[1].imshow(hillshade, cmap=\"Greys\", alpha=0.5)\n",
    "\n",
    "    output_picks = pd.DataFrame({'station_name' : [], \n",
    "                                'st_lat' : [], 'st_lon' : [],\n",
    "                                 'starttime' : [], \n",
    "                                 'p_phase, s' : [], 'p_uncertainty, s' : [], \n",
    "                                 's_phase, s' : [], 's_uncertainty, s' : [],\n",
    "                                 'velocity_p, km/s' : [], 'velocity_s, km/s' : []})\n",
    "                        \n",
    "    for i in range(len(waveforms)):\n",
    "        print(f\"Plotting waveform {i+1}/{len(waveforms)}\")\n",
    "        current_P = p_phases[i]\n",
    "        current_S = s_phases[i]\n",
    "        \n",
    "        x = [t0s[i] + pd.Timedelta(seconds=k/100) for k in np.linspace(0,6000,6000)]\n",
    "        x = mdates.date2num(x)\n",
    "\n",
    "        # Normalize confidence for the plot\n",
    "        p_conf = 1/(current_P.std()/p_max_confidence).item()\n",
    "        s_conf = 1/(current_S.std()/s_max_confidence).item()\n",
    "\n",
    "        delta_t = t0s[i].timestamp - obspy.UTCDateTime(timestamp).timestamp\n",
    "\n",
    "        ax[0].plot(x, waveforms[i][0, 0]*10+distances[i]*111.2, color='black', alpha=0.5, lw=1)\n",
    "\n",
    "        if (current_P.std().item()*60 < conf_thres_P) or (current_S.std().item()*60 < conf_thres_S):\n",
    "            ax[0].scatter(x[int(current_P.mean()*waveforms[i][0].shape[-1])], waveforms[i][0, 0].mean()+distances[i]*111.2, color='r', alpha=p_conf, marker='|')\n",
    "            ax[0].scatter(x[int(current_S.mean()*waveforms[i][0].shape[-1])], waveforms[i][0, 0].mean()+distances[i]*111.2, color='b', alpha=s_conf, marker='|')\n",
    "        \n",
    "            velocity_p = (distances[i]*111.2)/(delta_t+current_P.mean()*60).item()\n",
    "            velocity_s = (distances[i]*111.2)/(delta_t+current_S.mean()*60).item()\n",
    "\n",
    "            # Generate an array from st_lat to eq_lat and from st_lon to eq_lon\n",
    "            x = np.linspace(st_lons[i], eq_lon, 50)\n",
    "            y = np.linspace(st_lats[i], eq_lat, 50)\n",
    "            \n",
    "            # Plot the array\n",
    "            ax[1].scatter(x, y, c=np.zeros_like(x)+velocity_p, alpha=0.1, vmin=0, vmax=8)\n",
    "            ax[2].scatter(x, y, c=np.zeros_like(x)+velocity_s, alpha=0.1, vmin=0, vmax=8)\n",
    "\n",
    "        else:\n",
    "            velocity_p = np.nan\n",
    "            velocity_s = np.nan\n",
    "        \n",
    "        ax[0].set_ylabel('Z')\n",
    "        print(f\"Station {st_lats[i]}, {st_lons[i]} has P velocity {velocity_p} and S velocity {velocity_s}\")\n",
    "\n",
    "        output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], \n",
    "                                                        'st_lat' : [st_lats[i]], 'st_lon' : [st_lons[i]],\n",
    "                                                        'starttime' : [str(t0s[i])], \n",
    "                                                        'p_phase, s' : [(delta_t+current_P.mean()*60).item()], 'p_uncertainty, s' : [current_P.std().item()*60], \n",
    "                                                        's_phase, s' : [(delta_t+current_S.mean()*60).item()], 's_uncertainty, s' : [current_S.std().item()*60],\n",
    "                                                        'velocity_p, km/s' : [velocity_p], 'velocity_s, km/s' : [velocity_s]}))\n",
    "        \n",
    "        \n",
    "    # Add legend\n",
    "    ax[0].scatter(None, None, color='r', marker='|', label='P')\n",
    "    ax[0].scatter(None, None, color='b', marker='|', label='S')\n",
    "    ax[0].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
    "    ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=20))\n",
    "    ax[0].legend()\n",
    "\n",
    "    print('Plotting stations')\n",
    "    for i in range(1,3):\n",
    "        ax[i].scatter(st_lons, st_lats, color='b', label='Stations')\n",
    "        ax[i].scatter(eq_lon, eq_lat, color='r', marker='*', label='Earthquake')\n",
    "        ax[i].set_aspect('equal')\n",
    "        ax[i].set_xticklabels(ax[i].get_xticks(), rotation = 50)\n",
    "\n",
    "    fig.subplots_adjust(bottom=0.1, top=0.9, left=0.1, right=0.8,\n",
    "                    wspace=0.02, hspace=0.02)\n",
    "    \n",
    "    cb_ax = fig.add_axes([0.83, 0.1, 0.02, 0.8])\n",
    "    cbar = fig.colorbar(ax[2].scatter(None, None, c=velocity_p, alpha=0.5, vmin=0, vmax=8), cax=cb_ax)\n",
    "\n",
    "    cbar.set_label('Velocity (km/s)')\n",
    "    ax[1].set_title('P Velocity')\n",
    "    ax[2].set_title('S Velocity')\n",
    "\n",
    "    for a in ax:\n",
    "        a.tick_params(axis='both', which='major', labelsize=8)\n",
    "        \n",
    "    plt.subplots_adjust(hspace=0., wspace=0.5)\n",
    "    fig.canvas.draw();\n",
    "    image = np.array(fig.canvas.renderer.buffer_rgba())\n",
    "    plt.close(fig)\n",
    "    output_picks.to_csv(f'data/velocity/{eq_lat}_{eq_lon}_{timestamp}_{len(waveforms)}.csv', index=False)\n",
    "    output_csv = f'data/velocity/{eq_lat}_{eq_lon}_{timestamp}_{len(waveforms)}.csv'\n",
    "\n",
    "    return image, output_picks, output_csv\n",
    "\n",
    "model = torch.jit.load(\"model.pt\")\n",
    "\n",
    "with gr.Blocks() as demo:\n",
    "    gr.HTML(\"\"\"\n",
    "<div style=\"padding: 20px; border-radius: 10px;\">\n",
    "    <h1 style=\"font-size: 30px; text-align: center; margin-bottom: 20px;\">PhaseHunter <span style=\"animation: arrow-anim 10s linear infinite; display: inline-block; transform: rotate(45deg) translateX(-20px);\">🏹</span>\n",
    "\n",
    "<style>\n",
    "    @keyframes arrow-anim {\n",
    "        0% { transform: translateX(-20px); }\n",
    "        50% { transform: translateX(20px); }\n",
    "        100% { transform: translateX(-20px); }\n",
    "    }\n",
    "</style></h1> \n",
    "    \n",
    "    <p style=\"font-size: 16px; margin-bottom: 20px;\">Detect <span style=\"background-image: linear-gradient(to right, #ED213A, #93291E); \n",
    "    -webkit-background-clip: text;\n",
    "    -webkit-text-fill-color: transparent;\n",
    "    background-clip: text;\">P</span> and <span style=\"background-image: linear-gradient(to right, #00B4DB, #0083B0); \n",
    "    -webkit-background-clip: text;\n",
    "    -webkit-text-fill-color: transparent;\n",
    "    background-clip: text;\">S</span> seismic phases with <span style=\"background-image: linear-gradient(to right, #f12711, #f5af19); \n",
    "    -webkit-background-clip: text;\n",
    "    -webkit-text-fill-color: transparent;\n",
    "    background-clip: text;\">uncertainty</span></p>\n",
    "    <ul style=\"font-size: 16px; margin-bottom: 40px;\">\n",
    "        <li>Detect seismic phases by selecting a sample waveform or uploading your own waveform in <code>.npy</code> format.</li>\n",
    "        <li>Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.</li>\n",
    "        <li>Waveforms should be sampled at 100 samples/sec and have 3 (Z, N, E) or 1 (Z) channels. PhaseHunter analyzes the first 6000 samples of your file.</li>\n",
    "    </ul>\n",
    "</div>\n",
    "\"\"\")\n",
    "\n",
    "    with gr.Tab(\"Try on a single station\"):\n",
    "        with gr.Row(): \n",
    "            # Define the input and output types for Gradio\n",
    "            inputs = gr.Dropdown(\n",
    "                [\"data/sample/sample_0.npy\", \n",
    "                \"data/sample/sample_1.npy\", \n",
    "                \"data/sample/sample_2.npy\"], \n",
    "                label=\"Sample waveform\", \n",
    "                info=\"Select one of the samples\",\n",
    "                value = \"data/sample/sample_0.npy\"\n",
    "            )\n",
    "\n",
    "            upload = gr.File(label=\"Or upload your own waveform\")\n",
    "\n",
    "        button = gr.Button(\"Predict phases\")\n",
    "        outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)\n",
    "    \n",
    "        button.click(mark_phases, inputs=[inputs, upload], outputs=outputs)\n",
    "        \n",
    "    with gr.Tab(\"Select earthquake from catalogue\"):\n",
    "\n",
    "        gr.HTML(\"\"\"\n",
    "        <div style=\"padding: 20px; border-radius: 10px; font-size: 16px;\">\n",
    "        <p style=\"font-weight: bold; font-size: 24px; margin-bottom: 20px;\">Using PhaseHunter to Analyze Seismic Waveforms</p>\n",
    "        <p>Select an earthquake from the global earthquake catalogue (e.g. <a href=\"https://earthquake.usgs.gov/earthquakes/map\">USGS</a>) and the app will download the waveform from the FDSN client of your choice. The app will use a velocity model of your choice to select appropriate time windows for each station within a specified radius of the earthquake.</p>\n",
    "        <p>The app will then analyze the waveforms and mark the detected phases on the waveform. Pick data for each waveform is reported in seconds from the start of the waveform.</p>\n",
    "        <p>Velocities are derived from distance and travel time determined by PhaseHunter picks (<span style=\"font-style: italic;\">v = distance/predicted_pick_time</span>). The background of the velocity plot is colored by DEM.</p>\n",
    "        </div>\n",
    "        \"\"\")\n",
    "        with gr.Row(): \n",
    "            with gr.Column(scale=2):\n",
    "                client_inputs = gr.Dropdown(\n",
    "                    choices = list(URL_MAPPINGS.keys()), \n",
    "                    label=\"FDSN Client\", \n",
    "                    info=\"Select one of the available FDSN clients\",\n",
    "                    value = \"IRIS\",\n",
    "                    interactive=True\n",
    "                )\n",
    "\n",
    "                velocity_inputs = gr.Dropdown(\n",
    "                    choices = ['1066a', '1066b', 'ak135', \n",
    "                            'ak135f', 'herrin', 'iasp91', \n",
    "                            'jb', 'prem', 'pwdk'], \n",
    "                    label=\"1D velocity model\", \n",
    "                    info=\"Velocity model for station selection\",\n",
    "                    value = \"1066a\",\n",
    "                    interactive=True\n",
    "                )\n",
    "\n",
    "            with gr.Column(scale=2):\n",
    "                timestamp_inputs = gr.Textbox(value='2019-07-04 17:33:49',\n",
    "                                    placeholder='YYYY-MM-DD HH:MM:SS',\n",
    "                                    label=\"Timestamp\",\n",
    "                                    info=\"Timestamp of the earthquake\",\n",
    "                                    max_lines=1,\n",
    "                                    interactive=True)\n",
    "                \n",
    "                source_depth_inputs = gr.Number(value=10,\n",
    "                    label=\"Source depth (km)\",\n",
    "                    info=\"Depth of the earthquake\",\n",
    "                    interactive=True)\n",
    "                \n",
    "            with gr.Column(scale=2):\n",
    "                eq_lat_inputs = gr.Number(value=35.766, \n",
    "                                label=\"Latitude\", \n",
    "                                info=\"Latitude of the earthquake\",\n",
    "                                interactive=True)\n",
    "                \n",
    "                eq_lon_inputs = gr.Number(value=-117.605,\n",
    "                                    label=\"Longitude\",\n",
    "                                    info=\"Longitude of the earthquake\",\n",
    "                                    interactive=True)\n",
    "                \n",
    "            with gr.Column(scale=2):\n",
    "                radius_inputs = gr.Slider(minimum=1, \n",
    "                                        maximum=200, \n",
    "                                        value=50, \n",
    "                                        label=\"Radius (km)\", \n",
    "                                        step=10,\n",
    "                                        info=\"\"\"Select the radius around the earthquake to download data from.\\n \n",
    "                                        Note that the larger the radius, the longer the app will take to run.\"\"\",\n",
    "                                        interactive=True)\n",
    "                \n",
    "                max_waveforms_inputs = gr.Slider(minimum=1,\n",
    "                                maximum=100,\n",
    "                                value=10,\n",
    "                                label=\"Max waveforms per section\",\n",
    "                                step=1,\n",
    "                                info=\"Maximum number of waveforms to show per section\\n (to avoid long prediction times)\",\n",
    "                                interactive=True,\n",
    "                                )\n",
    "            with gr.Column(scale=2):\n",
    "                P_thres_inputs = gr.Slider(minimum=0.01,\n",
    "                                maximum=1,\n",
    "                                value=0.1,\n",
    "                                label=\"P uncertainty threshold, s\",\n",
    "                                step=0.01,\n",
    "                                info=\"Acceptable uncertainty for P picks expressed in std() seconds\",\n",
    "                                interactive=True,\n",
    "                                )\n",
    "                S_thres_inputs = gr.Slider(minimum=0.01,\n",
    "                                maximum=1,\n",
    "                                value=0.2,\n",
    "                                label=\"S uncertainty threshold, s\",\n",
    "                                step=0.01,\n",
    "                                info=\"Acceptable uncertainty for S picks expressed in std() seconds\",\n",
    "                                interactive=True,\n",
    "                                )\n",
    "            \n",
    "        button = gr.Button(\"Predict phases\")\n",
    "        output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n",
    "\n",
    "        with gr.Row():\n",
    "            output_picks = gr.Dataframe(label='Pick data', \n",
    "                                        type='pandas', \n",
    "                                        interactive=False)\n",
    "            output_csv = gr.File(label=\"Output File\", file_types=[\".csv\"])\n",
    "\n",
    "        button.click(predict_on_section, \n",
    "                 inputs=[client_inputs, timestamp_inputs, \n",
    "                         eq_lat_inputs, eq_lon_inputs, \n",
    "                         radius_inputs, source_depth_inputs, \n",
    "                         velocity_inputs, max_waveforms_inputs,\n",
    "                         P_thres_inputs, S_thres_inputs],\n",
    "                 outputs=[output_image, output_picks, output_csv])\n",
    "\n",
    "demo.launch()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "phasehunter",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "6bf57068982d7b420bddaaf1d0614a7795947176033057024cf47d8ca2c1c4cd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}