finished Alpha version

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.formatting.provider": "black"
+}

Gradio_app.ipynb

@@ -2,42 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'hi!'"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "'hi!'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/Users/anovosel/miniconda3/envs/phasehunter/lib/python3.11/site-packages/gradio/outputs.py:43: UserWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n",
-      "  warnings.warn(\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Running on local URL:  http://127.0.0.1:7862\n",
+      "Running on local URL:  http://127.0.0.1:7904\n",
       "\n",
       "To create a public link, set `share=True` in `launch()`.\n"
      ]
@@ -45,7 +17,7 @@
     {
      "data": {
       "text/html": [
-       "<div><iframe src=\"http://127.0.0.1:7862/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+       "<div><iframe src=\"http://127.0.0.1:7904/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -58,30 +30,9 @@
      "data": {
       "text/plain": []
      },
-     "execution_count": 4,
+     "execution_count": 64,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Error in callback <function _draw_all_if_interactive at 0x1774d0ea0> (for post_execute):\n"
-     ]
-    },
-    {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
-      "File \u001b[0;32m~/miniconda3/envs/phasehunter/lib/python3.11/site-packages/matplotlib/pyplot.py:120\u001b[0m, in \u001b[0;36m_draw_all_if_interactive\u001b[0;34m()\u001b[0m\n\u001b[1;32m    118\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_draw_all_if_interactive\u001b[39m():\n\u001b[1;32m    119\u001b[0m     \u001b[39mif\u001b[39;00m matplotlib\u001b[39m.\u001b[39mis_interactive():\n\u001b[0;32m--> 120\u001b[0m         draw_all()\n",
-      "File \u001b[0;32m~/miniconda3/envs/phasehunter/lib/python3.11/site-packages/matplotlib/_pylab_helpers.py:132\u001b[0m, in \u001b[0;36mGcf.draw_all\u001b[0;34m(cls, force)\u001b[0m\n\u001b[1;32m    130\u001b[0m \u001b[39mfor\u001b[39;00m manager \u001b[39min\u001b[39;00m \u001b[39mcls\u001b[39m\u001b[39m.\u001b[39mget_all_fig_managers():\n\u001b[1;32m    131\u001b[0m     \u001b[39mif\u001b[39;00m force \u001b[39mor\u001b[39;00m manager\u001b[39m.\u001b[39mcanvas\u001b[39m.\u001b[39mfigure\u001b[39m.\u001b[39mstale:\n\u001b[0;32m--> 132\u001b[0m         manager\u001b[39m.\u001b[39;49mcanvas\u001b[39m.\u001b[39;49mdraw_idle()\n",
-      "File \u001b[0;32m~/miniconda3/envs/phasehunter/lib/python3.11/site-packages/matplotlib/backend_bases.py:2082\u001b[0m, in \u001b[0;36mFigureCanvasBase.draw_idle\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2080\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_is_idle_drawing:\n\u001b[1;32m   2081\u001b[0m     \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_idle_draw_cntx():\n\u001b[0;32m-> 2082\u001b[0m         \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdraw(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n",
-      "File \u001b[0;32m~/miniconda3/envs/phasehunter/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:397\u001b[0m, in \u001b[0;36mFigureCanvasAgg.draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    395\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrenderer\u001b[39m.\u001b[39mclear()\n\u001b[1;32m    396\u001b[0m \u001b[39m# Acquire a lock on the shared font cache.\u001b[39;00m\n\u001b[0;32m--> 397\u001b[0m \u001b[39mwith\u001b[39;49;00m RendererAgg\u001b[39m.\u001b[39;49mlock, \\\n\u001b[1;32m    398\u001b[0m      (\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtoolbar\u001b[39m.\u001b[39;49m_wait_cursor_for_draw_cm() \u001b[39mif\u001b[39;49;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtoolbar\n\u001b[1;32m    399\u001b[0m       \u001b[39melse\u001b[39;49;00m nullcontext()):\n\u001b[1;32m    400\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfigure\u001b[39m.\u001b[39;49mdraw(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrenderer)\n\u001b[1;32m    401\u001b[0m     \u001b[39m# A GUI class may be need to update a window using this draw, so\u001b[39;49;00m\n\u001b[1;32m    402\u001b[0m     \u001b[39m# don't forget to call the superclass.\u001b[39;49;00m\n",
-      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
-     ]
     }
    ],
    "source": [
@@ -95,6 +46,8 @@
     "import torch\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",
@@ -107,6 +60,7 @@
     "\n",
     "import matplotlib.pyplot as plt\n",
     "import matplotlib.dates as mdates\n",
+    "from matplotlib.colors import LightSource\n",
     "\n",
     "from glob import glob\n",
     "\n",
@@ -123,21 +77,25 @@
     "\n",
     "    return processed_input, p_phase, s_phase\n",
     "\n",
-    "def mark_phases(waveform):\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])\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])\n",
-    "        ax[1].plot(processed_input[0][1])\n",
-    "        ax[2].plot(processed_input[0][2])\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",
@@ -169,22 +127,39 @@
     "    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",
-    "    \n",
     "    # scale the variance to a coefficient between 0 and 1\n",
     "    coeff = 1 - (var / (residuals.max() - residuals.min()))\n",
-    "    \n",
     "    return coeff\n",
     "\n",
-    "def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model):\n",
+    "def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model, max_waveforms):\n",
     "    distances, t0s, st_lats, st_lons, waveforms = [], [], [], [], []\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",
@@ -192,59 +167,107 @@
     "    starttime = obspy.UTCDateTime(timestamp)\n",
     "    endtime = starttime + 120\n",
     "\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",
+    "    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",
+    "    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",
+    "        # Skip the SYntetic networks\n",
+    "        if network.code == 'SY':\n",
+    "            continue\n",
     "        for station in network:\n",
-    "            try:\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",
+    "            print(f\"Processing {network.code}.{station.code}...\")\n",
+    "            distance = locations2degrees(eq_lat, eq_lon, station.latitude, station.longitude)\n",
     "\n",
-    "                if len(arrivals) > 0:\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",
-    "                    starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15\n",
-    "                    endtime = starttime + 60\n",
+    "            if len(arrivals) > 0:\n",
     "\n",
+    "                starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15\n",
+    "                endtime = starttime + 60\n",
+    "                try:\n",
     "                    if f\"data/cached/{network.code}_{station.code}_{starttime}.mseed\" not in cached_waveforms:\n",
+    "                        print('Downloading waveform')\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",
-    "                    waveform = waveform.select(channel=\"H[BH][ZNE]\")\n",
-    "                    waveform = waveform.merge(fill_value=0)\n",
-    "                    waveform = waveform[:3]\n",
-    "                    \n",
-    "                    len_check = [len(x.data) for x in waveform]\n",
-    "                    if len(set(len_check)) > 1:\n",
-    "                        continue\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]\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",
-    "                    if len(waveform) == 3:\n",
-    "                        try:\n",
-    "                            waveform = prepare_waveform(np.stack([x.data for x in waveform]))\n",
-    "                        except:\n",
-    "                            continue\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",
     "\n",
-    "            except (IndexError, FDSNNoDataException, FDSNTimeoutException):\n",
-    "                continue\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",
+    "        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",
+    "        return image\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",
     "\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",
@@ -256,8 +279,31 @@
     "    p_max_confidence = np.min([p_phases[i::len(waveforms)].std() for i in range(len(waveforms))]) \n",
     "    s_max_confidence = np.min([s_phases[i::len(waveforms)].std() for i in range(len(waveforms))])\n",
     "\n",
-    "    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 3), sharex=True)\n",
+    "    print(f\"Starting plotting {len(waveforms)} waveforms\")\n",
+    "    fig, ax = plt.subplots(nrows=1, 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",
     "    for i in range(len(waveforms)):\n",
+    "        print(f\"Plotting waveform {i+1}/{len(waveforms)}\")\n",
     "        current_P = p_phases[i::len(waveforms)]\n",
     "        current_S = s_phases[i::len(waveforms)]\n",
     "\n",
@@ -275,17 +321,46 @@
     "        ax[0].set_ylabel('Z')\n",
     "\n",
     "        ax[0].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
-    "        ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=5))\n",
+    "        ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=20))\n",
+    "\n",
+    "        delta_t = t0s[i].timestamp - obspy.UTCDateTime(timestamp).timestamp\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",
+    "        print(f\"Station {st_lats[i]}, {st_lons[i]} has P velocity {velocity_p} and S velocity {velocity_s}\")\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.5, vmin=0, vmax=8)\n",
+    "        ax[2].scatter(x, y, c=np.zeros_like(x)+velocity_s, alpha=0.5, vmin=0, vmax=8)\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].legend()\n",
     "\n",
-    "    ax[1].scatter(st_lats, st_lons, color='b', marker='d', label='Stations')\n",
-    "    ax[1].scatter(eq_lat, eq_lon, color='r', marker='*', label='Earthquake')\n",
-    "    ax[1].legend()\n",
-    "    plt.subplots_adjust(hspace=0., wspace=0.)\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",
+    "\n",
+    "    # Generate colorbar for the velocity plot\n",
+    "    cbar = plt.colorbar(ax[1].scatter(None, None, c=velocity_p, alpha=0.5, vmin=0, vmax=8), ax=ax[1])\n",
+    "    cbar.set_label('P Velocity (km/s)')\n",
+    "    ax[1].set_title('P Velocity')\n",
+    "\n",
+    "    cbar = plt.colorbar(ax[2].scatter(None, None, c=velocity_s, alpha=0.5, vmin=0, vmax=8), ax=ax[2])\n",
+    "    cbar.set_label('S Velocity (km/s)')\n",
+    "    ax[2].set_title('S Velocity')\n",
+    "\n",
+    "\n",
+    "\n",
+    "    plt.subplots_adjust(hspace=0., wspace=0.5)\n",
+    "\n",
     "    fig.canvas.draw();\n",
     "    image = np.array(fig.canvas.renderer.buffer_rgba())\n",
     "    plt.close(fig)\n",
@@ -299,30 +374,54 @@
     "model.eval()\n",
     "\n",
     "with gr.Blocks() as demo:\n",
-    "    gr.Markdown(\"# PhaseHunter\")\n",
-    "    gr.Markdown(\"\"\"This app allows one to detect P and S seismic phases along with uncertainty of the detection. \n",
-    "            The app can be used in three ways: either by selecting one of the sample waveforms;\n",
-    "                                                or by selecting an earthquake from the global earthquake catalogue;\n",
-    "                                                or by uploading a waveform of interest.\n",
+    "    gr.HTML(\"\"\"<h1>PhaseHunter</h1>\n",
+    "<p>This app allows one to detect <mark style=\"background-color: red; color: white;\">P</mark> and <mark style=\"background-color: blue; color: white;\">S</mark> seismic phases along with \n",
+    "\n",
+    "<span style=\"font-size: 24px; font-weight: bold;\">\n",
+    "  <span style=\"color: #4c4c4c; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;\">u</span>\n",
+    "  <span style=\"color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;\">n</span>\n",
+    "  <span style=\"color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;\">c</span>\n",
+    "  <span style=\"color: #d9d9d9; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;\">e</span>\n",
+    "  <span style=\"color: #f2f2f2; text-shadow: 1px 1px 0 #eee, -1px -1px 0 #eee, 1px -1px 0 #eee, -1px 1px 0 #eee;\">r</span>\n",
+    "  <span style=\"color: #d9d9d9; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;\">t</span>\n",
+    "  <span style=\"color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;\">a</span>\n",
+    "  <span style=\"color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;\">i</span>\n",
+    "  <span style=\"color: #4c4c4c; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;\">n</span>\n",
+    "  <span style=\"color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;\">t</span>\n",
+    "  <span style=\"color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;\">y</span>\n",
+    "  \n",
+    "</span>\n",
+    " of the detection.</p>\n",
+    "<ol>\n",
+    "  <li>By selecting one of the sample waveforms.</li>\n",
+    "  <li>By uploading your own waveform.</li>\n",
+    "  <li>By selecting an earthquake from the global earthquake catalogue.</li>\n",
+    "</ol>\n",
+    "<p>Please upload your waveform in <code>.npy</code> (numpy) format.</p>\n",
+    "<p>Your waveform should be sampled at 100 samples per second and have 3 (Z, N, E) or 1 (Z) channels. If your file is longer than 60 seconds, the app will only use the first 60 seconds of the waveform.</p>\n",
     "            \"\"\")\n",
-    "    with gr.Tab(\"Default example\"):\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",
+    "    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.outputs.Image(label='Waveform with Phases Marked', type='numpy')\n",
+    "        outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)\n",
     "    \n",
-    "        button.click(mark_phases, inputs=inputs, outputs=outputs)\n",
+    "        button.click(mark_phases, inputs=[inputs, upload], outputs=outputs)\n",
     "        \n",
     "    with gr.Tab(\"Select earthquake from catalogue\"):\n",
-    "        gr.Markdown('TEST')\n",
+    "        gr.Markdown(\"\"\"Select an earthquake from the global earthquake catalogue and the app will download the waveform from the FDSN client of your choice.\n",
+    "                       \"\"\")\n",
     "        \n",
     "        client_inputs = gr.Dropdown(\n",
     "            choices = list(URL_MAPPINGS.keys()), \n",
@@ -331,6 +430,7 @@
     "            value = \"IRIS\",\n",
     "            interactive=True\n",
     "        )\n",
+    "\n",
     "        with gr.Row(): \n",
     "\n",
     "            timestamp_inputs = gr.Textbox(value='2019-07-04 17:33:49',\n",
@@ -364,13 +464,23 @@
     "                                    interactive=True)\n",
     "            \n",
     "            velocity_inputs = gr.Dropdown(\n",
-    "                choices = ['1066a', '1066b', 'ak135', 'ak135f', 'herrin', 'iasp91', 'jb', 'prem', 'pwdk'], \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",
+    "\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",
     "            \n",
     "        button = gr.Button(\"Predict phases\")\n",
     "        outputs_section = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n",
@@ -378,15 +488,10 @@
     "        button.click(predict_on_section, \n",
     "                 inputs=[client_inputs, timestamp_inputs, \n",
     "                         eq_lat_inputs, eq_lon_inputs, \n",
-    "                         radius_inputs, source_depth_inputs, velocity_inputs],\n",
+    "                         radius_inputs, source_depth_inputs, \n",
+    "                         velocity_inputs, max_waveforms_inputs],\n",
     "                 outputs=outputs_section)\n",
     "\n",
-    "    with gr.Tab(\"Predict on your own waveform\"):\n",
-    "        gr.Markdown(\"\"\"\n",
-    "        Please upload your waveform in .npy (numpy) format. \n",
-    "        Your waveform should be sampled at 100 sps and have 3 (Z, N, E) or 1 (Z) channels.\n",
-    "        \"\"\")\n",
-    "\n",
     "demo.launch()"
    ]
   },

