WIP on section plot

Gradio_app.ipynb

@@ -0,0 +1,506 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inventory created at 2023-03-31T20:48:41.380800Z\n",
+      "\tCreated by: IRIS WEB SERVICE: fdsnws-station | version: 1.1.52\n",
+      "\t\t    http://service.iris.edu/fdsnws/station/1/query?starttime=2019-07-...\n",
+      "\tSending institution: IRIS-DMC (IRIS-DMC)\n",
+      "\tContains:\n",
+      "\t\tNetworks (7):\n",
+      "\t\t\t8P, CI, LB, NN, NP, PB, SY\n",
+      "\t\tStations (85):\n",
+      "\t\t\t8P.CAU08 (Monache Meadows, CA, USA)\n",
+      "\t\t\tCI.APL (Apollo)\n",
+      "\t\t\tCI.CCA (California City Airport)\n",
+      "\t\t\tCI.CCC (Christmas Canyon China Lake)\n",
+      "\t\t\tCI.CGO (Cerro Gordo)\n",
+      "\t\t\tCI.CLC (China Lake)\n",
+      "\t\t\tCI.CWC (Cottonwood Creek)\n",
+      "\t\t\tCI.DAW (Darwin)\n",
+      "\t\t\tCI.DTP (Desert Tortoise Park)\n",
+      "\t\t\tCI.GSC (Goldstone)\n",
+      "\t\t\tCI.HAR (Harper Dry Lake bed)\n",
+      "\t\t\tCI.ISA (Isabella)\n",
+      "\t\t\tCI.JRC2 (Joshua Ridge: China Lake)\n",
+      "\t\t\tCI.LMR2 (Leuhmann Ridge Extension)\n",
+      "\t\t\tCI.LRL (Laurel Mtn)\n",
+      "\t\t\tCI.MPM (Manuel Prospect Mine)\n",
+      "\t\t\tCI.MRS (Mars)\n",
+      "\t\t\tCI.Q0068 (Redwood Blvd, California City CA)\n",
+      "\t\t\tCI.Q0072 (Lakeland Street, Ridgecrest CA)\n",
+      "\t\t\tCI.SLA (Slate Mountain)\n",
+      "\t\t\tCI.SRT (Snort)\n",
+      "\t\t\tCI.TEH (Cattani Ranch)\n",
+      "\t\t\tCI.TOW2 (Tower 2)\n",
+      "\t\t\tCI.WAS2 (Alta Sierra 2)\n",
+      "\t\t\tCI.WBM (Bowman Road)\n",
+      "\t\t\tCI.WBS (Bird Springs)\n",
+      "\t\t\tCI.WCS2 (Coso Hot Springs 2)\n",
+      "\t\t\tCI.WHF (Hanning Flat)\n",
+      "\t\t\tCI.WLH2 (Little Horse 2)\n",
+      "\t\t\tCI.WMF (Mccloud Flat)\n",
+      "\t\t\tCI.WNM (Nine Mile Canyon)\n",
+      "\t\t\tCI.WOR (Onyx Ranch)\n",
+      "\t\t\tCI.WRC2 (Renegade Canyon)\n",
+      "\t\t\tCI.WRV2 (Rose Valley Canyon 2)\n",
+      "\t\t\tCI.WVP2 (Volcano Peak 2)\n",
+      "\t\t\tLB.DAC (Inyo County, Darwin, CA, USA)\n",
+      "\t\t\tNN.GWY (Greenwater Valley, CA. (GPS 12/06/2000) w84gm)\n",
+      "\t\t\tNN.PAN (Panamint Range. (GPS 12/06/2000) w84gm)\n",
+      "\t\t\tNN.QSM (Queen of Sheba Mine, CA. (GPS 01/17/2001)   w84gm)\n",
+      "\t\t\tNP.1035 (CA:Lake Isabella Dam)\n",
+      "\t\t\tNP.1809 (CA:Haiwee Rsvr;Pump Pl)\n",
+      "\t\t\tNP.5419 (CA:China Lake;Nav Weapon Ctr)\n",
+      "\t\t\tPB.B916 (marips916bcs2008, China Lake, CA, USA)\n",
+      "\t\t\tPB.B917 (tonyso917bcs2008, China Lake, CA, USA)\n",
+      "\t\t\tPB.B918 (mtsprn918bcs2008, China Lake, CA, USA)\n",
+      "\t\t\tPB.B921 (randsb921bcs2008, China Lake, CA, USA)\n",
+      "\t\t\tSY.CCA (CCA synthetic)\n",
+      "\t\t\tSY.CCC (CCC synthetic)\n",
+      "\t\t\tSY.CGO (CGO synthetic)\n",
+      "\t\t\tSY.CLC (CLC synthetic)\n",
+      "\t\t\tSY.CWC (CWC synthetic)\n",
+      "\t\t\tSY.DAC (DAC synthetic)\n",
+      "\t\t\tSY.DAW (DAW synthetic)\n",
+      "\t\t\tSY.DTP (DTP synthetic)\n",
+      "\t\t\tSY.FPC (FPC synthetic)\n",
+      "\t\t\tSY.FSR (FSR synthetic)\n",
+      "\t\t\tSY.GPO (GPO synthetic)\n",
+      "\t\t\tSY.GSC (GSC synthetic)\n",
+      "\t\t\tSY.HAR (HAR synthetic)\n",
+      "\t\t\tSY.ISA (ISA synthetic)\n",
+      "\t\t\tSY.JRC (JRC synthetic)\n",
+      "\t\t\tSY.JRC2 (JRC2 synthetic)\n",
+      "\t\t\tSY.KRV3 (KRV3 synthetic)\n",
+      "\t\t\tSY.LMR (LMR synthetic)\n",
+      "\t\t\tSY.LMR2 (LMR2 synthetic)\n",
+      "\t\t\tSY.LRL (LRL synthetic)\n",
+      "\t\t\tSY.MPM (MPM synthetic)\n",
+      "\t\t\tSY.OVRO (OVRO synthetic)\n",
+      "\t\t\tSY.RRC (RRC synthetic)\n",
+      "\t\t\tSY.SEV (SEV synthetic)\n",
+      "\t\t\tSY.SLA (SLA synthetic)\n",
+      "\t\t\tSY.SRT (SRT synthetic)\n",
+      "\t\t\tSY.TEH (TEH synthetic)\n",
+      "\t\t\tSY.TOW2 (TOW2 synthetic)\n",
+      "\t\t\tSY.WAS2 (WAS2 synthetic)\n",
+      "\t\t\tSY.WBM (WBM synthetic)\n",
+      "\t\t\tSY.WBP (WBP synthetic)\n",
+      "\t\t\tSY.WBS (WBS synthetic)\n",
+      "\t\t\tSY.WCS2 (WCS2 synthetic)\n",
+      "\t\t\tSY.WHF (WHF synthetic)\n",
+      "\t\t\tSY.WLH2 (WLH2 synthetic)\n",
+      "\t\t\tSY.WMF (WMF synthetic)\n",
+      "\t\t\tSY.WNM (WNM synthetic)\n",
+      "\t\t\tSY.WOR (WOR synthetic)\n",
+      "\t\t\tSY.WRC2 (WRC2 synthetic)\n",
+      "\t\tChannels (0):\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import obspy\n",
+    "from obspy.clients.fdsn import Client\n",
+    "\n",
+    "client_name = 'SCEDC'\n",
+    "radius_km = 100\n",
+    "timestamp = '2019-07-04 17:33:49'\n",
+    "eq_lat = 35.766\n",
+    "eq_lon = -117.605\n",
+    "\n",
+    "origin_time = obspy.UTCDateTime(timestamp)\n",
+    "\n",
+    "client = Client(\"IRIS\")\n",
+    "inventory = client.get_stations(network=\"*\", station=\"*\", channel=\"*\",\n",
+    "                                starttime=origin_time, endtime=origin_time + 120,\n",
+    "                                latitude=eq_lat, longitude=eq_lon, maxradius=radius_km/111.2)\n",
+    "print(inventory)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "client = Client(client_name)\n",
+    "window = radius_km / 111.2\n",
+    "\n",
+    "assert eq_lat - window > -90 and eq_lat + window < 90, \"Latitude out of bounds\"\n",
+    "assert eq_lon - window > -180 and eq_lon + window < 180, \"Longitude out of bounds\"\n",
+    "\n",
+    "starttime = obspy.UTCDateTime(timestamp)\n",
+    "endtime = starttime + 120\n",
+    "\n",
+    "inv = client.get_stations(network=\"*\", station=\"*\", location=\"*\", channel=\"*H*\", \n",
+    "                        starttime=starttime, endtime=endtime, \n",
+    "                        minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),\n",
+    "                        minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), \n",
+    "                        level='station')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/anovosel/miniconda3/envs/phasehunter/lib/python3.11/site-packages/gradio/outputs.py:43: UserWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7914\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7914/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([256])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Gradio app that takes seismic waveform as input and marks 2 phases on the waveform as output.\n",
+    "\n",
+    "import gradio as gr\n",
+    "import numpy as np\n",
+    "from phasehunter.model import Onset_picker, Updated_onset_picker\n",
+    "from phasehunter.data_preparation import prepare_waveform\n",
+    "import torch\n",
+    "\n",
+    "from scipy.stats import gaussian_kde\n",
+    "\n",
+    "import obspy\n",
+    "from obspy.clients.fdsn import Client\n",
+    "from obspy.clients.fdsn.header import FDSNNoDataException, FDSNTimeoutException, FDSNInternalServerException\n",
+    "from obspy.geodetics.base import locations2degrees\n",
+    "from obspy.taup import TauPyModel\n",
+    "from obspy.taup.helper_classes import SlownessModelError\n",
+    "\n",
+    "from obspy.clients.fdsn.header import URL_MAPPINGS\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def make_prediction(waveform):\n",
+    "    waveform = np.load(waveform)\n",
+    "    processed_input = prepare_waveform(waveform)\n",
+    "    \n",
+    "    # Make prediction\n",
+    "    with torch.no_grad():\n",
+    "        output = model(processed_input)\n",
+    "\n",
+    "    p_phase = output[:, 0]\n",
+    "    s_phase = output[:, 1]\n",
+    "\n",
+    "    return processed_input, p_phase, s_phase\n",
+    "\n",
+    "def mark_phases(waveform):\n",
+    "    processed_input, p_phase, s_phase = make_prediction(waveform)\n",
+    "\n",
+    "    # Create a plot of the waveform with the phases marked\n",
+    "    if sum(processed_input[0][2] == 0): #if input is 1C\n",
+    "        fig, ax = plt.subplots(nrows=2, figsize=(10, 2), sharex=True)\n",
+    "\n",
+    "        ax[0].plot(processed_input[0][0])\n",
+    "        ax[0].set_ylabel('Norm. Ampl.')\n",
+    "\n",
+    "    else: #if input is 3C\n",
+    "        fig, ax = plt.subplots(nrows=4, figsize=(10, 6), sharex=True)\n",
+    "        ax[0].plot(processed_input[0][0])\n",
+    "        ax[1].plot(processed_input[0][1])\n",
+    "        ax[2].plot(processed_input[0][2])\n",
+    "\n",
+    "        ax[0].set_ylabel('Z')\n",
+    "        ax[1].set_ylabel('N')\n",
+    "        ax[2].set_ylabel('E')\n",
+    "\n",
+    "    p_phase_plot = p_phase*processed_input.shape[-1]\n",
+    "    p_kde = gaussian_kde(p_phase_plot)\n",
+    "    p_dist_space = np.linspace( min(p_phase_plot)-10, max(p_phase_plot)+10, 500 )\n",
+    "    ax[-1].plot( p_dist_space, p_kde(p_dist_space), color='r')\n",
+    "\n",
+    "    s_phase_plot = s_phase*processed_input.shape[-1]\n",
+    "    s_kde = gaussian_kde(s_phase_plot)\n",
+    "    s_dist_space = np.linspace( min(s_phase_plot)-10, max(s_phase_plot)+10, 500 )\n",
+    "    ax[-1].plot( s_dist_space, s_kde(s_dist_space), color='b')\n",
+    "\n",
+    "    for a in ax:\n",
+    "        a.axvline(p_phase.mean()*processed_input.shape[-1], color='r', linestyle='--', label='P')\n",
+    "        a.axvline(s_phase.mean()*processed_input.shape[-1], color='b', linestyle='--', label='S')\n",
+    "\n",
+    "    ax[-1].set_xlabel('Time, samples')\n",
+    "    ax[-1].set_ylabel('Uncert.')\n",
+    "    ax[-1].legend()\n",
+    "\n",
+    "    plt.subplots_adjust(hspace=0., wspace=0.)\n",
+    "\n",
+    "    # Convert the plot to an image and return it\n",
+    "    fig.canvas.draw()\n",
+    "    image = np.array(fig.canvas.renderer.buffer_rgba())\n",
+    "    plt.close(fig)\n",
+    "    return image\n",
+    "\n",
+    "def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source_depth_km, velocity_model):\n",
+    "    distances, t0s, st_lats, st_lons, waveforms = [], [], [], [], []\n",
+    "    \n",
+    "    taup_model = TauPyModel(model=velocity_model)\n",
+    "    client = Client(client_name)\n",
+    "\n",
+    "    window = radius_km / 111.2\n",
+    "\n",
+    "    assert eq_lat - window > -90 and eq_lat + window < 90, \"Latitude out of bounds\"\n",
+    "    assert eq_lon - window > -180 and eq_lon + window < 180, \"Longitude out of bounds\"\n",
+    "\n",
+    "    starttime = obspy.UTCDateTime(timestamp)\n",
+    "    endtime = starttime + 120\n",
+    "\n",
+    "    inv = client.get_stations(network=\"*\", station=\"*\", location=\"*\", channel=\"*H*\", \n",
+    "                          starttime=starttime, endtime=endtime, \n",
+    "                          minlatitude=(eq_lat-window), maxlatitude=(eq_lat+window),\n",
+    "                          minlongitude=(eq_lon-window), maxlongitude=(eq_lon+window), \n",
+    "                          level='station')\n",
+    "    \n",
+    "    waveforms = []\n",
+    "    for network in inv:\n",
+    "        for station in network:\n",
+    "            try:\n",
+    "                distance = locations2degrees(eq_lat, eq_lon, station.latitude, station.longitude)\n",
+    "\n",
+    "                arrivals = taup_model.get_travel_times(source_depth_in_km=source_depth_km, \n",
+    "                                                       distance_in_degree=distance, \n",
+    "                                                       phase_list=[\"P\", \"S\"])\n",
+    "\n",
+    "                if len(arrivals) > 0:\n",
+    "\n",
+    "                    starttime = obspy.UTCDateTime(timestamp) + arrivals[0].time - 15\n",
+    "                    endtime = starttime + 60\n",
+    "\n",
+    "                    waveform = client.get_waveforms(network=network.code, station=station.code, location=\"*\", channel=\"*\", \n",
+    "                                                starttime=starttime, endtime=endtime)\n",
+    "                    \n",
+    "                    waveform = waveform.select(channel=\"H[BH][ZNE]\")\n",
+    "                    waveform = waveform.merge(fill_value=0)\n",
+    "                    waveform = waveform[:3]\n",
+    "                    \n",
+    "                    len_check = [len(x.data) for x in waveform]\n",
+    "                    if len(set(len_check)) > 1:\n",
+    "                        continue\n",
+    "\n",
+    "                    if len(waveform) == 3:\n",
+    "                        waveform = prepare_waveform(np.stack([x.data for x in waveform]))\n",
+    "                    \n",
+    "                        distances.append(distance)\n",
+    "                        t0s.append(starttime)\n",
+    "                        st_lats.append(station.latitude)\n",
+    "                        st_lons.append(station.longitude)\n",
+    "                        waveforms.append(waveform)\n",
+    "\n",
+    "            except (IndexError, FDSNNoDataException, FDSNTimeoutException):\n",
+    "                continue\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        waveforms_torch = torch.vstack(waveforms)\n",
+    "        output = model(waveforms_torch)\n",
+    "\n",
+    "    p_phases = output[:, 0]\n",
+    "    s_phases = output[:, 1]\n",
+    "\n",
+    "\n",
+    "    print(p_phases.shape)\n",
+    "    # for i in range(len(waveforms)):\n",
+    "    #     current_P = P_batch[i::len(waveforms)].cpu()\n",
+    "    #     current_S_batch = S_batch[i::len(waveforms)].cpu()\n",
+    "    #     current_Pg_batch = Pg_batch[i::len(waveforms)].cpu()\n",
+    "    #     current_Sg_batch = Sg_batch[i::len(waveforms)].cpu()\n",
+    "    #     current_Pn_batch = Pn_batch[i::len(waveforms)].cpu()\n",
+    "    #     current_Sn_batch = Sn_batch[i::len(waveforms)].cpu()\n",
+    "    \n",
+    "    fig,ax = plt.subplots()\n",
+    "    ax.scatter(st_lats, st_lons)\n",
+    "    fig.canvas.draw()\n",
+    "    image = np.array(fig.canvas.renderer.buffer_rgba())\n",
+    "    plt.close(fig)\n",
+    "\n",
+    "    return image\n",
+    "\n",
+    "\n",
+    "model = Onset_picker.load_from_checkpoint(\"./weights.ckpt\",\n",
+    "                                 picker=Updated_onset_picker(),\n",
+    "                                    learning_rate=3e-4)\n",
+    "model.eval()\n",
+    "\n",
+    "\n",
+    "\n",
+    "# # Create the Gradio interface\n",
+    "# gr.Interface(mark_phases, inputs, outputs, title='PhaseHunter').launch()\n",
+    "\n",
+    "\n",
+    "with gr.Blocks() as demo:\n",
+    "    gr.Markdown(\"# PhaseHunter\")\n",
+    "    gr.Markdown(\"\"\"This app allows one to detect P and S seismic phases along with uncertainty of the detection. \n",
+    "            The app can be used in three ways: either by selecting one of the sample waveforms;\n",
+    "                                                or by selecting an earthquake from the global earthquake catalogue;\n",
+    "                                                or by uploading a waveform of interest.\n",
+    "            \"\"\")\n",
+    "    with gr.Tab(\"Default example\"):\n",
+    "        # Define the input and output types for Gradio\n",
+    "        inputs = gr.Dropdown(\n",
+    "            [\"data/sample/sample_0.npy\", \n",
+    "            \"data/sample/sample_1.npy\", \n",
+    "            \"data/sample/sample_2.npy\"], \n",
+    "            label=\"Sample waveform\", \n",
+    "            info=\"Select one of the samples\",\n",
+    "            value = \"data/sample/sample_0.npy\"\n",
+    "        )\n",
+    "\n",
+    "        button = gr.Button(\"Predict phases\")\n",
+    "        outputs = gr.outputs.Image(label='Waveform with Phases Marked', type='numpy')\n",
+    "    \n",
+    "        button.click(mark_phases, inputs=inputs, outputs=outputs)\n",
+    "        \n",
+    "    with gr.Tab(\"Select earthquake from catalogue\"):\n",
+    "        gr.Markdown('TEST')\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",
+    "        with gr.Row(): \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",
+    "                                    info=\"Select the radius around the earthquake to download data from\",\n",
+    "                                    interactive=True)\n",
+    "            \n",
+    "            velocity_inputs = gr.Dropdown(\n",
+    "                choices = ['1066a', '1066b', 'ak135', 'ak135f', 'herrin', 'iasp91', 'jb', 'prem', 'pwdk'], \n",
+    "                label=\"1D velocity model\", \n",
+    "                info=\"Velocity model for station selection\",\n",
+    "                value = \"1066a\",\n",
+    "                interactive=True\n",
+    "            )\n",
+    "            \n",
+    "            \n",
+    "        button = gr.Button(\"Predict phases\")\n",
+    "        outputs_section = gr.outputs.Image(label='Waveforms with Phases Marked', type='numpy')\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, velocity_inputs],\n",
+    "                 outputs=outputs_section)\n",
+    "\n",
+    "    with gr.Tab(\"Predict on your own waveform\"):\n",
+    "        gr.Markdown(\"\"\"\n",
+    "        Please upload your waveform in .npy (numpy) format. \n",
+    "        Your waveform should be sampled at 100 sps and have 3 (Z, N, E) or 1 (Z) channels.\n",
+    "        \"\"\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "demo.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "phasehunter",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "6bf57068982d7b420bddaaf1d0614a7795947176033057024cf47d8ca2c1c4cd"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

