Added velocity model builder 0.01

Gradio_app.ipynb

@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Running on local URL:  http://127.0.0.1:7876\n",
+      "Running on local URL:  http://127.0.0.1:7864\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:7876/\" 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:7864/\" 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,7 +30,7 @@
      "data": {
       "text/plain": []
      },
-     "execution_count": 30,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -38,16 +38,215 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Loaded (6000,)\n",
-      "Reshaped (1, 6000)\n",
-      "Resampled (1, 3000)\n"
+      "Starting to download inventory\n",
+      "Finished downloading inventory\n",
+      "Processing CI.CCC...\n",
+      "Downloading waveform for CI_CCC_2019-07-04T17:33:40.494920Z\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 for CI_WBM_2019-07-04T17:33:40.063616Z\n",
+      "Skipping CI_WBM_2019-07-04T17:33:40.063616Z\n",
+      "Processing CI.WCS2...\n",
+      "Downloading waveform for CI_WCS2_2019-07-04T17:33:40.200958Z\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 for CI_WRC2_2019-07-04T17:33:38.698099Z\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 for CI_WVP2_2019-07-04T17:33:39.650402Z\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": [
-      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:273: 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_3502/4124724611.py:273: 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_3502/4124724611.py:280: 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 35.98249, -117.80885 has P velocity 4.13660431013202 and S velocity 2.2622770044299756\n",
+      "Plotting waveform 2/3\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:365: 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]],\n",
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:365: 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]],\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Station 35.69235, -117.75051 has P velocity 3.4155476453388767 and S velocity 1.67967367867923\n",
+      "Plotting waveform 3/3\n",
+      "Station 36.11758, -117.85486 has P velocity 4.745724852828504 and S velocity 2.6483289549749593\n",
+      "Plotting stations\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:365: 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]],\n",
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:385: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
+      "  ax[i].set_xticklabels(ax[i].get_xticks(), rotation = 50)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  station_name    st_lat     st_lon                    starttime  p_phase, s  \\\n",
+      "0      CI.JRC2  35.98249 -117.80885  2019-07-04T17:33:39.947494Z    7.320212   \n",
+      "1       CI.SRT  35.69235 -117.75051  2019-07-04T17:33:38.029990Z    4.532020   \n",
+      "2       CI.WMF  36.11758 -117.85486  2019-07-04T17:33:41.867962Z    9.504385   \n",
+      "\n",
+      "   p_uncertainty, s  s_phase, s  s_uncertainty, s  velocity_p, km/s  \\\n",
+      "0          0.020417   13.385108          0.028439          4.136604   \n",
+      "1          0.017490    9.215676          0.019568          3.415548   \n",
+      "2          0.015920   17.031569          0.046738          4.745725   \n",
+      "\n",
+      "   velocity_s, km/s  \n",
+      "0          2.262277  \n",
+      "1          1.679674  \n",
+      "2          2.648329  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:503: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
+      "  plt.colorbar(m)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  station_name    st_lat     st_lon                    starttime  p_phase, s  \\\n",
+      "0      CI.JRC2  35.98249 -117.80885  2019-07-04T17:33:39.947494Z    7.320212   \n",
+      "1       CI.SRT  35.69235 -117.75051  2019-07-04T17:33:38.029990Z    4.532020   \n",
+      "2       CI.WMF  36.11758 -117.85486  2019-07-04T17:33:41.867962Z    9.504385   \n",
+      "\n",
+      "   p_uncertainty, s  s_phase, s  s_uncertainty, s  velocity_p, km/s  \\\n",
+      "0          0.020417   13.385108          0.028439          4.136604   \n",
+      "1          0.017490    9.215676          0.019568          3.415548   \n",
+      "2          0.015920   17.031569          0.046738          4.745725   \n",
+      "\n",
+      "   velocity_s, km/s  \n",
+      "0          2.262277  \n",
+      "1          1.679674  \n",
+      "2          2.648329  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:503: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
+      "  plt.colorbar(m)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  station_name    st_lat     st_lon                    starttime  p_phase, s  \\\n",
+      "0      CI.JRC2  35.98249 -117.80885  2019-07-04T17:33:39.947494Z    7.320212   \n",
+      "1       CI.SRT  35.69235 -117.75051  2019-07-04T17:33:38.029990Z    4.532020   \n",
+      "2       CI.WMF  36.11758 -117.85486  2019-07-04T17:33:41.867962Z    9.504385   \n",
+      "\n",
+      "   p_uncertainty, s  s_phase, s  s_uncertainty, s  velocity_p, km/s  \\\n",
+      "0          0.020417   13.385108          0.028439          4.136604   \n",
+      "1          0.017490    9.215676          0.019568          3.415548   \n",
+      "2          0.015920   17.031569          0.046738          4.745725   \n",
+      "\n",
+      "   velocity_s, km/s  \n",
+      "0          2.262277  \n",
+      "1          1.679674  \n",
+      "2          2.648329  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/_g/3q5q8_dj0ydcpktxlwxb5vrh0000gq/T/ipykernel_3502/4124724611.py:503: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
+      "  plt.colorbar(m)\n"
      ]
     }
    ],
@@ -455,9 +654,10 @@
     "    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",
+    "    output_csv = f'data/velocity/{eq_lat}_{eq_lon}_{source_depth_km}_{timestamp}_{len(waveforms)}.csv'\n",
+    "    output_picks.to_csv(output_csv, index=False)\n",
+    "    \n",
     "    return image, output_picks, output_csv\n",
     "\n",
     "import numpy as np\n",
@@ -468,17 +668,16 @@
     "    return np.argmin(np.abs(array - value))\n",
     "\n",
     "def compute_velocity_model(azimuth, elevation):\n",
-    "    filename = output_csv\n",
+    "    filename = list(output_csv.temp_files)[0]\n",
+    "    \n",
     "    df = pd.read_csv(filename)\n",
-    "\n",
+    "    print(df)\n",
+    "    filename = filename.split('/')[-1]\n",
+    "    \n",
     "    # Current EQ location\n",
