Fixed button bug and added contacts

.vscode/settings.json

@@ -1,3 +1,6 @@
 {
-    "python.formatting.provider": "black"
+    "python.formatting.provider": "none",
+    "[python]": {
+        "editor.defaultFormatter": "ms-python.black-formatter"
+    }
 }

Gradio_app.ipynb

@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Running on local URL:  http://127.0.0.1:7860\n",
+      "Running on local URL:  http://127.0.0.1:7862\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:7860/\" 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:7862/\" 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": 1,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -667,6 +667,7 @@
     "        <li>Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.</li>\n",
     "        <li>Waveforms should be sampled at 100 samples/sec and have 3 (Z, N, E) or 1 (Z) channels. PhaseHunter analyzes the first 6000 samples of your file.</li>\n",
     "    </ul>\n",
+    "    <p style=\"font-size: 16px; margin-bottom: 20px;\">Please contact me at [email protected] with questions and feedback</p>\n",
     "</div>\n",
     "\"\"\")\n",
     "    with gr.Tab(\"Try on a single station\"):\n",
@@ -810,7 +811,7 @@
     "                                interactive=True,\n",
     "                                )\n",
     "            \n",
-    "        button = gr.Button(\"Predict phases\")\n",
+    "        button_phases = gr.Button(\"Predict phases\")\n",
     "        output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)\n",
     "        \n",
     "        with gr.Row():\n",
@@ -839,7 +840,7 @@
     "                                        interactive=False)\n",
     "            output_csv = gr.File(label=\"Output File\", file_types=[\".csv\"])\n",
     "\n",
-    "        button.click(predict_on_section, \n",
+    "        button_phases.click(predict_on_section, \n",
     "                 inputs=[client_inputs, timestamp_inputs, \n",
     "                         eq_lat_inputs, eq_lon_inputs, \n",
     "                         radius_inputs, source_depth_inputs, \n",
@@ -1465,7 +1466,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.9.8"
   },
   "orig_nbformat": 4
  },

app.py

@@ -629,6 +629,7 @@ with gr.Blocks() as demo:
         <li>Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.</li>
         <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>
+    <p style="font-size: 16px; margin-bottom: 20px;">Please contact me at [email protected] with questions and feedback</p>
 </div>
 """)
     with gr.Tab("Try on a single station"):
@@ -772,7 +773,7 @@ with gr.Blocks() as demo:
                                 interactive=True,
                                 )
             
-        button = gr.Button("Predict phases")
+        button_phases = gr.Button("Predict phases")
         output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)
         
         with gr.Row():
@@ -801,7 +802,7 @@ with gr.Blocks() as demo:
                                         interactive=False)
             output_csv = gr.File(label="Output File", file_types=[".csv"])
 
-        button.click(predict_on_section, 
+        button_phases.click(predict_on_section, 
                  inputs=[client_inputs, timestamp_inputs, 
                          eq_lat_inputs, eq_lon_inputs, 
                          radius_inputs, source_depth_inputs, 

data/velocity/35.766_-117.605_10.0_2019-07-04T17:33:49-00_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.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
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.503650665283203,0.0166851474205032,17.022594451904297,0.04997983225621283,4.746091546067712,2.6497251172094707
+CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.53201961517334,0.017489900928921998,9.215676307678223,0.019567753770388663,3.4155476453388767,1.67967367867923
+CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.3213396072387695,0.014792497968301177,13.395279884338379,0.025232930202037096,4.135967410510336,2.2605591132307814

phasehunter/utils.py

@@ -0,0 +1,93 @@
+import numpy as np
+from scipy.interpolate import griddata
+
+
+def bin_distances(distances, bin_size=10):
+    # Bin the distances into groups of `bin_size` kilometers
+    binned_distances = {}
+    for i, distance in enumerate(distances):
+        bin_index = distance // bin_size
+        if bin_index not in binned_distances:
+            binned_distances[bin_index] = (distance, i)
+        elif i < binned_distances[bin_index][1]:
+            binned_distances[bin_index] = (distance, i)
+
+    # Select the first distance in each bin and its index
+    first_distances = []
+    for bin_index in binned_distances:
+        first_distance, first_distance_index = binned_distances[bin_index]
+        first_distances.append(first_distance_index)
+
+    return first_distances
+
+
+def interpolate_vel_model(
+    velocity_model,
+    initial_velocity,
+    lat_values,
+    lon_values,
+    depth_values,
+    n_lat,
+    n_lon,
+    n_depth,
+):
+    # Create a mask for points with the initial velocity
+    initial_velocity_mask = velocity_model == initial_velocity
+
+    # Find the indices of points with non-initial velocities
+    non_initial_velocity_indices = np.argwhere(~initial_velocity_mask)
+
+    # Extract the coordinates and corresponding velocities of the known points
+    known_points = np.column_stack(
+        [
+            lat_values[non_initial_velocity_indices[:, 0]],
+            lon_values[non_initial_velocity_indices[:, 1]],
+            depth_values[non_initial_velocity_indices[:, 2]],
+        ]
+    )
+
+    # Find the maximum depth in the known_points
+    max_known_depth = np.max(known_points[:, 2])
+
+    known_velocities = velocity_model[~initial_velocity_mask]
+
+    # Create a grid of points for the entire volume
+    grid_points = (
+        np.array(np.meshgrid(lat_values, lon_values, depth_values, indexing="ij"))
+        .reshape(3, -1)
+        .T
+    )
+
+    # Create a mask for grid points that are deeper than the maximum known depth
+    depth_mask = grid_points[:, 2] <= max_known_depth
+
+    # Interpolate the velocities at the grid points
+    interpolated_velocities = griddata(
+        known_points, known_velocities, grid_points[depth_mask], method="linear"
+    )
+
+    # Fill nan values with the nearest known velocities
+    interpolated_velocities_filled = griddata(
+        known_points, known_velocities, grid_points[depth_mask], method="nearest"
+    )
+    interpolated_velocities[
+        np.isnan(interpolated_velocities)
+    ] = interpolated_velocities_filled[np.isnan(interpolated_velocities)]
+
+    # Initialize an array with the same length as grid_points and fill it with nan values
+    interpolated_velocities_with_depth_limit = np.full(grid_points.shape[0], np.nan)
+
+    # Update the array with the interpolated velocities for the masked grid points
+    interpolated_velocities_with_depth_limit[depth_mask] = interpolated_velocities
+
+    # Reshape the interpolated velocities to match the shape of the velocity_model
+    interpolated_velocity_model = interpolated_velocities_with_depth_limit.reshape(
+        n_lat, n_lon, n_depth
+    )
+
+    return interpolated_velocity_model
+
+
+# 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))