app.py

@@ -8,6 +8,8 @@ from phasehunter.data_preparation import prepare_waveform
 import torch
 
 from scipy.stats import gaussian_kde
+from bmi_topography import Topography
+import earthpy.spatial as es
 
 import obspy
 from obspy.clients.fdsn import Client
@@ -20,6 +22,7 @@ from obspy.clients.fdsn.header import URL_MAPPINGS
 
 import matplotlib.pyplot as plt
 import matplotlib.dates as mdates
+from matplotlib.colors import LightSource
 
 from glob import glob
 
@@ -36,21 +39,25 @@ def make_prediction(waveform):
 
     return processed_input, p_phase, s_phase
 
-def mark_phases(waveform):
+def mark_phases(waveform, uploaded_file):
+
+    if uploaded_file is not None:
+        waveform = uploaded_file.name
+
     processed_input, p_phase, s_phase = make_prediction(waveform)
 
     # Create a plot of the waveform with the phases marked
     if sum(processed_input[0][2] == 0): #if input is 1C
         fig, ax = plt.subplots(nrows=2, figsize=(10, 2), sharex=True)
 
-        ax[0].plot(processed_input[0][0])
+        ax[0].plot(processed_input[0][0], color='black', lw=1)
         ax[0].set_ylabel('Norm. Ampl.')
 
     else: #if input is 3C
         fig, ax = plt.subplots(nrows=4, figsize=(10, 6), sharex=True)
