diff --git "a/Gradio_app.ipynb" "b/Gradio_app.ipynb"
--- "a/Gradio_app.ipynb"
+++ "b/Gradio_app.ipynb"
@@ -2,14 +2,14 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Running on local URL: http://127.0.0.1:7862\n",
+ "Running on local URL: http://127.0.0.1:7865\n",
"\n",
"To create a public link, set `share=True` in `launch()`.\n"
]
@@ -17,7 +17,7 @@
{
"data": {
"text/html": [
- "
"
+ ""
],
"text/plain": [
""
@@ -30,9 +30,45 @@
"data": {
"text/plain": []
},
- "execution_count": 5,
+ "execution_count": 3,
"metadata": {},
"output_type": "execute_result"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Starting to download inventory\n",
+ "Finished downloading inventory\n",
+ "Processing CI.CCC...\n",
+ "Downloading waveform 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"
+ ]
}
],
"source": [
@@ -67,6 +103,9 @@
"\n",
"from glob import glob\n",
"\n",
+ "import numpy as np\n",
+ "from matplotlib import colors, cm\n",
+ "from scipy.interpolate import griddata\n",
"\n",
"def resample_waveform(waveform, original_freq, target_freq):\n",
" \"\"\"\n",
@@ -473,10 +512,6 @@
" \n",
" return image, output_picks, output_csv\n",
"\n",
- "import numpy as np\n",
- "from matplotlib import colors, cm\n",
- "from scipy.interpolate import griddata\n",
- "\n",
"def interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth):\n",
" # Create a mask for points with the initial velocity\n",
" initial_velocity_mask = (velocity_model == initial_velocity)\n",
@@ -523,120 +558,123 @@
"def find_closest_index(array, value):\n",
" return np.argmin(np.abs(array - value))\n",
"\n",
- "def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):\n",
- " filename = list(output_csv.temp_files)[0]\n",
+ "# FIX AFTER CONFERENCE\n",
+ "# def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):\n",
+ "# filename = list(output_csv.temp_files)[0]\n",
" \n",
- " df = pd.read_csv(filename)\n",
- " filename = filename.split('/')[-1]\n",
+ "# df = pd.read_csv(filename)\n",
+ "# filename = filename.split('/')[-1]\n",
" \n",
- " # Current EQ location\n",
- " eq_lat = float(filename.split(\"_\")[0])\n",
- " eq_lon = float(filename.split(\"_\")[1])\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",
- " lon_range = (np.min([df.st_lon.min(), eq_lon]), np.max([df.st_lon.max(), eq_lon]))\n",
- " depth_range = (0, 50)\n",
- "\n",
- " # Define the number of nodes in each dimension\n",
- " num_points = 100\n",
- "\n",
- " taup_model = TauPyModel(model='1066a')\n",
- "\n",
- " # Create the grid\n",
- " lat_values = np.linspace(lat_range[0], lat_range[1], n_lat)\n",
- " lon_values = np.linspace(lon_range[0], lon_range[1], n_lon)\n",
- " depth_values = np.linspace(depth_range[0], depth_range[1], n_depth)\n",
- "\n",
- " # Initialize the velocity model with constant values\n",
- " initial_velocity = 0 # km/s, this can be P-wave or S-wave velocity\n",
- " velocity_model = np.full((n_lat, n_lon, n_depth), initial_velocity, dtype=float)\n",
- "\n",
- " # Loop through the stations and update the velocity model\n",
- " for i in range(len(df)):\n",
- " if ~np.isnan(df['velocity_p, km/s'].iloc[i]):\n",
- "\n",
- " ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,\n",
- " source_latitude_in_deg=eq_lat,\n",
- " source_longitude_in_deg=eq_lon,\n",
- " receiver_latitude_in_deg=df.st_lat.iloc[i],\n",
- " receiver_longitude_in_deg=df.st_lon.iloc[i],\n",
- " phase_list=['P', 'S'])\n",
- "\n",
- " # Create the interpolator objects for latitude, longitude, and depth\n",
- " interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n",
- " interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])\n",
- " interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])\n",
- "\n",
- " # Resample the ray path to N points\n",
- " lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))\n",
- " lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))\n",
- " depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))\n",
- "\n",
- " # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity\n",
- " for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):\n",
- " lat_index = find_closest_index(lat_values, lat)\n",
- " lon_index = find_closest_index(lon_values, lon)\n",
- " depth_index = find_closest_index(depth_values, depth)\n",
+ "# # Current EQ location\n",
+ "# eq_lat = float(filename.split(\"_\")[0])\n",
+ "# eq_lon = float(filename.split(\"_\")[1])\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",
+ "# lon_range = (np.min([df.st_lon.min(), eq_lon]), np.max([df.st_lon.max(), eq_lon]))\n",
+ "# depth_range = (0, 50)\n",
+ "\n",
+ "# # Define the number of nodes in each dimension\n",
+ "# num_points = 100\n",
+ "\n",
+ "# taup_model = TauPyModel(model='1066a')\n",
+ "\n",
+ "# # Create the grid\n",
+ "# lat_values = np.linspace(lat_range[0], lat_range[1], n_lat)\n",
+ "# lon_values = np.linspace(lon_range[0], lon_range[1], n_lon)\n",
+ "# depth_values = np.linspace(depth_range[0], depth_range[1], n_depth)\n",
+ "\n",
+ "# # Initialize the velocity model with constant values\n",
+ "# initial_velocity = 0 # km/s, this can be P-wave or S-wave velocity\n",
+ "# velocity_model = np.full((n_lat, n_lon, n_depth), initial_velocity, dtype=float)\n",
+ "\n",
+ "# # Loop through the stations and update the velocity model\n",
+ "# for i in range(len(df)):\n",
+ "# if ~np.isnan(df['velocity_p, km/s'].iloc[i]):\n",
+ "\n",
+ "# ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,\n",
+ "# source_latitude_in_deg=eq_lat,\n",
+ "# source_longitude_in_deg=eq_lon,\n",
+ "# receiver_latitude_in_deg=df.st_lat.iloc[i],\n",
+ "# receiver_longitude_in_deg=df.st_lon.iloc[i],\n",
+ "# phase_list=['P', 'S'])\n",
+ " \n",
+ "# # THERE IS A PROBLEM WITH THE RAY PATHS. APPARENTLY LAT AND LON DON'T EXIST (HOW DID IT WORK BEFORE?)\n",
+ "# print(ray_path[0].path)\n",
+ "\n",
+ "# # Create the interpolator objects for latitude, longitude, and depth\n",
+ "# interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])\n",
+ "# interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])\n",
+ "# interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])\n",
+ "\n",
+ "# # Resample the ray path to N points\n",
+ "# lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))\n",
+ "# lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))\n",
+ "# depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))\n",
+ "\n",
+ "# # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity\n",
+ "# for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):\n",
+ "# lat_index = find_closest_index(lat_values, lat)\n",
+ "# lon_index = find_closest_index(lon_values, lon)\n",
+ "# depth_index = find_closest_index(depth_values, depth)\n",
" \n",
- " if velocity_model[lat_index, lon_index, depth_index] == initial_velocity:\n",
- " velocity_model[lat_index, lon_index, depth_index] = df['velocity_p, km/s'].iloc[i]\n",
- " else:\n",
- " velocity_model[lat_index, lon_index, depth_index] = (velocity_model[lat_index, lon_index, depth_index] +\n",
- " df['velocity_p, km/s'].iloc[i]) / 2\n",
- "\n",
- " # Create the figure and axis\n",
- " fig = plt.figure(figsize=(8, 8))\n",
- " ax = fig.add_subplot(111, projection='3d')\n",
- "\n",
- " # Set the plot limits\n",
- " ax.set_xlim3d(lat_range[0], lat_range[1])\n",
- " ax.set_ylim3d(lon_range[0], lon_range[1])\n",
- " ax.set_zlim3d(depth_range[1], depth_range[0])\n",
- "\n",
- " ax.set_xlabel('Latitude')\n",
- " ax.set_ylabel('Longitude')\n",
- " ax.set_zlabel('Depth (km)')\n",
- " ax.set_title('Velocity Model')\n",
+ "# if velocity_model[lat_index, lon_index, depth_index] == initial_velocity:\n",
+ "# velocity_model[lat_index, lon_index, depth_index] = df['velocity_p, km/s'].iloc[i]\n",
+ "# else:\n",
+ "# velocity_model[lat_index, lon_index, depth_index] = (velocity_model[lat_index, lon_index, depth_index] +\n",
+ "# df['velocity_p, km/s'].iloc[i]) / 2\n",
+ "\n",
+ "# # Create the figure and axis\n",
+ "# fig = plt.figure(figsize=(8, 8))\n",
+ "# ax = fig.add_subplot(111, projection='3d')\n",
+ "\n",
+ "# # Set the plot limits\n",
+ "# ax.set_xlim3d(lat_range[0], lat_range[1])\n",
+ "# ax.set_ylim3d(lon_range[0], lon_range[1])\n",
+ "# ax.set_zlim3d(depth_range[1], depth_range[0])\n",
+ "\n",
+ "# ax.set_xlabel('Latitude')\n",
+ "# ax.set_ylabel('Longitude')\n",
+ "# ax.set_zlabel('Depth (km)')\n",
+ "# ax.set_title('Velocity Model')\n",
" \n",
- " # Create the meshgrid\n",
- " x, y, z = np.meshgrid(\n",
- " np.linspace(lat_range[0], lat_range[1], velocity_model.shape[0]+1),\n",
- " np.linspace(lon_range[0], lon_range[1], velocity_model.shape[1]+1),\n",
- " np.linspace(depth_range[0], depth_range[1], velocity_model.shape[2]+1),\n",
- " indexing='ij'\n",
- " )\n",
- "\n",
- " # Create the color array\n",
- " norm = plt.Normalize(vmin=2, vmax=8)\n",
- " colors_vel = plt.cm.plasma(norm(velocity_model)) \n",
+ "# # Create the meshgrid\n",
+ "# x, y, z = np.meshgrid(\n",
+ "# np.linspace(lat_range[0], lat_range[1], velocity_model.shape[0]+1),\n",
+ "# np.linspace(lon_range[0], lon_range[1], velocity_model.shape[1]+1),\n",
+ "# np.linspace(depth_range[0], depth_range[1], velocity_model.shape[2]+1),\n",
+ "# indexing='ij'\n",
+ "# )\n",
+ "\n",
+ "# # Create the color array\n",
+ "# norm = plt.Normalize(vmin=2, vmax=8)\n",
+ "# colors_vel = plt.cm.plasma(norm(velocity_model)) \n",
" \n",
- " # Plot the voxels\n",
- " if interpolate:\n",
- " interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)\n",
- " colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))\n",
- " ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')\n",
+ "# # Plot the voxels\n",
+ "# if interpolate:\n",
+ "# interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)\n",
+ "# colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))\n",
+ "# ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')\n",
" \n",
- " ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')\n",
+ "# ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')\n",
"\n",
- " # Set the view angle\n",
- " ax.view_init(elev=elevation, azim=azimuth)\n",
+ "# # Set the view angle\n",
+ "# ax.view_init(elev=elevation, azim=azimuth)\n",
"\n",
- " m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)\n",
- " m.set_array([])\n",
- " plt.colorbar(m)\n",
+ "# m = cm.ScalarMappable(cmap=plt.cm.plasma, norm=norm)\n",
+ "# m.set_array([])\n",
+ "# plt.colorbar(m)\n",
"\n",
- " # Show the plot\n",
- " fig.canvas.draw();\n",
- " image = np.array(fig.canvas.renderer.buffer_rgba())\n",
- " plt.close(fig)\n",
+ "# # Show the plot\n",
+ "# fig.canvas.draw();\n",
+ "# image = np.array(fig.canvas.renderer.buffer_rgba())\n",
+ "# plt.close(fig)\n",
"\n",
- " return image\n",
+ "# return image\n",
"\n",
"# model = torch.jit.load(\"model.pt\")\n",
"model = torch.jit.load(\"model.pt\")\n",
- "\n",
"model.eval()\n",
"\n",
"with gr.Blocks() as demo:\n",
@@ -663,8 +701,8 @@
" -webkit-text-fill-color: transparent;\n",
" background-clip: text;\">uncertainty\n",
" \n",
- " - Detect seismic phases by selecting a sample waveform or uploading your own waveform in
.npy
format. \n",
- " - Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.
\n",
+ " - Tab 1: Detect seismic phases by selecting a sample waveform or uploading your own waveform in
.npy
format. \n",
+ " - Tab 2: Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.
\n",
" - 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.
\n",
"
\n",
" Please contact me at anovosel@stanford.edu with questions and feedback
\n",
@@ -814,25 +852,25 @@
" 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",
- " with gr.Column(scale=2):\n",
- " azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label=\"Azimuth\", interactive=True)\n",
- " elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label=\"Elevation\", interactive=True)\n",
- "\n",
- " with gr.Row():\n",
- " interpolate_input = gr.Checkbox(label=\"Interpolate\", info=\"Interpolate velocity model\")\n",
- " n_lat_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lat\", info='Number of Lat grid points', interactive=True)\n",
- " n_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lon\", info='Number of Lon grid points', interactive=True)\n",
- " n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N depth\", info='Number of Depth grid points', interactive=True)\n",
+ " # with gr.Row():\n",
+ " # with gr.Column(scale=2):\n",
+ " # azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label=\"Azimuth\", interactive=True)\n",
+ " # elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label=\"Elevation\", interactive=True)\n",
+ "\n",
+ " # with gr.Row():\n",
+ " # interpolate_input = gr.Checkbox(label=\"Interpolate\", info=\"Interpolate velocity model\")\n",
+ " # n_lat_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lat\", info='Number of Lat grid points', interactive=True)\n",
+ " # n_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N lon\", info='Number of Lon grid points', interactive=True)\n",
+ " # n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label=\"N depth\", info='Number of Depth grid points', interactive=True)\n",
" \n",
- " button = gr.Button(\"Look at 3D Velocities\")\n",
- " outputs_vel_model = gr.Image(label=\"3D Velocity Model\")\n",
- "\n",
- " button.click(compute_velocity_model, \n",
- " inputs=[azimuth_input, elevation_input, \n",
- " interpolate_input, n_lat_input, \n",
- " n_lon_input, n_depth_input], \n",
- " outputs=[outputs_vel_model])\n",
+ " # button = gr.Button(\"Look at 3D Velocities\")\n",
+ " # outputs_vel_model = gr.Image(label=\"3D Velocity Model\")\n",
+ "\n",
+ " # button.click(compute_velocity_model, \n",
+ " # inputs=[azimuth_input, elevation_input, \n",
+ " # interpolate_input, n_lat_input, \n",
+ " # n_lon_input, n_depth_input], \n",
+ " # outputs=[outputs_vel_model])\n",
" \n",
" with gr.Row():\n",
" output_picks = gr.Dataframe(label='Pick data', \n",
@@ -851,454 +889,13 @@
"demo.launch()"
]
},
- {
- "cell_type": "code",
- "execution_count": 1,
- "metadata": {},
- "outputs": [],
- "source": [
- "import obspy\n",
- "from obspy.clients.fdsn import Client\n",
- "\n",
- "import numpy as np\n",
- "import pandas as pd\n",
- "import matplotlib.pyplot as plt\n",
- "\n",
- "client = Client('IRIS')\n",
- "\n",
- "radius_km = 150\n",
- "window = radius_km / 111.2\n",
- "max_waveforms = 10\n",
- "\n",
- "starttime = obspy.UTCDateTime('2023-01-23 00:00:00.000')\n",
- "endtime = starttime + 60*60*24\n",
- "\n",
- "eq_lat = 35.6173961\n",
- "eq_lon = 139.7453414\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='response')\n",
- "\n",
- "waveform = client.get_waveforms(network=inv[0].code, station=inv[0][0].code, location=\"*\", channel=\"*\", \n",
- " starttime=starttime, endtime=endtime)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "metadata": {},
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- "