updated layout

Gradio_app.ipynb

@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 83,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Running on local URL:  http://127.0.0.1:7906\n",
+      "Running on local URL:  http://127.0.0.1:7923\n",
       "\n",
       "To create a public link, set `share=True` in `launch()`.\n"
      ]
@@ -17,7 +17,7 @@
     {
      "data": {
       "text/html": [
-       "<div><iframe src=\"http://127.0.0.1:7906/\" 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:7923/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
       ],
       "text/plain": [
        "<IPython.core.display.HTML object>"
@@ -30,9 +30,138 @@
      "data": {
       "text/plain": []
      },
-     "execution_count": 66,
+     "execution_count": 83,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting to download inventory\n",
+      "Finished downloading inventory\n",
+      "Processing CI.CCC...\n",
+      "Downloading waveform\n",
+      "Skipping CI_CCC_2019-07-04T17:33:40.494920Z\n",
+      "Processing CI.CLC...\n",
+      "Processing CI.JRC2...\n",
+      "Reading cached waveform\n",
+      "Added CI.JRC2 to the list of waveforms\n",
+      "Processing CI.LRL...\n",
+      "Reading cached waveform\n",
+      "Added CI.LRL to the list of waveforms\n",
+      "Processing CI.MPM...\n",
+      "Reading cached waveform\n",
+      "Processing CI.Q0072...\n",
+      "Reading cached waveform\n",
+      "Processing CI.SLA...\n",
+      "Reading cached waveform\n",
+      "Added CI.SLA to the list of waveforms\n",
+      "Processing CI.SRT...\n",
+      "Reading cached waveform\n",
+      "Added CI.SRT to the list of waveforms\n",
+      "Processing CI.TOW2...\n",
+      "Reading cached waveform\n",
+      "Added CI.TOW2 to the list of waveforms\n",
+      "Processing CI.WBM...\n",
+      "Downloading waveform\n",
+      "Skipping CI_WBM_2019-07-04T17:33:40.063616Z\n",
+      "Processing CI.WCS2...\n",
+      "Downloading waveform\n",
+      "Skipping CI_WCS2_2019-07-04T17:33:40.200958Z\n",
+      "Processing CI.WMF...\n",
+      "Reading cached waveform\n",
+      "Added CI.WMF to the list of waveforms\n",
+      "Processing CI.WNM...\n",
+      "Reading cached waveform\n",
+      "Processing CI.WRC2...\n",
+      "Downloading waveform\n",
+      "Skipping CI_WRC2_2019-07-04T17:33:38.698099Z\n",
+      "Processing CI.WRV2...\n",
+      "Reading cached waveform\n",
+      "Processing CI.WVP2...\n",
+      "Downloading waveform\n",
+      "Skipping CI_WVP2_2019-07-04T17:33:39.650402Z\n",
+      "Processing NP.1809...\n",
+      "Reading cached waveform\n",
+      "Processing NP.5419...\n",
+      "Reading cached waveform\n",
+      "Processing PB.B916...\n",
+      "Reading cached waveform\n",
+      "Processing PB.B917...\n",
+      "Reading cached waveform\n",
+      "Processing PB.B918...\n",
+      "Reading cached waveform\n",
+      "Processing PB.B921...\n",
+      "Reading cached waveform\n",
+      "Starting to run predictions\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:225: FutureWarning: The input object of type 'Tensor' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Tensor', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n",
+      "  waveforms = np.array(waveforms)[selection_indexes]\n",
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:225: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
+      "  waveforms = np.array(waveforms)[selection_indexes]\n",
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:232: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
+      "  waveforms = [torch.tensor(waveform) for waveform in waveforms]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Starting plotting 3 waveforms\n",
+      "Fetching topography\n",
+      "Plotting topo\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/anovosel/miniconda3/envs/phasehunter/lib/python3.11/site-packages/bmi_topography/api_key.py:49: UserWarning: You are using a demo key to fetch data from OpenTopography, functionality will be limited. See https://bmi-topography.readthedocs.io/en/latest/#api-key for more information.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting waveform 1/3\n",
+      "Station 36.11758, -117.85486 has P velocity 4.96342368856812 and S velocity 3.0001093626503503\n",
+      "Plotting waveform 2/3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:302: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], 'starttime' : [str(t0s[i])],\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Station 35.98249, -117.80885 has P velocity 4.229153346955616 and S velocity 2.3118595983254937\n",
+      "Plotting waveform 3/3\n",
+      "Station 35.69235, -117.75051 has P velocity 2.9537452996413585 and S velocity 1.3863453902284213\n",
+      "Plotting stations\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:302: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], 'starttime' : [str(t0s[i])],\n",
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_17878/2982466024.py:302: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n",
+      "  output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], 'starttime' : [str(t0s[i])],\n"
+     ]
     }
    ],
    "source": [
@@ -153,7 +282,7 @@
     "    return coeff\n",
     "\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",
+    "    distances, t0s, st_lats, st_lons, waveforms, names = [], [], [], [], [], []\n",
     "    \n",
     "    taup_model = TauPyModel(model=velocity_model)\n",
     "    client = Client(client_name)\n",
@@ -235,6 +364,7 @@
     "                        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",
@@ -264,6 +394,7 @@
     "    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",
@@ -302,6 +433,11 @@
     "    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' : [], 'starttime' : [], \n",
+    "                                 'p_phase' : [], 'p_uncertainty' : [], 's_phase' : [], 's_uncertainty' : [],\n",
+    "                                 'velocity_p' : [], 'velocity_s' : []})\n",
+    "                                  \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",
@@ -329,6 +465,11 @@
     "        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",
+    "        output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], 'starttime' : [str(t0s[i])], \n",
+    "                                                        'p_phase' : [(delta_t+current_P.mean()*60).item()], 'p_uncertainty' : [current_P.std().item()*60], \n",
+    "                                                        's_phase' : [(delta_t+current_S.mean()*60).item()], 's_uncertainty' : [current_S.std().item()*60],\n",
+    "                                                        'velocity_p' : [velocity_p], 'velocity_s' : [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",
@@ -357,15 +498,13 @@
     "    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",
     "\n",
-    "    return image\n",
+    "    return image, output_picks\n",
     "\n",
     "\n",
     "model = Onset_picker.load_from_checkpoint(\"./weights.ckpt\",\n",
@@ -412,75 +551,80 @@
     "    with gr.Tab(\"Select earthquake from catalogue\"):\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",
-    "            label=\"FDSN Client\", \n",
-    "            info=\"Select one of the available FDSN clients\",\n",
-    "            value = \"IRIS\",\n",
-    "            interactive=True\n",
-    "        )\n",
-    "\n",
     "        with gr.Row(): \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",
-    "            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",
-    "            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",
-    "            source_depth_inputs = gr.Number(value=10,\n",
-    "                                label=\"Source depth (km)\",\n",
-    "                                info=\"Depth of the earthquake\",\n",
-    "                                interactive=True)\n",
-    "            \n",
-    "            radius_inputs = gr.Slider(minimum=1, \n",
-    "                                    maximum=150, \n",
-    "                                    value=50, 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",
     "            velocity_inputs = gr.Dropdown(\n",
     "                choices = ['1066a', '1066b', 'ak135', \n",
-    "                           'ak135f', 'herrin', 'iasp91', \n",
-    "                           'jb', 'prem', 'pwdk'], \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",
-    "            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=4):\n",
+    "                with gr.Row():   \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",
+    "                    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",
+    "                    source_depth_inputs = gr.Number(value=10,\n",
+    "                        label=\"Source depth (km)\",\n",
+    "                        info=\"Depth of the earthquake\",\n",
+    "                        interactive=True)\n",
+    "                \n",
+    "\n",
+    "            \n",
+    "            with gr.Column(scale=2):\n",
+    "                with gr.Row():   \n",
+    "                    radius_inputs = gr.Slider(minimum=1, \n",
+    "                                            maximum=150, \n",
+    "                                            value=50, 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",
     "            \n",
     "        button = gr.Button(\"Predict phases\")\n",
-    "        outputs_section = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n",
-    "        \n",
+    "        output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n",
+    "        output_picks = gr.Dataframe(label='# Pick data', type='pandas', interactive=False)\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",
-    "                 outputs=outputs_section)\n",
+    "                 outputs=[output_image, output_picks])\n",
     "\n",
     "demo.launch()"
    ]