-        ax[0].plot(processed_input[0][0])
-        ax[1].plot(processed_input[0][1])
-        ax[2].plot(processed_input[0][2])
+        ax[0].plot(processed_input[0][0], color='black', lw=1)
+        ax[1].plot(processed_input[0][1], color='black', lw=1)
+        ax[2].plot(processed_input[0][2], color='black', lw=1)
 
         ax[0].set_ylabel('Z')
         ax[1].set_ylabel('N')
@@ -82,22 +89,39 @@ def mark_phases(waveform):
     plt.close(fig)
     return image
 
+def bin_distances(distances, bin_size=10):
+    # Bin the distances into groups of `bin_size` kilometers
+    binned_distances = {}
+    for i, distance in enumerate(distances):
+        bin_index = distance // bin_size
+        if bin_index not in binned_distances:
+            binned_distances[bin_index] = (distance, i)
+        elif i < binned_distances[bin_index][1]:
+            binned_distances[bin_index] = (distance, i)
+
+    # Select the first distance in each bin and its index
+    first_distances = []
+    for bin_index in binned_distances:
+        first_distance, first_distance_index = binned_distances[bin_index]
+        first_distances.append(first_distance_index)
+    
+    return first_distances
+
 def variance_coefficient(residuals):
     # calculate the variance of the residuals
     var = residuals.var()
