Removed 3D velocity, because I broke it somehow

app.py

@@ -29,6 +29,9 @@ from mpl_toolkits.axes_grid1 import ImageGrid
 
 from glob import glob
 
+import numpy as np
+from matplotlib import colors, cm
+from scipy.interpolate import griddata
 
 def resample_waveform(waveform, original_freq, target_freq):
     """
@@ -435,10 +438,6 @@ def predict_on_section(client_name, timestamp, eq_lat, eq_lon, radius_km, source
     
     return image, output_picks, output_csv
 
-import numpy as np
-from matplotlib import colors, cm
-from scipy.interpolate import griddata
-
 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)
@@ -485,120 +484,123 @@ def interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_valu
 def find_closest_index(array, value):
     return np.argmin(np.abs(array - value))
 
-def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):
-    filename = list(output_csv.temp_files)[0]
+# FIX AFTER CONFERENCE
+# def compute_velocity_model(azimuth, elevation, interpolate, n_lat, n_lon, n_depth):
+#     filename = list(output_csv.temp_files)[0]
     
-    df = pd.read_csv(filename)
-    filename = filename.split('/')[-1]
+#     df = pd.read_csv(filename)
+#     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
-    num_points = 100
-
-    taup_model = TauPyModel(model='1066a')
-
-    # 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]):
-
-                ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,
-                                        source_latitude_in_deg=eq_lat,
-                                        source_longitude_in_deg=eq_lon,
-                                        receiver_latitude_in_deg=df.st_lat.iloc[i],
-                                        receiver_longitude_in_deg=df.st_lon.iloc[i],
-                                        phase_list=['P', 'S'])
-
-                # Create the interpolator objects for latitude, longitude, and depth
-                interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])
-                interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])
-                interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])
-
-                # Resample the ray path to N points
-                lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))
-                lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))
-                depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))
-
-                # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity
-                for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):
-                    lat_index = find_closest_index(lat_values, lat)
-                    lon_index = find_closest_index(lon_values, lon)
-                    depth_index = find_closest_index(depth_values, depth)
+#     # 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
+#     num_points = 100
+
+#     taup_model = TauPyModel(model='1066a')
+
+#     # 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]):
+
+#                 ray_path = taup_model.get_ray_paths_geo(source_depth_in_km=eq_depth,
+#                                         source_latitude_in_deg=eq_lat,
+#                                         source_longitude_in_deg=eq_lon,
+#                                         receiver_latitude_in_deg=df.st_lat.iloc[i],
+#                                         receiver_longitude_in_deg=df.st_lon.iloc[i],
+#                                         phase_list=['P', 'S'])
+                
+#                 # THERE IS A PROBLEM WITH THE RAY PATHS. APPARENTLY LAT AND LON DON'T EXIST (HOW DID IT WORK BEFORE?)
+#                 print(ray_path[0].path)
+
+#                 # Create the interpolator objects for latitude, longitude, and depth
+#                 interp_latitude = interp1d(np.linspace(0, ray_path[0].path['lat'].max(), len(ray_path[0].path['lat'])), ray_path[0].path['lat'])
+#                 interp_longitude = interp1d(np.linspace(0, ray_path[0].path['lon'].max(), len(ray_path[0].path['lon'])), ray_path[0].path['lon'])
+#                 interp_depth = interp1d(np.linspace(0, ray_path[0].path['depth'].max(), len(ray_path[0].path['depth'])), ray_path[0].path['depth'])
+
+#                 # Resample the ray path to N points
+#                 lat_values_interp = interp_latitude(np.linspace(0, ray_path[0].path['lat'].max(), num_points))
+#                 lon_values_interp = interp_longitude(np.linspace(0, ray_path[0].path['lon'].max(), num_points))
+#                 depth_values_interp = interp_depth(np.linspace(0, ray_path[0].path['depth'].max(), num_points))
+
+#                 # Loop through the interpolated coordinates and update the grid cells with the average P-wave velocity
+#                 for lat, lon, depth in zip(lat_values_interp, lon_values_interp, depth_values_interp):
+#                     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')
+#                     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=2, vmax=8)
-    colors_vel = plt.cm.plasma(norm(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=2, vmax=8)
+#     colors_vel = plt.cm.plasma(norm(velocity_model)) 
     
-    # Plot the voxels
-    if interpolate:
-        interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)
-        colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))
-        ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')
+#     # Plot the voxels
+#     if interpolate:
+#         interpolated_velocity_model = interpolate_vel_model(velocity_model, initial_velocity, lat_values, lon_values, depth_values, n_lat, n_lon, n_depth)
+#         colors_interp = plt.cm.plasma(norm(interpolated_velocity_model))
+#         ax.voxels(x, y, z, interpolated_velocity_model > 0, facecolors=colors_interp, alpha=0.5, edgecolor='k')
     
-    ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')
+#     ax.voxels(x, y, z, velocity_model > 0, facecolors=colors_vel, alpha=1, edgecolor='black')
 
-    # Set the view angle
-    ax.view_init(elev=elevation, azim=azimuth)
+#     # 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)
+#     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)
+#     # Show the plot
+#     fig.canvas.draw();
+#     image = np.array(fig.canvas.renderer.buffer_rgba())
+#     plt.close(fig)
 
-    return image
+#     return image
 
 # model = torch.jit.load("model.pt")
 model = torch.jit.load("model.pt")
-
 model.eval()
 
 with gr.Blocks() as demo:
@@ -625,8 +627,8 @@ with gr.Blocks() as demo:
     -webkit-text-fill-color: transparent;
     background-clip: text;">uncertainty</span></p>
     <ul style="font-size: 16px; margin-bottom: 40px;">
-        <li>Detect seismic phases by selecting a sample waveform or uploading your own waveform in <code>.npy</code> format.</li>
-        <li>Select an earthquake from the global earthquake catalogue and PhaseHunter will analyze seismic stations in the given radius.</li>
+        <li>Tab 1: Detect seismic phases by selecting a sample waveform or uploading your own waveform in <code>.npy</code> format.</li>
+        <li>Tab 2: 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 anovosel@stanford.edu with questions and feedback</p>
@@ -776,25 +778,25 @@ with gr.Blocks() as demo:
         button_phases = gr.Button("Predict phases")
         output_image = gr.Image(label='Waveforms with Phases Marked', type='numpy', interactive=False)
         
-        with gr.Row():
-            with gr.Column(scale=2):
-                azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label="Azimuth", interactive=True)
-                elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label="Elevation", interactive=True)
-
-                with gr.Row():
-                    interpolate_input = gr.Checkbox(label="Interpolate", info="Interpolate velocity model")
-                    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_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label="N lon", info='Number of Lon grid points', interactive=True)
-                    n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label="N depth", info='Number of Depth grid points', interactive=True)
+        # with gr.Row():
+        #     with gr.Column(scale=2):
+        #         azimuth_input = gr.Slider(minimum=-180, maximum=180, value=0, step=5, label="Azimuth", interactive=True)
+        #         elevation_input = gr.Slider(minimum=-90, maximum=90, value=30, step=5, label="Elevation", interactive=True)
+
+        #         with gr.Row():
+        #             interpolate_input = gr.Checkbox(label="Interpolate", info="Interpolate velocity model")
+        #             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_lon_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label="N lon", info='Number of Lon grid points', interactive=True)
+        #             n_depth_input = gr.Slider(minimum=5, maximum=100, value=50, step=5, label="N depth", info='Number of Depth grid points', interactive=True)
                 
-                button = gr.Button("Look at 3D Velocities")
-            outputs_vel_model = gr.Image(label="3D Velocity Model")
-
-        button.click(compute_velocity_model, 
-                        inputs=[azimuth_input, elevation_input, 
-                                interpolate_input, n_lat_input, 
-                                n_lon_input, n_depth_input], 
-                        outputs=[outputs_vel_model])
+        #         button = gr.Button("Look at 3D Velocities")
+        #     outputs_vel_model = gr.Image(label="3D Velocity Model")
+
+        # button.click(compute_velocity_model, 
+        #                 inputs=[azimuth_input, elevation_input, 
+        #                         interpolate_input, n_lat_input, 
+        #                         n_lon_input, n_depth_input], 
+        #                 outputs=[outputs_vel_model])
         
         with gr.Row():
             output_picks = gr.Dataframe(label='Pick data', 

data/velocity/35.766_-117.605_10.0_2019-07-04T17:33:49-00_15.csv

@@ -1,16 +1,16 @@
 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"
-LB.DAC,36.277,-117.593697,2019-07-04T17:33:43.387184Z,34.439029693603516,0.23750784806907177,41.48210525512695,0.84033178165555,,
-CI.ISA,35.66278,-118.47403,2019-07-04T17:33:46.297658Z,14.392077445983887,0.031968383118510246,26.656494140625,0.06666059140115976,5.509786370336251,2.9747824951914903
-CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.330288887023926,0.016060356865637004,13.382941246032715,0.03524674102663994,4.130917960194064,2.262643275505274
-NN.GWY,36.186001,-116.6698,2019-07-04T17:33:48.493781Z,15.728899002075195,0.045239757746458054,27.405405044555664,0.012221475772093982,6.119231109018811,3.5120359625275515
-NN.STHB,36.645401,-116.338799,2019-07-04T17:33:55.443778Z,23.352947235107422,0.3744226321578026,44.04683303833008,0.1678685937076807,6.418864645982177,3.40318240942485
-CI.RRX,34.875332,-116.996841,2019-07-04T17:33:50.712219Z,17.300827026367188,0.046564643271267414,30.308242797851562,0.07697680732235312,6.553167458647257,3.7407386971609977
-NN.QSM,35.965,-116.869102,2019-07-04T17:33:45.081547Z,10.853179931640625,0.03833597875200212,19.083938598632812,0.020896304631605744,6.441474783566184,3.6633153313634157
-CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.525603294372559,0.015247567207552493,9.212132453918457,0.017153594526462257,3.4203901487527526,1.680319839371246
-CI.CWC,36.439049,-118.080498,2019-07-04T17:33:47.189005Z,16.30278205871582,0.03326277597807348,28.5207576751709,0.025247696321457624,5.286053905666142,3.0215671601782677
-CI.SHO,35.899529,-116.275299,2019-07-04T17:33:51.673022Z,19.154117584228516,0.029428565176203847,33.864654541015625,0.038687243359163404,6.306307564126418,3.5668976471999314
-CI.OSI,34.6145,-118.7235,2019-07-04T17:33:57.203547Z,26.982280731201172,0.26682447642087936,49.88245391845703,0.21120380144566298,,
-CI.ADO,34.550461,-117.433907,2019-07-04T17:33:53.650962Z,21.616382598876953,0.04179573501460254,39.828887939453125,0.11273605981841683,6.294295200951223,3.416110775195922
-CI.EDW2,34.8811,-117.993881,2019-07-04T17:33:49.567241Z,17.19280242919922,0.023178785922937095,31.17211151123047,0.14238633681088686,6.080147521998276,3.3534711002313884
-CI.HEC,34.8294,-116.335,2019-07-04T17:33:56.148977Z,23.503509521484375,0.16815592534840107,41.08108901977539,0.05570112029090524,6.6093598323533715,3.7813786210938956
-CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.510456085205078,0.018548613879829645,17.035369873046875,0.035437317565083504,4.7426953739315625,2.6477379954424243
+NN.GWY,36.186001,-116.6698,2019-07-04T17:33:48.493781Z,15.700143814086914,0.032990213949233294,27.400177001953125,0.021678594639524817,6.130438626794903,3.5127060703751187
+NN.QSM,35.965,-116.869102,2019-07-04T17:33:45.081547Z,10.825798034667969,0.03368678851984441,19.0788516998291,0.019648977904580534,6.4577673283107595,3.664292062807735
+CI.SHO,35.899529,-116.275299,2019-07-04T17:33:51.673022Z,19.146766662597656,0.035460374783724546,33.84723663330078,0.04468856379389763,6.30872871300763,3.568733185348003
+NN.STHB,36.645401,-116.338799,2019-07-04T17:33:55.443778Z,23.533306121826172,0.30755365267395973,44.214805603027344,0.1947527378797531,6.369670568636879,3.390253679565082
+CI.ADO,34.550461,-117.433907,2019-07-04T17:33:53.650962Z,21.59795379638672,0.06652493728324771,39.832244873046875,0.07596344919875264,6.299665909869628,3.4158228763577374
+CI.CWC,36.439049,-118.080498,2019-07-04T17:33:47.189005Z,16.31502342224121,0.03174463869072497,28.542631149291992,0.03808272653259337,5.282087714150544,3.0192516003149317
+CI.EDW2,34.8811,-117.993881,2019-07-04T17:33:49.567241Z,17.189565658569336,0.027216661255806684,31.171907424926758,0.13113449793308973,6.081292405081156,3.3534930558182605
+CI.OSI,34.6145,-118.7235,2019-07-04T17:33:57.203547Z,27.027793884277344,0.2828584983944893,49.76795196533203,0.1476773852482438,6.048733936517377,3.284923884569468
+CI.HEC,34.8294,-116.335,2019-07-04T17:33:56.148977Z,23.56346893310547,0.12240480165928602,41.065738677978516,0.039880009135231376,6.5925417090174125,3.782792097538392
+CI.ISA,35.66278,-118.47403,2019-07-04T17:33:46.297658Z,14.406868934631348,0.03547209897078574,26.673168182373047,0.04885842092335224,5.5041294893778305,2.972922886794878
+LB.DAC,36.277,-117.593697,2019-07-04T17:33:43.387184Z,34.548667907714844,0.15354723203927279,41.79047393798828,1.0928620398044586,,
+CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.319685935974121,0.013258439430501312,13.406767845153809,0.024791041505523026,4.136901812685252,2.2586220904663317
+CI.RRX,34.875332,-116.996841,2019-07-04T17:33:50.712219Z,17.288339614868164,0.037936256267130375,30.341846466064453,0.12148946989327669,6.557900828103267,3.7365958200229463
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.49942398071289,0.009130067483056337,17.041561126708984,0.028638315852731466,4.748203277468246,2.646776063760303
+CI.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.530585289001465,0.018513815011829138,9.206761360168457,0.01343689626082778,3.4166289646533787,1.6813001140882917

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.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.SRT,35.69235,-117.75051,2019-07-04T17:33:38.029990Z,4.52931022644043,0.014338254695758224,9.210612297058105,0.013868825335521251,3.417590792273917,1.6805971661817796
+CI.WMF,36.11758,-117.85486,2019-07-04T17:33:41.867962Z,9.509395599365234,0.017237813444808125,17.024826049804688,0.043195366160944104,4.743224278343435,2.6493777937777434
 CI.JRC2,35.98249,-117.80885,2019-07-04T17:33:39.947494Z,7.3213396072387695,0.014792497968301177,13.395279884338379,0.025232930202037096,4.135967410510336,2.2605591132307814

requirements.txt

@@ -15,4 +15,5 @@ obspy
 pandas
 bmi_topography
 earthpy
+geographiclib
 git+http://github.com/nikitadurasov/masksembles