app.py

@@ -115,7 +115,7 @@ def variance_coefficient(residuals):
     return coeff
 
 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 = [], [], [], [], []
+    distances, t0s, st_lats, st_lons, waveforms, names = [], [], [], [], [], []
     
     taup_model = TauPyModel(model=velocity_model)
     client = Client(client_name)
@@ -197,6 +197,7 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
                         st_lats.append(station.latitude)
                         st_lons.append(station.longitude)
                         waveforms.append(waveform)
+                        names.append(f"{network.code}.{station.code}")
 
                         print(f"Added {network.code}.{station.code} to the list of waveforms")
 
@@ -226,6 +227,7 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     t0s = np.array(t0s)[selection_indexes]
     st_lats = np.array(st_lats)[selection_indexes]
     st_lons = np.array(st_lons)[selection_indexes]
+    names = np.array(names)[selection_indexes]
 
     waveforms = [torch.tensor(waveform) for waveform in waveforms]
 
@@ -264,6 +266,11 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     topo_map.da.plot(ax = ax[2], cmap='Greys', add_colorbar=False, add_labels=False)
     ax[1].imshow(hillshade, cmap="Greys", alpha=0.5)
 
+    output_picks = pd.DataFrame({'station_name' : [], 'starttime' : [], 
+                                 'p_phase' : [], 'p_uncertainty' : [], 's_phase' : [], 's_uncertainty' : [],
+                                 'velocity_p' : [], 'velocity_s' : []})
+                                  
+                                  
     for i in range(len(waveforms)):
         print(f"Plotting waveform {i+1}/{len(waveforms)}")
         current_P = p_phases[i::len(waveforms)]