-    
     # scale the variance to a coefficient between 0 and 1
     coeff = 1 - (var / (residuals.max() - residuals.min()))
-    
     return coeff
 
-def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model):
+def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model, max_waveforms):
     distances, t0s, st_lats, st_lons, waveforms = [], [], [], [], []
     
     taup_model = TauPyModel(model=velocity_model)
     client = Client(client_name)
 
     window = radius_km / 111.2
+    max_waveforms = int(max_waveforms)
 
     assert eq_lat - window > -90 and eq_lat + window < 90, "Latitude out of bounds"
     assert eq_lon - window > -180 and eq_lon + window < 180, "Longitude out of bounds"
@@ -105,59 +129,107 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     starttime = obspy.UTCDateTime(timestamp)
     endtime = starttime + 120
 
-    inv = client.get_stations(network="*", station="*", location="*", channel="*H*", 
-                          starttime=starttime, endtime=endtime, 
-                          minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),
-                          minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), 
-                          level='station')
+    try:
+        print('Starting to download inventory')
+        inv = client.get_stations(network="*", station="*", location="*", channel="*H*", 
+                            starttime=starttime, endtime=endtime, 
+                            minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),
+                            minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), 
+                            level='station')
+        print('Finished downloading inventory')
+    except (IndexError, FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException):
+        fig, ax = plt.subplots()
+        ax.text(0.5,0.5,'Something is wrong with the data provider, try another')
+        fig.canvas.draw();
+        image = np.array(fig.canvas.renderer.buffer_rgba())
+        plt.close(fig)
+        return image
     
     waveforms = []
     cached_waveforms = glob("data/cached/*.mseed")
 
     for network in inv:
+        # Skip the SYntetic networks
+        if network.code == 'SY':
+            continue
         for station in network:
-            try:
-                distance = locations2degrees(eq_lat, eq_lon, station.latitude, station.longitude)
+            print(f"Processing {network.code}.{station.code}...")
+            distance = locations2degrees(eq_lat, eq_lon, station.latitude, station.longitude)
 
-                arrivals = taup_model.get_travel_times(source_depth_in_km=source_depth_km, 
-                                                       distance_in_degree=distance, 
-                                                       phase_list=["P", "S"])
+            arrivals = taup_model.get_travel_times(source_depth_in_km=source_depth_km, 
+                                                    distance_in_degree=distance, 
+                                                    phase_list=["P", "S"])
 
-                if len(arrivals) > 0:
-
-                    starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15
-                    endtime = starttime + 60
+            if len(arrivals) > 0:
 
+                starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15
+                endtime = starttime + 60
+                try:
                     if f"data/cached/{network.code}_{station.code}_{starttime}.mseed" not in cached_waveforms:
+                        print('Downloading waveform')
                         waveform = client.get_waveforms(network=network.code, station=station.code, location="*", channel="*", 
                                                     starttime=starttime, endtime=endtime)
                         waveform.write(f"data/cached/{network.code}_{station.code}_{starttime}.mseed", format="MSEED")
+                        print('Finished downloading and caching waveform')
                     else:
+                        print('Reading cached waveform')
                         waveform = obspy.read(f"data/cached/{network.code}_{station.code}_{starttime}.mseed")