phasehunter/app.py

@@ -1,188 +0,0 @@
-# Gradio app that takes seismic waveform as input and marks 2 phases on the waveform as output.
-
-import gradio as gr
-import numpy as np
-from phasehunter.model import Onset_picker, Updated_onset_picker
-from phasehunter.data_preparation import prepare_waveform
-import torch
-
-from scipy.stats import gaussian_kde
-
-import obspy
-from obspy.clients.fdsn import Client
-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
-
-from obspy.clients.fdsn.header import URL_MAPPINGS
-
-import matplotlib.pyplot as plt
-
-def make_prediction(waveform):
-    waveform = np.load(waveform)
-    processed_input = prepare_waveform(waveform)
-    
-    # Make prediction
-    with torch.no_grad():
-        output = model(processed_input)
-
-    p_phase = output[:, 0]
-    s_phase = output[:, 1]
-
-    return processed_input, p_phase, s_phase
-
-def mark_phases(waveform):
-    processed_input, p_phase, s_phase = make_prediction(waveform)
-
-    # Create a plot of the waveform with the phases marked
-    if sum(processed_input[0][2] == 0): #if input is 1C
-        fig, ax = plt.subplots(nrows=2, figsize=(10, 2), sharex=True)
-
-        ax[0].plot(processed_input[0][0])
-        ax[0].set_ylabel('Norm. Ampl.')
-
-    else: #if input is 3C
-        fig, ax = plt.subplots(nrows=4, figsize=(10, 6), sharex=True)
-        ax[0].plot(processed_input[0][0])
-        ax[1].plot(processed_input[0][1])
-        ax[2].plot(processed_input[0][2])
-
-        ax[0].set_ylabel('Z')
-        ax[1].set_ylabel('N')
-        ax[2].set_ylabel('E')
-
-    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')
-
-    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')
-
-    for a in ax:
-        a.axvline(p_phase.mean()*processed_input.shape[-1], color='r', linestyle='--', label='P')
-        a.axvline(s_phase.mean()*processed_input.shape[-1], color='b', linestyle='--', label='S')
-
-    ax[-1].set_xlabel('Time, samples')
-    ax[-1].set_ylabel('Uncert.')
-    ax[-1].legend()
-
-    plt.subplots_adjust(hspace=0., wspace=0.)
-
-    # Convert the plot to an image and return it
-    fig.canvas.draw()
-    image = np.array(fig.canvas.renderer.buffer_rgba())
-    plt.close(fig)
-    return image
-
-#??
-
-def download_data(timestamp, eq_lat, eq_lon, client_name, radius_km):
-    client = Client(client_name)
-    window = radius_km / 111.2
-
-    assert eq_lat - window > -90 and eq_lat + window < 90, "Latitude out of bounds"
-    assert eq_lon - window > -180 and eq_lon + window < 180, "Longitude out of bounds"
-
-    starttime = obspy.UTCDateTime(timestamp)
-    endtime = startime + 120
-
-    inv = client.get_stations(network="*", station="*", location="*", channel="*H*", 
-                          starttime=obspy.UTCDateTime(starttime), endtime=endtime, 
-                          minlatitude=eq_lat-window, maxlatitude=eq_lat+window,
-                          minlongitude=eq_lon-window, maxlongitude=eq_lon+window, 
-                          level='channel')
-    
-    for network in inv:
-        for station in network:
-            print(station)
-
-            # waveform = client.get_waveforms(network=network.code, station=station.code, location="*", channel="*", 
-            #                             starttime=obspy.UTCDateTime(start_date), endtime=obspy.UTCDateTime(end_date))
-
-    return 0
-
-model = Onset_picker.load_from_checkpoint("./weights.ckpt",
-                                 picker=Updated_onset_picker(),
-                                    learning_rate=3e-4)
-model.eval()
-
-
-
-# # Create the Gradio interface
-# gr.Interface(mark_phases, inputs, outputs, title='PhaseHunter').launch()
-
-
-with gr.Blocks() as demo:
-    gr.Markdown("# PhaseHunter")
-    gr.Markdown("""This app allows one to detect P and S seismic phases along with uncertainty of the detection. 
-                The app can be used in three ways: either by selecting one of the sample waveforms;
-                                                   or by selecting an earthquake from the global earthquake catalogue;
-                                                   or by uploading a waveform of interest.
-                """)
-    with gr.Tab("Default example"):
-        # Define the input and output types for Gradio
-        inputs = gr.Dropdown(
-            ["data/sample/sample_0.npy", 
-            "data/sample/sample_1.npy", 
-            "data/sample/sample_2.npy"], 
-            label="Sample waveform", 
-            info="Select one of the samples",
-            value = "data/sample/sample_0.npy"
-        )
-
-        button = gr.Button("Predict phases")
-        outputs = gr.outputs.Image(label='Waveform with Phases Marked', type='numpy')
-    
-        button.click(mark_phases, inputs=inputs, outputs=outputs)
-        
-    with gr.Tab("Select earthquake from catalogue"):
-        gr.Markdown('TEST')
-        
-        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(): 
-
-            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_lo_inputs = gr.Number(value=117.605,
-                                label="Longitude",
-                                info="Longitude of the earthquake",
-                                interactive=True)
-            
-            radius_inputs = gr.Slider(minimum=1, 
-                                    maximum=150, 
-                                    value=50, label="Radius (km)", 
-                                    info="Select the radius around the earthquake to download data from",
-                                    interactive=True)
-            
-        button = gr.Button("Predict phases")
-        button.click(mark_phases, inputs=inputs, outputs=outputs)
-
-    with gr.Tab("Predict on your own waveform"):
-        gr.Markdown("""
-        Please upload your waveform in .npy (numpy) format. 
-        Your waveform should be sampled at 100 sps and have 3 (Z, N, E) or 1 (Z) channels.
-        """)
-
-    button.click(download_data, inputs=[timestamp_inputs, eq_lat_inputs,eq_lo_inputs, radius_inputs], outputs=outputs)
-
-demo.launch()