@@ -291,6 +298,11 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
         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}")
+
+        output_picks = output_picks.append(pd.DataFrame({'station_name': [names[i]], 'starttime' : [str(t0s[i])], 
+                                                        'p_phase' : [(delta_t+current_P.mean()*60).item()], 'p_uncertainty' : [current_P.std().item()*60], 
+                                                        's_phase' : [(delta_t+current_S.mean()*60).item()], 's_uncertainty' : [current_S.std().item()*60],
+                                                        'velocity_p' : [velocity_p], 'velocity_s' : [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)
@@ -319,15 +331,13 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     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)
 
-    return image
+    return image, output_picks
 
 
 model = Onset_picker.load_from_checkpoint("./weights.ckpt",
@@ -374,74 +384,79 @@ with gr.Blocks() as demo:
     with gr.Tab("Select earthquake from catalogue"):
         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()), 
-            label="FDSN Client", 
-            info="Select one of the available FDSN clients",
-            value = "IRIS",
-            interactive=True
-        )
-
         with gr.Row(): 
+            client_inputs = gr.Dropdown(
+                choices = list(URL_MAPPINGS.keys()), 
+                label="FDSN Client", 
+                info="Select one of the available FDSN clients",
+                value = "IRIS",
+                interactive=True
+            )
 
-            timestamp_inputs = gr.Textbox(value='2019-07-04 17:33:49',
-                                placeholder='YYYY-MM-DD HH:MM:SS',
-                                label="Timestamp",
-                                info="Timestamp of the earthquake",
-                                max_lines=1,
-                                interactive=True)
-                               
-            eq_lat_inputs = gr.Number(value=35.766, 
-                            label="Latitude", 
-                            info="Latitude of the earthquake",
-                            interactive=True)
-            
-            eq_lon_inputs = gr.Number(value=-117.605,
-                                label="Longitude",
-                                info="Longitude of the earthquake",
-                                interactive=True)
-            
-            source_depth_inputs = gr.Number(value=10,
-                                label="Source depth (km)",
-                                info="Depth of the earthquake",
-                                interactive=True)
-            
-            radius_inputs = gr.Slider(minimum=1, 
-                                    maximum=150, 
-                                    value=50, label="Radius (km)", 
-                                    step=10,
-                                    info="""Select the radius around the earthquake to download data from.\n 
-                                    Note that the larger the radius, the longer the app will take to run.""",
-                                    interactive=True)
-            
             velocity_inputs = gr.Dropdown(
                 choices = ['1066a', '1066b', 'ak135', 
-                           'ak135f', 'herrin', 'iasp91', 
-                           'jb', 'prem', 'pwdk'], 
+                        '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,
-                                            )
+            with gr.Column(scale=4):
+                with gr.Row():   
+                    timestamp_inputs = gr.Textbox(value='2019-07-04 17:33:49',
+                                        placeholder='YYYY-MM-DD HH:MM:SS',
+                                        label="Timestamp",
+                                        info="Timestamp of the earthquake",
+                                        max_lines=1,
+                                        interactive=True)
+                            
+                    eq_lat_inputs = gr.Number(value=35.766, 
+                                    label="Latitude", 
+                                    info="Latitude of the earthquake",
+                                    interactive=True)
+                    
+                    eq_lon_inputs = gr.Number(value=-117.605,
+                                        label="Longitude",
+                                        info="Longitude of the earthquake",
+                                        interactive=True)
+                    
+                    source_depth_inputs = gr.Number(value=10,
+                        label="Source depth (km)",
+                        info="Depth of the earthquake",
+                        interactive=True)
+                
+
+            
+            with gr.Column(scale=2):
+                with gr.Row():   
+                    radius_inputs = gr.Slider(minimum=1, 
+                                            maximum=150, 
+                                            value=50, label="Radius (km)", 
+                                            step=10,
+                                            info="""Select the radius around the earthquake to download data from.\n 
+                                            Note that the larger the radius, the longer the app will take to run.""",
+                                            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)
-        
+        output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)
+        output_picks = gr.Dataframe(label='# Pick data', type='pandas', interactive=False)
+
         button.click(predict_on_section, 
                  inputs=[client_inputs, timestamp_inputs, 
                          eq_lat_inputs, eq_lon_inputs, 
                          radius_inputs, source_depth_inputs, 
                          velocity_inputs, max_waveforms_inputs],
-                 outputs=outputs_section)
+                 outputs=[output_image, output_picks])
 
 demo.launch()