-                    
-                    waveform = waveform.select(channel="H[BH][ZNE]")
-                    waveform = waveform.merge(fill_value=0)
-                    waveform = waveform[:3]
-                    
-                    len_check = [len(x.data) for x in waveform]
-                    if len(set(len_check)) > 1:
-                        continue
+                        
+
+                except (IndexError, FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException):
+                    print(f'Skipping {network.code}_{station.code}_{starttime}')
+                    continue
+            
+                waveform = waveform.select(channel="H[BH][ZNE]")
+                waveform = waveform.merge(fill_value=0)
+                waveform = waveform[:3]
+                
+                len_check = [len(x.data) for x in waveform]
+                if len(set(len_check)) > 1:
+                    continue
+
+                if len(waveform) == 3:
+                    try:
+                        waveform = prepare_waveform(np.stack([x.data for x in waveform]))
 
-                    if len(waveform) == 3:
-                        try:
-                            waveform = prepare_waveform(np.stack([x.data for x in waveform]))
-                        except:
-                            continue
-                    
                         distances.append(distance)
                         t0s.append(starttime)
                         st_lats.append(station.latitude)
                         st_lons.append(station.longitude)
                         waveforms.append(waveform)
 
-            except (IndexError, FDSNNoDataException, FDSNTimeoutException):
-                continue
+                        print(f"Added {network.code}.{station.code} to the list of waveforms")
+
+                    except:
+                        continue
+                
+    
+    # If there are no waveforms, return an empty plot
+    if len(waveforms) == 0:
+        fig, ax = plt.subplots()
+        ax.text(0.5,0.5,'No waveforms found')
+        fig.canvas.draw();
+        image = np.array(fig.canvas.renderer.buffer_rgba())
+        plt.close(fig)
+        return image
+    
+
+    first_distances = bin_distances(distances, bin_size=10/111.2)
+
+    # Edge case when there are way too many waveforms to process
+    selection_indexes = np.random.choice(first_distances, 
+                                         np.min([len(first_distances), max_waveforms]),
+                                         replace=False)
+
+    waveforms = np.array(waveforms)[selection_indexes]
+    distances = np.array(distances)[selection_indexes]
+    t0s = np.array(t0s)[selection_indexes]
+    st_lats = np.array(st_lats)[selection_indexes]
+    st_lons = np.array(st_lons)[selection_indexes]
 
+    waveforms = [torch.tensor(waveform) for waveform in waveforms]
+
+    print('Starting to run predictions')
     with torch.no_grad():
         waveforms_torch = torch.vstack(waveforms)
         output = model(waveforms_torch)
@@ -169,8 +241,31 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     p_max_confidence = np.min([p_phases[i::len(waveforms)].std() for i in range(len(waveforms))]) 
     s_max_confidence = np.min([s_phases[i::len(waveforms)].std() for i in range(len(waveforms))])
 
-    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 3), sharex=True)
+    print(f"Starting plotting {len(waveforms)} waveforms")
+    fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(10, 3))
+
+    # Plot topography
+    print('Fetching topography')
+    params = Topography.DEFAULT.copy()
+    extra_window = 0.5
+    params["south"] = np.min([st_lats.min(), eq_lat])-extra_window
+    params["north"] = np.max([st_lats.max(), eq_lat])+extra_window
+    params["west"] = np.min([st_lons.min(), eq_lon])-extra_window
+    params["east"] = np.max([st_lons.max(), eq_lon])+extra_window
+
+    topo_map = Topography(**params)
+    topo_map.fetch()
+    topo_map.load()
+
+    print('Plotting topo')
+    hillshade = es.hillshade(topo_map.da[0], altitude=10)
+    
+    topo_map.da.plot(ax = ax[1], cmap='Greys', add_colorbar=False, add_labels=False)
+    topo_map.da.plot(ax = ax[2], cmap='Greys', add_colorbar=False, add_labels=False)
+    ax[1].imshow(hillshade, cmap="Greys", alpha=0.5)
+
     for i in range(len(waveforms)):
+        print(f"Plotting waveform {i+1}/{len(waveforms)}")
         current_P = p_phases[i::len(waveforms)]
         current_S = s_phases[i::len(waveforms)]
 
@@ -188,17 +283,46 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
         ax[0].set_ylabel('Z')
 
         ax[0].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