-    "    filename = filename.split(\"/\")[-1]\n",
     "    eq_lat = float(filename.split(\"_\")[0])\n",
     "    eq_lon = float(filename.split(\"_\")[1])\n",
-    "\n",
-    "    ## FIX THIS LATTER\n",
-    "    eq_depth = 10 ##FIX THIS LATTER\n",
-    "    ## FIX THIS LATTER\n",
+    "    eq_depth = float(filename.split(\"_\")[2])\n",
     "\n",
     "    # Define the region of interest (latitude, longitude, and depth ranges)\n",
     "    lat_range = (np.min([df.st_lat.min(), eq_lat]), np.max([df.st_lat.max(), eq_lat]))\n",
@@ -595,7 +794,53 @@
     "    </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",
+    "            with gr.Column(scale=1):\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",
+    "                \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",
+    "            with gr.Column(scale=1):\n",
+    "                upload = gr.File(label=\"Or upload your own waveform\")\n",
+    "                sampling_rate_inputs = gr.Slider(minimum=10,\n",
+    "                        maximum=1000,\n",
+    "                        value=100,\n",
+    "                        label=\"Samlping rate, Hz\",\n",
+    "                        step=10,\n",
+    "                        info=\"Sampling rate of the waveform\",\n",
+    "                        interactive=True,\n",
+    "                        )\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, \n",
+    "                                          P_thres_inputs, S_thres_inputs,\n",
+    "                                          sampling_rate_inputs], \n",
+    "                                          outputs=outputs)    \n",
     "    with gr.Tab(\"Select earthquake from catalogue\"):\n",
     "\n",
     "        gr.HTML(\"\"\"\n",
@@ -717,53 +962,6 @@
     "                         inputs=inputs_vel_model, \n",
     "                         outputs=outputs_vel_model)\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",
-    "            with gr.Column(scale=1):\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",
-    "                \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",
-    "            with gr.Column(scale=1):\n",
-    "                upload = gr.File(label=\"Or upload your own waveform\")\n",
-    "                sampling_rate_inputs = gr.Slider(minimum=10,\n",
-    "                        maximum=1000,\n",
-    "                        value=100,\n",
-    "                        label=\"Samlping rate, Hz\",\n",
-    "                        step=10,\n",
-    "                        info=\"Sampling rate of the waveform\",\n",
-    "                        interactive=True,\n",
-    "                        )\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, \n",
-    "                                          P_thres_inputs, S_thres_inputs,\n",
-    "                                          sampling_rate_inputs], \n",
-    "                                          outputs=outputs)\n",
     "\n",
     "            \n",
     "\n",
@@ -840,54 +1038,102 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Running on local URL:  http://127.0.0.1:7869\n",
-      "\n",
-      "To create a public link, set `share=True` in `launch()`.\n"
-     ]
-    },
     {
      "data": {
-      "text/html": [
-       "<div><iframe src=\"http://127.0.0.1:7869/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
-      ],
       "text/plain": [
-       "<IPython.core.display.HTML object>"
+       "['DEFAULT_TEMP_DIR',\n",
+       " '__abstractmethods__',\n",
+       " '__class__',\n",
+       " '__delattr__',\n",
+       " '__dict__',\n",
+       " '__dir__',\n",
+       " '__doc__',\n",
+       " '__eq__',\n",
+       " '__format__',\n",
+       " '__ge__',\n",
+       " '__getattribute__',\n",
+       " '__getstate__',\n",
+       " '__gt__',\n",
+       " '__hash__',\n",
+       " '__init__',\n",
+       " '__init_subclass__',\n",
+       " '__le__',\n",
+       " '__lt__',\n",
+       " '__module__',\n",
+       " '__ne__',\n",
+       " '__new__',\n",
+       " '__reduce__',\n",
+       " '__reduce_ex__',\n",
+       " '__repr__',\n",
+       " '__setattr__',\n",
+       " '__sizeof__',\n",
+       " '__slots__',\n",
+       " '__str__',\n",
+       " '__subclasshook__',\n",
+       " '__weakref__',\n",
+       " '_abc_impl',\n",
+       " '_id',\n",
+       " '_skip_init_processing',\n",
+       " '_style',\n",
+       " 'as_example',\n",
+       " 'attach_load_event',\n",
+       " 'base64_to_temp_file_if_needed',\n",
+       " 'change',\n",
+       " 'clear',\n",
+       " 'deserialize',\n",
+       " 'download_temp_copy_if_needed',\n",
+       " 'elem_classes',\n",
+       " 'elem_id',\n",
+       " 'file_count',\n",
+       " 'file_types',\n",
+       " 'get_block_name',\n",
+       " 'get_config',\n",
+       " 'get_expected_parent',\n",
+       " 'get_load_fn_and_initial_value',\n",
+       " 'get_specific_update',\n",
+       " 'hash_base64',\n",
+       " 'hash_file',\n",
+       " 'hash_url',\n",
+       " 'info',\n",
+       " 'interactive',\n",
+       " 'label',\n",
+       " 'load_event',\n",
+       " 'load_event_to_attach',\n",
+       " 'make_temp_copy_if_needed',\n",
+       " 'parent',\n",
+       " 'postprocess',\n",
+       " 'preprocess',\n",
+       " 'render',\n",
+       " 'root',\n",
+       " 'root_url',\n",
+       " 'save_uploaded_file',\n",
+       " 'select',\n",
+       " 'selectable',\n",
+       " 'serialize',\n",
+       " 'set_event_trigger',\n",
+       " 'share_token',\n",
+       " 'show_label',\n",
+       " 'style',\n",
+       " 'temp_files',\n",
+       " 'test_input',\n",
+       " 'type',\n",
+       " 'unrender',\n",
+       " 'update',\n",
+       " 'upload',\n",
+       " 'value',\n",
+       " 'visible']"
       ]
      },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": []
-     },
-     "execution_count": 24,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/ky/4j6xbvhs5m583jflkhyzxf9h0000gn/T/ipykernel_19576/4006067033.py:95: MatplotlibDeprecationWarning: Unable to determine Axes to steal space for Colorbar. Using gca(), but will raise in the future. Either provide the *cax* argument to use as the Axes for the Colorbar, provide the *ax* argument to steal space from it, or add *mappable* to an Axes.\n",
-      "  plt.colorbar(m)\n"
-     ]
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "import gradio as gr\n",
-    "    \n",
-    "# Define the Gradio interface\n",
-    "\n"
+    "dir(output_csv)"
    ]
   },
   {
@@ -916,14 +1162,9 @@
     }
    ],
    "source": [
-    "# generate sin of shape (1,5000)\n",
-    "x = np.linspace(0, 10, 5000)\n",
-    "y = np.sin(x)\n",
-    "\n",
-    "y_resampled = resample_waveform(y, 1000, 100)\n",
-    "# plot sin\n",
-    "plt.plot(x, y)\n",
-    "plt.plot(x, y_resampled)"
+    "filename.split(\"/\")[-1]\n",
+    "    eq_lat = float(filename.split(\"_\")[0])\n",
+    "    eq_lon = float(filename.split(\"_\")[1])"
    ]
   }
  ],