-        ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=5))
+        ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=20))
+
+        delta_t = t0s[i].timestamp - obspy.UTCDateTime(timestamp).timestamp
+
+        velocity_p = (distances[i]*111.2)/(delta_t+current_P.mean()*60).item()
+        velocity_s = (distances[i]*111.2)/(delta_t+current_S.mean()*60).item()
+
+        print(f"Station {st_lats[i]}, {st_lons[i]} has P velocity {velocity_p} and S velocity {velocity_s}")
+        
+        # Generate an array from st_lat to eq_lat and from st_lon to eq_lon
+        x = np.linspace(st_lons[i], eq_lon, 50)
+        y = np.linspace(st_lats[i], eq_lat, 50)
         
+        # Plot the array
+        ax[1].scatter(x, y, c=np.zeros_like(x)+velocity_p, alpha=0.5, vmin=0, vmax=8)
+        ax[2].scatter(x, y, c=np.zeros_like(x)+velocity_s, alpha=0.5, vmin=0, vmax=8)
+
+    # Add legend
     ax[0].scatter(None, None, color='r', marker='|', label='P')
     ax[0].scatter(None, None, color='b', marker='|', label='S')
     ax[0].legend()
 
-    ax[1].scatter(st_lats, st_lons, color='b', marker='d', label='Stations')
-    ax[1].scatter(eq_lat, eq_lon, color='r', marker='*', label='Earthquake')
-    ax[1].legend()
-    plt.subplots_adjust(hspace=0., wspace=0.)
-        
+    print('Plotting stations')
+    for i in range(1,3):
+        ax[i].scatter(st_lons, st_lats, color='b', label='Stations')
+        ax[i].scatter(eq_lon, eq_lat, color='r', marker='*', label='Earthquake')
+
+    # Generate colorbar for the velocity plot
+    cbar = plt.colorbar(ax[1].scatter(None, None, c=velocity_p, alpha=0.5, vmin=0, vmax=8), ax=ax[1])
+    cbar.set_label('P Velocity (km/s)')
+    ax[1].set_title('P Velocity')
+
+    cbar = plt.colorbar(ax[2].scatter(None, None, c=velocity_s, alpha=0.5, vmin=0, vmax=8), ax=ax[2])
+    cbar.set_label('S Velocity (km/s)')
+    ax[2].set_title('S Velocity')
+
+
+
+    plt.subplots_adjust(hspace=0., wspace=0.5)
+
     fig.canvas.draw();
     image = np.array(fig.canvas.renderer.buffer_rgba())
     plt.close(fig)
@@ -212,30 +336,54 @@ model = Onset_picker.load_from_checkpoint("./weights.ckpt",
 model.eval()
 
 with gr.Blocks() as demo:
-    gr.Markdown("# PhaseHunter")
-    gr.Markdown("""This app allows one to detect P and S seismic phases along with uncertainty of the detection. 
-            The app can be used in three ways: either by selecting one of the sample waveforms;
-                                                or by selecting an earthquake from the global earthquake catalogue;
-                                                or by uploading a waveform of interest.
+    gr.HTML("""<h1>PhaseHunter</h1>
+<p>This app allows one to detect <mark style="background-color: red; color: white;">P</mark> and <mark style="background-color: blue; color: white;">S</mark> seismic phases along with 
+
+<span style="font-size: 24px; font-weight: bold;">
+  <span style="color: #4c4c4c; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;">u</span>
+  <span style="color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;">n</span>
+  <span style="color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;">c</span>
+  <span style="color: #d9d9d9; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;">e</span>
+  <span style="color: #f2f2f2; text-shadow: 1px 1px 0 #eee, -1px -1px 0 #eee, 1px -1px 0 #eee, -1px 1px 0 #eee;">r</span>
+  <span style="color: #d9d9d9; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;">t</span>
+  <span style="color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;">a</span>
+  <span style="color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;">i</span>
+  <span style="color: #4c4c4c; text-shadow: 1px 1px 0 #ccc, -1px -1px 0 #ccc, 1px -1px 0 #ccc, -1px 1px 0 #ccc;">n</span>
+  <span style="color: #808080; text-shadow: 1px 1px 0 #bbb, -1px -1px 0 #bbb, 1px -1px 0 #bbb, -1px 1px 0 #bbb;">t</span>
+  <span style="color: #b3b3b3; text-shadow: 1px 1px 0 #aaa, -1px -1px 0 #aaa, 1px -1px 0 #aaa, -1px 1px 0 #aaa;">y</span>
+  
+</span>
+ of the detection.</p>
+<ol>
+  <li>By selecting one of the sample waveforms.</li>
+  <li>By uploading your own waveform.</li>
+  <li>By selecting an earthquake from the global earthquake catalogue.</li>
+</ol>
+<p>Please upload your waveform in <code>.npy</code> (numpy) format.</p>
+<p>Your waveform should be sampled at 100 samples per second and have 3 (Z, N, E) or 1 (Z) channels. If your file is longer than 60 seconds, the app will only use the first 60 seconds of the waveform.</p>
             """)
-    with gr.Tab("Default example"):
-        # Define the input and output types for Gradio
-        inputs = gr.Dropdown(
-            ["data/sample/sample_0.npy", 
-            "data/sample/sample_1.npy", 
-            "data/sample/sample_2.npy"], 
-            label="Sample waveform", 
-            info="Select one of the samples",
-            value = "data/sample/sample_0.npy"
-        )
+    with gr.Tab("Try on a single station"):
+        with gr.Row(): 
+            # Define the input and output types for Gradio
+            inputs = gr.Dropdown(
+                ["data/sample/sample_0.npy", 
+                "data/sample/sample_1.npy", 
+                "data/sample/sample_2.npy"], 
+                label="Sample waveform", 
+                info="Select one of the samples",
+                value = "data/sample/sample_0.npy"
+            )
+
+            upload = gr.File(label="Or upload your own waveform")
 
         button = gr.Button("Predict phases")
-        outputs = gr.outputs.Image(label='Waveform with Phases Marked', type='numpy')
+        outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)
     
-        button.click(mark_phases, inputs=inputs, outputs=outputs)
+        button.click(mark_phases, inputs=[inputs, upload], outputs=outputs)
         
     with gr.Tab("Select earthquake from catalogue"):
-        gr.Markdown('TEST')
+        gr.Markdown("""Select an earthquake from the global earthquake catalogue and the app will download the waveform from the FDSN client of your choice.
+                       """)
         
         client_inputs = gr.Dropdown(
             choices = list(URL_MAPPINGS.keys()), 
@@ -244,6 +392,7 @@ with gr.Blocks() as demo:
             value = "IRIS",
             interactive=True
         )
+
         with gr.Row(): 
 
             timestamp_inputs = gr.Textbox(value='2019-07-04 17:33:49',
@@ -277,13 +426,23 @@ with gr.Blocks() as demo:
                                     interactive=True)
             
             velocity_inputs = gr.Dropdown(
-                choices = ['1066a', '1066b', 'ak135', 'ak135f', 'herrin', 'iasp91', 'jb', 'prem', 'pwdk'], 
+                choices = ['1066a', '1066b', 'ak135', 
+                           'ak135f', 'herrin', 'iasp91', 
+                           'jb', 'prem', 'pwdk'], 
                 label="1D velocity model", 
                 info="Velocity model for station selection",
                 value = "1066a",
                 interactive=True
             )
-            
+
+            max_waveforms_inputs = gr.Slider(minimum=1,
+                                            maximum=100,
+                                            value=10,
+                                            label="Max waveforms per section",
+                                            step=1,
+                                            info="Maximum number of waveforms to show per section\n (to avoid long prediction times)",
+                                            interactive=True,
+                                            )
             
         button = gr.Button("Predict phases")
         outputs_section = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)
@@ -291,13 +450,8 @@ with gr.Blocks() as demo:
         button.click(predict_on_section, 
                  inputs=[client_inputs, timestamp_inputs, 
                          eq_lat_inputs, eq_lon_inputs, 
-                         radius_inputs, source_depth_inputs, velocity_inputs],
+                         radius_inputs, source_depth_inputs, 
+                         velocity_inputs, max_waveforms_inputs],
                  outputs=outputs_section)
 
-    with gr.Tab("Predict on your own waveform"):
-        gr.Markdown("""
-        Please upload your waveform in .npy (numpy) format. 
-        Your waveform should be sampled at 100 sps and have 3 (Z, N, E) or 1 (Z) channels.
-        """)
-
 demo.launch()