@@ -943,7 +1184,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.8"
+   "version": "3.11.2"
   },
   "orig_nbformat": 4
  },

app.py

@@ -7,18 +7,14 @@ from phasehunter.data_preparation import prepare_waveform
 import torch
 import io
 
-from scipy.signal import resample
 from scipy.stats import gaussian_kde
+from scipy.signal import resample
 from bmi_topography import Topography
 import earthpy.spatial as es
 
 import obspy
 from obspy.clients.fdsn import Client
-from obspy.clients.fdsn.header import (
-    FDSNNoDataException,
-    FDSNTimeoutException,
-    FDSNInternalServerException,
-)
+from obspy.clients.fdsn.header import FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException
 from obspy.geodetics.base import locations2degrees
 from obspy.taup import TauPyModel
 from obspy.taup.helper_classes import SlownessModelError
@@ -35,12 +31,12 @@ from glob import glob
 def resample_waveform(waveform, original_freq, target_freq):
     """
     Resample a waveform from original frequency to target frequency using SciPy's resample function.
-
+    
     Args:
     waveform (numpy.ndarray): The input waveform as a 1D array.
     original_freq (float): The original sampling frequency of the waveform.
     target_freq (float): The target sampling frequency of the waveform.
-
+    
     Returns:
     resampled_waveform (numpy.ndarray): The resampled waveform as a 1D array.
     """
@@ -50,20 +46,19 @@ def resample_waveform(waveform, original_freq, target_freq):
     resampled_length = int(waveform.shape[-1] * resampling_ratio)
     # Resample the waveform using SciPy's resample function
     resampled_waveform = resample(waveform, resampled_length, axis=-1)
-
+    
     return resampled_waveform
 
-
 def make_prediction(waveform, sampling_rate):
     waveform = np.load(waveform)
-    print("Loaded", waveform.shape)
+    print('Loaded', waveform.shape)
 
     if len(waveform.shape) == 1:
         waveform = waveform.reshape(1, waveform.shape[0])
-    print("Reshaped", waveform.shape)
+    print('Reshaped', waveform.shape)
     if sampling_rate != 100:
         waveform = resample_waveform(waveform, sampling_rate, 100)
-        print("Resampled", waveform.shape)
+        print('Resampled', waveform.shape)
 
     orig_waveform = waveform[:, :6000].copy()
     processed_input = prepare_waveform(waveform)
@@ -83,80 +78,53 @@ def mark_phases(waveform, uploaded_file, p_thres, s_thres, sampling_rate):
     if uploaded_file is not None:
         waveform = uploaded_file.name
 
-    processed_input, p_phase, s_phase, orig_waveform = make_prediction(
-        waveform, sampling_rate
-    )
+    processed_input, p_phase, s_phase, orig_waveform = make_prediction(waveform, sampling_rate)
 
     # Create a plot of the waveform with the phases marked
-    if sum(processed_input[0][2] == 0):  # if input is 1C
+    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(orig_waveform[0], color="black", lw=1)
-        ax[0].set_ylabel("Norm. Ampl.")
+        ax[0].plot(orig_waveform[0], color='black', lw=1)
+        ax[0].set_ylabel('Norm. Ampl.')
 
-    else:  # if input is 3C
+    else: #if input is 3C
         fig, ax = plt.subplots(nrows=4, figsize=(10, 6), sharex=True)
-        ax[0].plot(orig_waveform[0], color="black", lw=1)
-        ax[1].plot(orig_waveform[1], color="black", lw=1)
-        ax[2].plot(orig_waveform[2], color="black", lw=1)
+        ax[0].plot(orig_waveform[0], color='black', lw=1)
+        ax[1].plot(orig_waveform[1], color='black', lw=1)
+        ax[2].plot(orig_waveform[2], color='black', lw=1)
+
+        ax[0].set_ylabel('Z')
+        ax[1].set_ylabel('N')
+        ax[2].set_ylabel('E')
 
-        ax[0].set_ylabel("Z")
-        ax[1].set_ylabel("N")
-        ax[2].set_ylabel("E")
 
-    do_we_have_p = p_phase.std().item() * 60 < p_thres
+    do_we_have_p = (p_phase.std().item()*60 < p_thres)
     if do_we_have_p:
-        p_phase_plot = p_phase * processed_input.shape[-1]
+        p_phase_plot = p_phase*processed_input.shape[-1]
         p_kde = gaussian_kde(p_phase_plot)
-        p_dist_space = np.linspace(min(p_phase_plot) - 10, max(p_phase_plot) + 10, 500)
-        ax[-1].plot(p_dist_space, p_kde(p_dist_space), color="r")
+        p_dist_space = np.linspace( min(p_phase_plot)-10, max(p_phase_plot)+10, 500 )
+        ax[-1].plot( p_dist_space, p_kde(p_dist_space), color='r')
     else:
-        ax[-1].text(
-            0.5,
-            0.75,
-            "No P phase detected",
-            horizontalalignment="center",
-            verticalalignment="center",
-            transform=ax[-1].transAxes,
-        )
-
-    do_we_have_s = s_phase.std().item() * 60 < s_thres
+        ax[-1].text(0.5, 0.75, 'No P phase detected', horizontalalignment='center', verticalalignment='center', transform=ax[-1].transAxes)
+
+    do_we_have_s = (s_phase.std().item()*60 < s_thres)
     if do_we_have_s:
-        s_phase_plot = s_phase * processed_input.shape[-1]
+        s_phase_plot = s_phase*processed_input.shape[-1]
         s_kde = gaussian_kde(s_phase_plot)
-        s_dist_space = np.linspace(min(s_phase_plot) - 10, max(s_phase_plot) + 10, 500)
-        ax[-1].plot(s_dist_space, s_kde(s_dist_space), color="b")
+        s_dist_space = np.linspace( min(s_phase_plot)-10, max(s_phase_plot)+10, 500 )
+        ax[-1].plot( s_dist_space, s_kde(s_dist_space), color='b')
 
         for a in ax:
-            a.axvline(
-                p_phase.mean() * processed_input.shape[-1],
-                color="r",
-                linestyle="--",
-                label="P",
-                alpha=do_we_have_p,
-            )
-            a.axvline(
-                s_phase.mean() * processed_input.shape[-1],
-                color="b",
-                linestyle="--",
-                label="S",
-                alpha=do_we_have_s,
-            )
+            a.axvline(p_phase.mean()*processed_input.shape[-1], color='r', linestyle='--', label='P', alpha=do_we_have_p)
+            a.axvline(s_phase.mean()*processed_input.shape[-1], color='b', linestyle='--', label='S', alpha=do_we_have_s)
     else:
-        ax[-1].text(
-            0.5,
-            0.25,
-            "No S phase detected",
-            horizontalalignment="center",
-            verticalalignment="center",
-            transform=ax[-1].transAxes,
-        )
-
-    ax[-1].set_xlabel("Time, samples")
-    ax[-1].set_ylabel("Uncert., samples")
+        ax[-1].text(0.5, 0.25, 'No S phase detected', horizontalalignment='center', verticalalignment='center', transform=ax[-1].transAxes)
+
+    ax[-1].set_xlabel('Time, samples')
+    ax[-1].set_ylabel('Uncert., samples')
     ax[-1].legend()
 
-    plt.subplots_adjust(hspace=0.0, wspace=0.0)
+    plt.subplots_adjust(hspace=0., wspace=0.)
 
     # Convert the plot to an image and return it
     fig.canvas.draw()
@@ -164,7 +132,6 @@ def mark_phases(waveform, uploaded_file, p_thres, s_thres, sampling_rate):
     plt.close(fig)
     return image
 
-
 def bin_distances(distances, bin_size=10):
     # Bin the distances into groups of `bin_size` kilometers
     binned_distances = {}
@@ -180,10 +147,9 @@ def bin_distances(distances, bin_size=10):
     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()
@@ -191,21 +157,9 @@ def variance_coefficient(residuals):
     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,
-    max_waveforms,
-    conf_thres_P,
-    conf_thres_S,
-):
+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):
     distances, t0s, st_lats, st_lons, waveforms, names = [], [], [], [], [], []
-
+    
     taup_model = TauPyModel(model=velocity_model)
     client = Client(client_name)
 
@@ -219,92 +173,60 @@ def predict_on_section(
     endtime = starttime + 120
 
     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,
-    ):
+        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()
+        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:
-        if network.code == "SY":
+        if network.code == 'SY':
             continue
         for station in network:
             print(f"Processing {network.code}.{station.code}...")
-            distance = locations2degrees(
-                eq_lat, eq_lon, station.latitude, station.longitude
-            )
+            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
                 try:
-                    filename = f"{network.code}_{station.code}_{starttime}"
+                    filename=f'{network.code}_{station.code}_{starttime}'
                     if f"data/cached/{filename}.mseed" not in cached_waveforms:
-                        print(f"Downloading waveform for {filename}")
-                        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")
+                        print(f'Downloading waveform for {filename}')
+                        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"
-                        )
+                        print('Reading cached waveform')
+                        waveform = obspy.read(f"data/cached/{network.code}_{station.code}_{starttime}.mseed")
+                        
 
-                except (
-                    IndexError,
-                    FDSNNoDataException,
-                    FDSNTimeoutException,
-                    FDSNInternalServerException,
-                ):
-                    print(f"Skipping {network.code}_{station.code}_{starttime}")
+                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].sort(keys=["channel"], reverse=True)
+                waveform = waveform[:3].sort(keys=['channel'], reverse=True)
 
                 len_check = [len(x.data) for x in waveform]
                 if len(set(len_check)) > 1:
@@ -312,9 +234,7 @@ def predict_on_section(
 
                 if len(waveform) == 3:
                     try:
-                        waveform = prepare_waveform(
-                            np.stack([x.data for x in waveform])
-                        )
+                        waveform = prepare_waveform(np.stack([x.data for x in waveform]))
 
                         distances.append(distance)
                         t0s.append(starttime)
@@ -323,32 +243,32 @@ def predict_on_section(
                         waveforms.append(waveform)
                         names.append(f"{network.code}.{station.code}")
 
-                        print(
-                            f"Added {network.code}.{station.code} to the list of waveforms"
-                        )
+                        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:
-        print("No waveforms found")
+        print('No waveforms found')
         fig, ax = plt.subplots()
-        ax.text(0.5, 0.5, "No waveforms found")
-        fig.canvas.draw()
+        ax.text(0.5,0.5,'No waveforms found')
+        fig.canvas.draw();
         image = np.array(fig.canvas.renderer.buffer_rgba())
         plt.close(fig)
         output_picks = pd.DataFrame()
-        output_picks.to_csv("data/picks.csv", index=False)
-        output_csv = "data/picks.csv"
+        output_picks.to_csv('data/picks.csv', index=False)
+        output_csv = 'data/picks.csv'
         return image, output_picks, output_csv
+    
 
-    first_distances = bin_distances(distances, bin_size=10 / 111.2)
+    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
-    )
+    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]
@@ -359,7 +279,7 @@ def predict_on_section(
 
     waveforms = [torch.tensor(waveform) for waveform in waveforms]
 
-    print("Starting to run predictions")
+    print('Starting to run predictions')
     with torch.no_grad():
         waveforms_torch = torch.vstack(waveforms)
         output = model(waveforms_torch)
@@ -367,183 +287,232 @@ def predict_on_section(
     p_phases = output[:, 0]
     s_phases = output[:, 1]
 
-    p_phases = p_phases.reshape(len(waveforms), -1)
-    s_phases = s_phases.reshape(len(waveforms), -1)
+    p_phases = p_phases.reshape(len(waveforms),-1)
+    s_phases = s_phases.reshape(len(waveforms),-1)
 
-    # Max confidence - min variance
+    # Max confidence - min variance    
     p_max_confidence = p_phases.std(axis=-1).min()
     s_max_confidence = s_phases.std(axis=-1).min()
 
     print(f"Starting plotting {len(waveforms)} waveforms")
     fig, ax = plt.subplots(ncols=3, figsize=(10, 3))
-
+    
     # Plot topography
-    print("Fetching 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
+    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")
+    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)
+    
+    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)
 
-    output_picks = pd.DataFrame(
-        {
-            "station_name": [],
-            "st_lat": [],
-            "st_lon": [],
-            "starttime": [],
-            "p_phase, s": [],
-            "p_uncertainty, s": [],
-            "s_phase, s": [],
-            "s_uncertainty, s": [],
-            "velocity_p, km/s": [],
-            "velocity_s, km/s": [],
-        }
-    )
-
+    output_picks = pd.DataFrame({'station_name' : [], 
+                                'st_lat' : [], 'st_lon' : [],
+                                 'starttime' : [], 
+                                 'p_phase, s' : [], 'p_uncertainty, s' : [], 
+                                 's_phase, s' : [], 's_uncertainty, s' : [],
+                                 'velocity_p, km/s' : [], 'velocity_s, km/s' : []})
+                        
     for i in range(len(waveforms)):
         print(f"Plotting waveform {i+1}/{len(waveforms)}")
         current_P = p_phases[i]
         current_S = s_phases[i]
-
-        x = [t0s[i] + pd.Timedelta(seconds=k / 100) for k in np.linspace(0, 6000, 6000)]
+        
+        x = [t0s[i] + pd.Timedelta(seconds=k/100) for k in np.linspace(0,6000,6000)]
         x = mdates.date2num(x)
 
         # Normalize confidence for the plot
-        p_conf = 1 / (current_P.std() / p_max_confidence).item()
-        s_conf = 1 / (current_S.std() / s_max_confidence).item()
+        p_conf = 1/(current_P.std()/p_max_confidence).item()
+        s_conf = 1/(current_S.std()/s_max_confidence).item()
 
         delta_t = t0s[i].timestamp - obspy.UTCDateTime(timestamp).timestamp
 
-        ax[0].plot(
-            x,
-            waveforms[i][0, 0] * 10 + distances[i] * 111.2,
-            color="black",
-            alpha=0.5,
-            lw=1,
-        )
-
-        if (current_P.std().item() * 60 < conf_thres_P) or (
-            current_S.std().item() * 60 < conf_thres_S
-        ):
-            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="|",
-            )
-            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="|",
-            )
+        ax[0].plot(x, waveforms[i][0, 0]*10+distances[i]*111.2, color='black', alpha=0.5, lw=1)
 
-            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()
+        if (current_P.std().item()*60 < conf_thres_P) or (current_S.std().item()*60 < conf_thres_S):
+            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='|')
+            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='|')
+        
+            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()
 
             # 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.1, vmin=0, vmax=8
-            )
-            ax[2].scatter(
-                x, y, c=np.zeros_like(x) + velocity_s, alpha=0.1, vmin=0, vmax=8
-            )
+            ax[1].scatter(x, y, c=np.zeros_like(x)+velocity_p, alpha=0.1, vmin=0, vmax=8)
+            ax[2].scatter(x, y, c=np.zeros_like(x)+velocity_s, alpha=0.1, vmin=0, vmax=8)
 
         else:
             velocity_p = np.nan
             velocity_s = np.nan
-
-        ax[0].set_ylabel("Z")
-        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]],
-                    "st_lat": [st_lats[i]],
-                    "st_lon": [st_lons[i]],
-                    "starttime": [str(t0s[i])],
-                    "p_phase, s": [(delta_t + current_P.mean() * 60).item()],
-                    "p_uncertainty, s": [current_P.std().item() * 60],
-                    "s_phase, s": [(delta_t + current_S.mean() * 60).item()],
-                    "s_uncertainty, s": [current_S.std().item() * 60],
-                    "velocity_p, km/s": [velocity_p],
-                    "velocity_s, km/s": [velocity_s],
-                }
-            )
-        )
-
+        
+        ax[0].set_ylabel('Z')
+        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]], 
+                                                        'st_lat' : [st_lats[i]], 'st_lon' : [st_lons[i]],
+                                                        'starttime' : [str(t0s[i])], 
+                                                        'p_phase, s' : [(delta_t+current_P.mean()*60).item()], 'p_uncertainty, s' : [current_P.std().item()*60], 
+                                                        's_phase, s' : [(delta_t+current_S.mean()*60).item()], 's_uncertainty, s' : [current_S.std().item()*60],
+                                                        'velocity_p, km/s' : [velocity_p], 'velocity_s, km/s' : [velocity_s]}))
+        
+        
     # Add legend
-    ax[0].scatter(None, None, color="r", marker="|", label="P")
-    ax[0].scatter(None, None, color="b", marker="|", label="S")
-    ax[0].xaxis.set_major_formatter(mdates.DateFormatter("%H:%M:%S"))
+    ax[0].scatter(None, None, color='r', marker='|', label='P')
+    ax[0].scatter(None, None, color='b', marker='|', label='S')
+    ax[0].xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))
     ax[0].xaxis.set_major_locator(mdates.SecondLocator(interval=20))
     ax[0].legend()
 
-    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")
-        ax[i].set_aspect("equal")
-        ax[i].set_xticklabels(ax[i].get_xticks(), rotation=50)
-
-    fig.subplots_adjust(
-        bottom=0.1, top=0.9, left=0.1, right=0.8, wspace=0.02, hspace=0.02
-    )
+    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')
+        ax[i].set_aspect('equal')
+        ax[i].set_xticklabels(ax[i].get_xticks(), rotation = 50)
 
+    fig.subplots_adjust(bottom=0.1, top=0.9, left=0.1, right=0.8,
+                    wspace=0.02, hspace=0.02)
+    
     cb_ax = fig.add_axes([0.83, 0.1, 0.02, 0.8])
-    cbar = fig.colorbar(
-        ax[2].scatter(None, None, c=velocity_p, alpha=0.5, vmin=0, vmax=8), cax=cb_ax
-    )
+    cbar = fig.colorbar(ax[2].scatter(None, None, c=velocity_p, alpha=0.5, vmin=0, vmax=8), cax=cb_ax)
 
-    cbar.set_label("Velocity (km/s)")
-    ax[1].set_title("P Velocity")
-    ax[2].set_title("S Velocity")
+    cbar.set_label('Velocity (km/s)')
+    ax[1].set_title('P Velocity')
+    ax[2].set_title('S Velocity')
 
     for a in ax:
-        a.tick_params(axis="both", which="major", labelsize=8)
-
-    plt.subplots_adjust(hspace=0.0, wspace=0.5)
-    fig.canvas.draw()
+        a.tick_params(axis='both', which='major', labelsize=8)
+        
+    plt.subplots_adjust(hspace=0., wspace=0.5)
+    fig.canvas.draw();
     image = np.array(fig.canvas.renderer.buffer_rgba())
     plt.close(fig)
-    output_picks.to_csv(
-        f"data/velocity/{eq_lat}_{eq_lon}_{timestamp}_{len(waveforms)}.csv", index=False
-    )
-    output_csv = f"data/velocity/{eq_lat}_{eq_lon}_{timestamp}_{len(waveforms)}.csv"
 
+    output_csv = f'data/velocity/{eq_lat}_{eq_lon}_{source_depth_km}_{timestamp}_{len(waveforms)}.csv'
+    output_picks.to_csv(output_csv, index=False)
+    
     return image, output_picks, output_csv
 
+import numpy as np
+from matplotlib import colors, cm
+
+# Function to find the closest index for a given value in an array
+def find_closest_index(array, value):
+    return np.argmin(np.abs(array - value))
+
+def compute_velocity_model(azimuth, elevation):
+    filename = list(output_csv.temp_files)[0]
+    
+    df = pd.read_csv(filename)
+    print(df)
+    filename = filename.split('/')[-1]
+    
+    # Current EQ location
+    eq_lat = float(filename.split("_")[0])
+    eq_lon = float(filename.split("_")[1])
+    eq_depth = float(filename.split("_")[2])
+
+    # Define the region of interest (latitude, longitude, and depth ranges)
+    lat_range = (np.min([df.st_lat.min(), eq_lat]), np.max([df.st_lat.max(), eq_lat]))
+    lon_range = (np.min([df.st_lon.min(), eq_lon]),  np.max([df.st_lon.max(), eq_lon]))
+    depth_range = (0, 50)
+
+    # Define the number of nodes in each dimension
+    n_lat = 10
+    n_lon = 10
+    n_depth = 10
+    num_points = 100
+
+    # Create the grid
+    lat_values = np.linspace(lat_range[0], lat_range[1], n_lat)
+    lon_values = np.linspace(lon_range[0], lon_range[1], n_lon)
+    depth_values = np.linspace(depth_range[0], depth_range[1], n_depth)
+
+    # Initialize the velocity model with constant values
+    initial_velocity = 0  # km/s, this can be P-wave or S-wave velocity
+    velocity_model = np.full((n_lat, n_lon, n_depth), initial_velocity, dtype=float)
+
+    # Loop through the stations and update the velocity model
+    for i in range(len(df)):
+        if ~np.isnan(df['velocity_p, km/s'].iloc[i]):
+            # Interpolate coordinates along the great circle path between the earthquake and the station
+            lon_deg = np.linspace(df.st_lon.iloc[i], eq_lon, num_points)
+            lat_deg = np.linspace(df.st_lat.iloc[i], eq_lat, num_points)
+            depth_interpolated = np.interp(np.linspace(0, 1, num_points), [0, 1], [eq_depth, 0])
+
+            # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity
+            for lat, lon, depth in zip(lat_deg, lon_deg, depth_interpolated):
+                lat_index = find_closest_index(lat_values, lat)
+                lon_index = find_closest_index(lon_values, lon)
+                depth_index = find_closest_index(depth_values, depth)
+                
+                if velocity_model[lat_index, lon_index, depth_index] == initial_velocity:
+                    velocity_model[lat_index, lon_index, depth_index] = df['velocity_p, km/s'].iloc[i]
+                else:
+                    velocity_model[lat_index, lon_index, depth_index] = (velocity_model[lat_index, lon_index, depth_index] +
+                                                                        df['velocity_p, km/s'].iloc[i]) / 2
+                    
+    # Create the figure and axis
+    fig = plt.figure(figsize=(8, 8))
+    ax = fig.add_subplot(111, projection='3d')
+
+    # Set the plot limits
+    ax.set_xlim3d(lat_range[0], lat_range[1])
+    ax.set_ylim3d(lon_range[0], lon_range[1])
+    ax.set_zlim3d(depth_range[1], depth_range[0])
+
+    ax.set_xlabel('Latitude')
+    ax.set_ylabel('Longitude')
+    ax.set_zlabel('Depth (km)')
+    ax.set_title('Velocity Model')
+    
+    # Create the meshgrid
+    x, y, z = np.meshgrid(
+        np.linspace(lat_range[0], lat_range[1], velocity_model.shape[0]+1),
+        np.linspace(lon_range[0], lon_range[1], velocity_model.shape[1]+1),
+        np.linspace(depth_range[0], depth_range[1], velocity_model.shape[2]+1),
+        indexing='ij'
+    )
+
+    # Create the color array
+    norm = plt.Normalize(vmin=velocity_model.min(), vmax=velocity_model.max())
+    colors = plt.cm.plasma(norm(velocity_model))
+
+    # Plot the voxels
+    ax.voxels(x, y, z, velocity_model > 0, facecolors=colors, alpha=0.5, edgecolor='k')
+
+    # Set the view angle
+    ax.view_init(elev=elevation, azim=azimuth)
+
+    m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)
+    m.set_array([])
+    plt.colorbar(m)
+
+    # Show the plot
+    fig.canvas.draw();
+    image = np.array(fig.canvas.renderer.buffer_rgba())
+    plt.close(fig)
+
+    return image
 
 model = torch.jit.load("model.pt")
 
 with gr.Blocks() as demo:
-    gr.HTML(
-        """
+    gr.HTML("""
 <div style="padding: 20px; border-radius: 10px;">
     <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>
 
@@ -571,210 +540,177 @@ with gr.Blocks() as demo:
         <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>
     </ul>
 </div>
-"""
-    )
-
+""")
     with gr.Tab("Try on a single station"):
-        with gr.Row():
+        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",
+                ["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",
+                value = "data/sample/sample_0.npy"
             )
             with gr.Column(scale=1):
-                P_thres_inputs = gr.Slider(
-                    minimum=0.01,
-                    maximum=1,
-                    value=0.1,
-                    label="P uncertainty threshold, s",
-                    step=0.01,
-                    info="Acceptable uncertainty for P picks expressed in std() seconds",
-                    interactive=True,
-                )
-
-                S_thres_inputs = gr.Slider(
-                    minimum=0.01,
-                    maximum=1,
-                    value=0.2,
-                    label="S uncertainty threshold, s",
-                    step=0.01,
-                    info="Acceptable uncertainty for S picks expressed in std() seconds",
-                    interactive=True,
-                )
+                P_thres_inputs = gr.Slider(minimum=0.01,
+                                    maximum=1,
+                                    value=0.1,
+                                    label="P uncertainty threshold, s",
+                                    step=0.01,
+                                    info="Acceptable uncertainty for P picks expressed in std() seconds",
+                                    interactive=True,
+                                    )
+                
+                S_thres_inputs = gr.Slider(minimum=0.01,
+                                    maximum=1,
+                                    value=0.2,
+                                    label="S uncertainty threshold, s",
+                                    step=0.01,
+                                    info="Acceptable uncertainty for S picks expressed in std() seconds",
+                                    interactive=True,
+                                    )
             with gr.Column(scale=1):
                 upload = gr.File(label="Or upload your own waveform")
-                sampling_rate_inputs = gr.Slider(
-                    minimum=10,
-                    maximum=1000,
-                    value=100,
-                    label="Samlping rate, Hz",
-                    step=10,
-                    info="Sampling rate of the waveform",
-                    interactive=True,
-                )
+                sampling_rate_inputs = gr.Slider(minimum=10,
+                        maximum=1000,
+                        value=100,
+                        label="Samlping rate, Hz",
+                        step=10,
+                        info="Sampling rate of the waveform",
+                        interactive=True,
+                        )
 
         button = gr.Button("Predict phases")
-        outputs = gr.Image(
-            label="Waveform with Phases Marked", type="numpy", interactive=False
-        )
-
-        button.click(
-            mark_phases,
-            inputs=[
-                inputs,
-                upload,
-                P_thres_inputs,
-                S_thres_inputs,
-                sampling_rate_inputs,
-            ],
-            outputs=outputs,
-        )
-
+        outputs = gr.Image(label='Waveform with Phases Marked', type='numpy', interactive=False)
+    
+        button.click(mark_phases, inputs=[inputs, upload, 
+                                          P_thres_inputs, S_thres_inputs,
+                                          sampling_rate_inputs], 
+                                          outputs=outputs)    
     with gr.Tab("Select earthquake from catalogue"):
 
-        gr.HTML(
-            """
+        gr.HTML("""
         <div style="padding: 20px; border-radius: 10px; font-size: 16px;">
         <p style="font-weight: bold; font-size: 24px; margin-bottom: 20px;">Using PhaseHunter to Analyze Seismic Waveforms</p>
         <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>
         <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>
         <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>
         </div>
-        """
-        )
-        with gr.Row():
+        """)
+        with gr.Row(): 
             with gr.Column(scale=2):
                 client_inputs = gr.Dropdown(
-                    choices=list(URL_MAPPINGS.keys()),
-                    label="FDSN Client",
+                    choices = list(URL_MAPPINGS.keys()), 
+                    label="FDSN Client", 
                     info="Select one of the available FDSN clients",
-                    value="IRIS",
-                    interactive=True,
+                    value = "IRIS",
+                    interactive=True
                 )
 
                 velocity_inputs = gr.Dropdown(
-                    choices=[
-                        "1066a",
-                        "1066b",
-                        "ak135",
-                        "ak135f",
-                        "herrin",
-                        "iasp91",
-                        "jb",
-                        "prem",
-                        "pwdk",
-                    ],
-                    label="1D velocity model",
+                    choices = ['1066a', '1066b', 'ak135', 
+                            'ak135f', 'herrin', 'iasp91', 
+                            'jb', 'prem', 'pwdk'], 
+                    label="1D velocity model", 
                     info="Velocity model for station selection",
-                    value="1066a",
-                    interactive=True,
+                    value = "1066a",
+                    interactive=True
                 )
 
             with gr.Column(scale=2):
-                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,
-                )
-
-                source_depth_inputs = gr.Number(
-                    value=10,
+                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)
+                
+                source_depth_inputs = gr.Number(value=10,
                     label="Source depth (km)",
                     info="Depth of the earthquake",
-                    interactive=True,
-                )
-
+                    interactive=True)
+                
             with gr.Column(scale=2):
-                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,
-                )
-
+                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)
+                
             with gr.Column(scale=2):
-                radius_inputs = gr.Slider(
-                    minimum=1,
-                    maximum=200,
-                    value=50,
-                    label="Radius (km)",
-                    step=10,
-                    info="""Select the radius around the earthquake to download data from.\n 
+                radius_inputs = gr.Slider(minimum=1, 
+                                        maximum=200, 
+                                        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,
-                )
+                                        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=2):
-                P_thres_inputs = gr.Slider(
-                    minimum=0.01,
-                    maximum=1,
-                    value=0.1,
-                    label="P uncertainty threshold, s",
-                    step=0.01,
-                    info="Acceptable uncertainty for P picks expressed in std() seconds",
-                    interactive=True,
-                )
-                S_thres_inputs = gr.Slider(
-                    minimum=0.01,
-                    maximum=1,
-                    value=0.2,
-                    label="S uncertainty threshold, s",
-                    step=0.01,
-                    info="Acceptable uncertainty for S picks expressed in std() seconds",
-                    interactive=True,
-                )
-
+                P_thres_inputs = gr.Slider(minimum=0.01,
+                                maximum=1,
+                                value=0.1,
+                                label="P uncertainty threshold, s",
+                                step=0.01,
+                                info="Acceptable uncertainty for P picks expressed in std() seconds",
+                                interactive=True,
+                                )
+                S_thres_inputs = gr.Slider(minimum=0.01,
+                                maximum=1,
+                                value=0.2,
+                                label="S uncertainty threshold, s",
+                                step=0.01,
+                                info="Acceptable uncertainty for S picks expressed in std() seconds",
+                                interactive=True,
+                                )
+            
         button = gr.Button("Predict phases")
-        output_image = gr.Image(
-            label="Waveforms with Phases Marked", type="numpy", interactive=False
-        )
+        output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)
 
         with gr.Row():
-            output_picks = gr.Dataframe(
-                label="Pick data", type="pandas", interactive=False
-            )
+            output_picks = gr.Dataframe(label='Pick data', 
+                                        type='pandas', 
+                                        interactive=False)
             output_csv = gr.File(label="Output File", file_types=[".csv"])
 
-        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,
-                P_thres_inputs,
-                S_thres_inputs,
-            ],
-            outputs=[output_image, output_picks, output_csv],
-        )
-
-demo.launch()
+        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,
+                         P_thres_inputs, S_thres_inputs],
+                 outputs=[output_image, output_picks, output_csv])
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                inputs_vel_model = [
+                    ## FIX FILE NAME ISSUE
+                    gr.Slider(minimum=-180, maximum=180, value=0, step=5, label="Azimuth", interactive=True),
+                    gr.Slider(minimum=-90, maximum=90, value=30, step=5, label="Elevation", interactive=True)
+                ]
+                button = gr.Button("Look at 3D Velocities")
+            outputs_vel_model = gr.Image(label="3D Velocity Model")
+
+            button.click(compute_velocity_model, 
+                         inputs=inputs_vel_model, 
+                         outputs=outputs_vel_model)
+
+
+            
+
+
+demo.launch()

data/velocity/35.766_-117.605_10.0_2019-07-04 17:33:49_3.csv

@@ -0,0 +1,4 @@
+station_name,st_lat,st_lon,starttime,"p_phase, s","p_uncertainty, s","s_phase, s","s_uncertainty, s","velocity_p, km/s","velocity_s, km/s"
+CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.320212364196777,0.020417090272530913,13.38510799407959,0.028438671142794192,4.13660431013202,2.2622770044299756
+CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.53201961517334,0.01748959010001272,9.215676307678223,0.019567650742828846,3.4155476453388767,1.67967367867923
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.504384994506836,0.015920251607894897,17.03156852722168,0.04673808580264449,4.745724852828504,2.6483289549749593

data/velocity/35.766_-117.605_2019-07-04 17:33:49_3.csv

@@ -1,4 +1,4 @@
 station_name,st_lat,st_lon,starttime,"p_phase, s","p_uncertainty, s","s_phase, s","s_uncertainty, s","velocity_p, km/s","velocity_s, km/s"
-CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.52931022644043,0.014338254695758224,9.210612297058105,0.013868825335521251,3.417590792273917,1.6805971661817796
-CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.320904731750488,0.018777401419356465,13.390795707702637,0.037158007035031915,4.136213094741051,2.261316106809097
-CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.504384994506836,0.01592034415807575,17.031570434570312,0.04673818708397448,4.745724852828504,2.6483286583912338
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.503650665283203,0.016685163136571646,17.022592544555664,0.04997979383915663,4.746091546067712,2.649725414106055
+CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.53201961517334,0.01748959010001272,9.215676307678223,0.019567650742828846,3.4155476453388767,1.67967367867923
+CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.3213396072387695,0.014792646397836506,13.395279884338379,0.02523316943552345,4.135967410510336,2.2605591132307814

data/velocity/current_vel_model.csv

@@ -0,0 +1,4 @@
+station_name,st_lat,st_lon,starttime,"p_phase, s","p_uncertainty, s","s_phase, s","s_uncertainty, s","velocity_p, km/s","velocity_s, km/s"
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.503650665283203,0.016685163136571646,17.022592544555664,0.04997979383915663,4.746091546067712,2.649725414106055
+CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.53201961517334,0.01748959010001272,9.215676307678223,0.019567650742828846,3.4155476453388767,1.67967367867923
+CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.3213396072387695,0.014792646397836506,13.395279884338379,0.02523316943552345,4.135967410510336,2.2605591132307814