def cut_swave(infile, cutfile, t1, t2): #reads in a sac file #full path to output file #cuts at t1 sec before s arrival and t2 seconds after from obspy import read import dread import datetime from obspy.core.utcdatetime import UTCDateTime velocity = 3.5 #km/s stream = read(infile) tr = stream[0] origin_hour = tr.stats.sac.nzhour origin_min = tr.stats.sac.nzmin origin_sec = tr.stats.sac.nzsec origin_msec = tr.stats.sac.nzmsec trace_starttime = tr.stats.starttime origin_time = (origin_hour * 60 * 60 + origin_min * 60 + origin_sec + origin_msec / 1000.) # in seconds after start of day trace_starttime_sec = trace_starttime.hour * 60 * 60 + trace_starttime.minute * 60 + trace_starttime.second delta = origin_time - trace_starttime_sec # in sec # print(delta) origin_time_UTC = trace_starttime + datetime.timedelta( seconds=delta) #convert origin time to UTC evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km s_travel_time = dist / velocity # in sec # print(s_travel_time) cuttime = origin_time_UTC + datetime.timedelta( seconds=s_travel_time) #add travel time or utc origin time # print(cuttime) start = cuttime - datetime.timedelta(seconds=t1) end = cuttime + datetime.timedelta(seconds=t2) start = str(start) end = str(end) # print(start, end) # print(cuttime - datetime.timedelta(seconds = t1),cuttime + datetime.timedelta(seconds = t2)) # print(tr.slice(cuttime - datetime.timedelta(seconds = t1),cuttime + datetime.timedelta(seconds = t2), nearest_sample=True)) # cut_trace = tr.slice(cuttime - datetime.timedelta(seconds = t1),cuttime + datetime.timedelta(seconds = t2), nearest_sample=True)#make a new trace by slicing cut_trace = tr.slice(UTCDateTime(start), UTCDateTime(end), nearest_sample=True) #make a new trace by slicing # print(tr.data) # print(cut_trace) cut_trace.write(cutfile, format='SAC')
def L1norm(record_paths): import os.path as path import dread from obspy import read import numpy as np N = len(record_paths) L1 = np.zeros((N, 50)) #50 bands, number of recordings for i in range(N): #for the list of records compute L2 norm in each f band base = path.basename(record_paths[i]) eventid, network, station, channel, extn = base.split('.') raw_file = '/Users/escuser/Documents/Alexis_Data/cut_sac_files/rawdata/' + eventid + '.' + network + '.' + station + '.HHN.sac' event_dir = '/Users/escuser/Documents/Alexis_Data/cut_sac_files/event_site_spectra/' station_dir = '/Users/escuser/Documents/Alexis_Data/cut_sac_files/event_site_spectra/' stream = read(raw_file) tr = stream[0] evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km #km to cm dist = dist * 100000 #record spectra record_data = np.genfromtxt(record_paths[i], dtype=float, comments='#', delimiter=None, usecols=(0, 1)) #only read in first two cols record_spec = record_data[:, 1] * dist #event spectra event_data = np.genfromtxt(event_dir + eventid + '.out', dtype=float, comments='#', delimiter=None, usecols=(0, 1)) event_spec = event_data[:, 1] #station spectra station_data = np.genfromtxt(station_dir + station + '.out', dtype=float, comments='#', delimiter=None, usecols=(0, 1)) station_spec = station_data[:, 1] calc_record_spec = station_spec * event_spec residual = (record_spec - calc_record_spec) #set recording row equal to residual array L1[i:, ] = residual return L1
def match_residuals(evid, mcat, slon, slat, sd, s, rlon, rlat, rdepth, eresid): from scipy.stats import pearsonr import statsmodels import statsmodels.stats.power eventid = [] stressdrop = [] residual = [] for i in range(len(evid)): d = [] print (evid[i]) for j in range(len(rlat)): dist = dread.compute_rrup(slon[i], slat[i], sd[i], rlon[j], rlat[j], -1*rdepth[j]) #in km d.append(dist) if min(d) < 20: ind = d.index(min(d)) eventid.append(evid[i]) stressdrop.append(s[i]) residual.append(eresid[ind]) cmap = mpl.cm.get_cmap('viridis') normalize = mpl.colors.Normalize(vmin=min(mcat), vmax=max(mcat)) colors = [cmap(normalize(value)) for value in mcat] s_m = mpl.cm.ScalarMappable(cmap = cmap, norm=normalize) s_m.set_array([]) fig = plt.figure(figsize = (16,14)) plt.subplot(111) plt.tick_params(axis='both', which='major', labelsize=18) plt.tick_params(axis='both', which='both', length = 5, width = 1) plt.scatter(x= stressdrop, y=residual, c = colors, edgecolors = colors) plt.xlabel('log stress drop (MPa)', fontsize = 28) plt.ylabel('GMPE event residual', fontsize = 28) plt.gca().xaxis.set_major_formatter(mtick.FormatStrFormatter('%.2f')) rval, pval = pearsonr(x= stressdrop, y=residual) power = statsmodels.stats.power.tt_solve_power(effect_size = rval, nobs = len(stressdrop), alpha = 0.05) label1 = 'Pearson R : ' + "{:.4f}".format(rval) label3 = 'power : ' + "{:.4f}".format(power) label2 = 'pvalue: ' + "{:.4f}".format(pval) plt.annotate(label1 + '\n' + label2 + '\n' + label3, xy=(0.72, 0.02), xycoords='axes fraction', bbox=dict(facecolor='white', edgecolor='black', boxstyle='square,pad=0.2')) fig.subplots_adjust(right=0.9) cbar_ax = fig.add_axes([0.92, 0.15, 0.02, 0.75]) cbar = plt.colorbar(s_m, cax=cbar_ax) cbar.set_label(ur"magnitude", fontsize = 22)#"$azimuth$ (\u00b0)" cbar.ax.tick_params(labelsize = 18) plt.show() plt.savefig(top_dir + '/source_params/residual_vs_stressdrop_match_events.png')
def L1norm(record_paths): import os.path as path import dread from obspy import read import numpy as np N = len(record_paths) L1 = np.zeros((N, 50)) #50 bands, number of recordings for i in range(N): #for the list of records compute L1 norm in each f band base = path.basename(record_paths[i]) print(record_paths[i]) box = record_paths[i].split('/')[5] network, station, channel, loc = base.split('_')[0:4] yyyy, month, day, hh, mm, ss = base.split('_')[4:] ss = ss.split('.')[0] eventid = yyyy + '_' + month + '_' + day + '_' + hh + '_' + mm + '_' + ss raw_file = '/Users/escuser/project/boxes/' + box + '/uncorrected/Event_' + eventid + '/' + network + '_' + station + '_HHN_' + loc + '_' + eventid + '.SAC' event_dir = '/Users/escuser/project/boxes/' + box + '/secondo/' station_dir = '/Users/escuser/project/boxes/' + box + '/secondo/' stream = read(raw_file) tr = stream[0] evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km #km to cm dist = dist*100000 #record spectra record_data = np.genfromtxt(record_paths[i], dtype = float, comments = '#', delimiter = None, usecols = (0,1))#only read in first two cols record_spec = record_data[:,1]*dist #event spectra event_data = np.genfromtxt(event_dir + eventid + '.out', dtype = float, comments = '#', delimiter = None, usecols = (0,1)) event_spec = event_data[:,1] #station spectra station_data = np.genfromtxt(station_dir + station + '.out', dtype = float, comments = '#', delimiter = None, usecols = (0,1)) station_spec = station_data[:,1] calc_record_spec = station_spec*event_spec residual = (record_spec - calc_record_spec) #set recording row equal to residual array L1[i:,] = residual return L1
def dist_to_elMayor(vertices, lon, lat, m, s, sig, d): points = zip(sobj.lon, sobj.lat) path = mpltPath.Path(vertices) inside = path.contains_points(points) t = [] s = [] m = [] sig = [] d = [] lat = [] lon = [] elMayor_dist = [] for i in range(len(inside)): if inside[i] == True: x = (sobj.evid[i]).split('_') t.append(datetime(int(x[0]), int(x[1]), int(x[2]), int(x[3]), int(x[4]), int(x[5]))) #t.append(points_t[i]) s.append(sobj.log_stressdrop[i]) m.append(sobj.m_cat[i]) sig.append(sobj.log_stressdrop_sig[i]) d.append(sobj.depth[i]) lat.append(sobj.lat[i]) lon.append(sobj.lon[i]) dist = dread.compute_rrup(elMayorlon, elMayorlat,elMayordepth, sobj.lon[i], sobj.lat[i], -1*sobj.depth[i]) elMayor_dist.append(dist) cmap = mpl.cm.get_cmap('viridis') normalize = mpl.colors.Normalize(vmin=min(m), vmax=max(m)) colors = [cmap(normalize(value)) for value in m] s_m = mpl.cm.ScalarMappable(cmap = cmap, norm=normalize) s_m.set_array([]) fig = plt.figure(figsize = (18,16)) plt.scatter(elMayor_dist, s, marker='o', s=25, c = colors, edgecolors = colors) for i in range(len(s)): plt.errorbar(x=elMayor_dist[i], y=s[i], yerr = sig[i], marker = '.', c = colors[i]) plt.xlabel('distance to elMayor event (km)') plt.ylabel('log stressdrop') fig.subplots_adjust(right=0.88) cbar_ax = fig.add_axes([0.92, 0.1, 0.02, 0.8]) cbar = plt.colorbar(s_m, cax=cbar_ax) cbar.set_label(ur"magnitude", fontsize = 22)#"$azimuth$ (\u00b0)" cbar.ax.tick_params(labelsize = 18) plt.show() plt.savefig(top_dir + '/source_params/dist_to_elMayor_polygon1.png')
def cut_swave(infile, cutfile, t1, t2): #reads in a sac file #full path to output file #cuts at t1 sec before s arrival and t2 seconds after from obspy import read import dread import datetime velocity = 3.5 #km/s stream = read(infile) tr = stream[0] origin_hour = tr.stats.sac.nzhour origin_min = tr.stats.sac.nzmin origin_sec = tr.stats.sac.nzsec origin_msec = tr.stats.sac.nzmsec trace_starttime = tr.stats.starttime origin_time = (origin_hour * 60 * 60 + origin_min * 60 + origin_sec + origin_msec / 1000.) # in seconds after start of day trace_starttime_sec = tr.stats.sac.b #sec #difference between origin time and when the trace starts delta = origin_time - trace_starttime_sec # in sec origin_time_UTC = trace_starttime + datetime.timedelta( seconds=delta) #convert origin time to UTC evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km s_travel_time = dist / velocity # in sec cuttime = origin_time_UTC + datetime.timedelta( seconds=s_travel_time) #add travel time or utc origin time cut_trace = tr.slice(cuttime - datetime.timedelta(seconds=t1), cuttime + datetime.timedelta(seconds=t2), nearest_sample=True) #make a new trace by slicing cut_trace.write(cutfile, format='sac')
#read in uncorrected data for header info raw_file = boxpath + '/uncorrected/Event_'+ eventid + '/' + network + '_' + station + '_HHN_' + loc + '_' + eventid + '.SAC' stream = read(raw_file) tr = stream[0] # print('doing record: ' + base) evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km #km to cm dist = dist*100000. record_dist.append(dist) #read in file data = np.genfromtxt(record_path[i], dtype = float, comments = '#', delimiter = None, usecols = (0,1))#only read in first two cols record_freq.append(data[:,0]) #data is NE spectra #square for power spectra record_spec.append((data[:,1]*dist)**2.) #if network and station not part of the list yet add if station not in stationlist: stationlist.append(station) stn_lat.append(stlat) stn_lon.append(stlon) # print station, stlat, stlon
def cut_swave(infile, cutfile): #input an instrument corrected sac file, full path #reads in a sac file and cuts at the s wave arrival time and 120 s after #set up for HH sampling rate import matplotlib.pyplot as plt from obspy import read import dread import datetime # out = open(cutfile,'w') velocity = 3.5 #km/s, check and update with paper stream = read(infile) tr = stream[0] #df = tr.stats.sampling_rate origin_hour = tr.stats.sac.nzhour origin_min = tr.stats.sac.nzmin origin_sec = tr.stats.sac.nzsec origin_msec = tr.stats.sac.nzmsec trace_starttime = tr.stats.starttime #trace_endtime = tr.stats.endtime origin_time = (origin_hour * 60 * 60 + origin_min * 60 + origin_sec + origin_msec / 1000.) # in seconds after start of day trace_starttime_sec = tr.stats.sac.b #sec #difference between origin time and when the trace starts delta = origin_time - trace_starttime_sec # in sec origin_time_UTC = trace_starttime + datetime.timedelta( seconds=delta) #convert origin time to UTC evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km #print(tr.stats.sac.dist) s_travel_time = dist / velocity # in sec #s_arrival_time = origin_time + s_travel_time cuttime = origin_time_UTC + datetime.timedelta( seconds=s_travel_time) #add travel time or utc origin time cut_xval = ( cuttime - trace_starttime ) / 0.01 #using HH sampling rate, convert cut time into x value on plot data = tr.data # plt.figure(figsize = (25,6)) # plt.plot(data, color='black') # plt.xlim(0, len(data)) # plt.axvline(x=cut_xval, c = 'r')#first cut # plt.axvline(x=cut_xval + 120/0.01, c = 'r')#second cut # plt.show() cut_trace = tr.slice(cuttime, cuttime + datetime.timedelta(seconds=120), nearest_sample=True) #make a new trace by slicing data2 = cut_trace.data # plt.figure(figsize = (25,6)) # plt.plot(data2, color='black') # plt.xlim(0, len(data2)) # plt.show() cut_trace.write(cutfile, format='sac') return cuttime
t_evlat = [tobj.evlat[i] for i in t_index] t_evlon = [tobj.evlon[i] for i in t_index] t_evdep = [tobj.evdep[i] for i in t_index] t_tstar = [tobj.tstar[i] for i in t_index] r_evlat = [robj.elat[i] for i in r_index] r_evlon = [robj.elon[i] for i in r_index] r_evdep = [robj.edepth[i] for i in r_index] r_residual = [robj.path_terms[i] for i in r_index] #for each t* event, find the closest residual event for l in range(len(t_evlat)): # for l in range(10): d = [] for m in range(len(r_evlat)): dist = dread.compute_rrup(t_evlon[l], t_evlat[l], t_evdep[l], r_evlon[m], r_evlat[m], -1*r_evdep[m]) #in km # print(t_evlon[l], t_evlat[l], t_evdep[l], r_evlon[m], r_evlat[m], -1*r_evdep[m]) d.append(dist) if min(d) < match_dist: #it's a match!! ind = d.index(min(d)) # print '{0:23s} {1:6s} {2:15f} {3:12f} {4:12f} {5:12f} {6:12f} {7:12f} {8:12f} {9:12f} {10:12f}'.format(t_evid[l], sta_set[k], t_evlon[l], t_evlat[l], t_evdep[l], r_evlon[ind], r_evlat[ind], r_evdep[ind], d[ind], t_tstar[l], r_residual[ind]) v1.append(t_evid[l]) s.append(sta_set[k]) v2.append(t_evlon[l]) v3.append(t_evlat[l]) v4.append(t_evdep[l]) v5.append(r_evlon[ind]) v6.append(r_evlat[ind]) v7.append(r_evdep[ind]) v8.append(d[ind])
#Minimum number of stations for each event: min_stations=5 print 'Will use a buffer of %f, and minimum number of stations as %f' % (buffer,min_stations) ############# ############# print 'Reading in data' #Read in the data: evnum,evlat,evlon,evdep,sta,stlat,stlon,stelv,grcircle,ml,mw,pga_millig,source_i,receiver_i=dr.read_jsbfile(flatfile) print 'Computing Rrup' #Compute Rrup for the data: rrup=dr.compute_rrup(evlon,evlat,evdep,stlon,stlat,stelv) ###################### print 'Acquiring Vs30 from grid file' #Get Vs30: #Find unique stations so it can be saved to a file later: unique_stations=np.unique(sta) sta_index=[] for sta_i in range(len(unique_stations)): sta_index.append(int(np.where(sta==unique_stations[sta_i])[0][0])) #Get the lat and lon of these points only: stlon_unique=stlon[sta_index] stlat_unique=stlat[sta_index] # Write out the file to use for vs30 extraction:
def secondo(record_path, out_file_path): print 'Number of records: ', len(record_path) #read in all files to find networks and stations stationlist = [] stn_lat = [] stn_lon = [] eventidlist = [] event_lat = [] event_lon = [] event_depth = [] record_freq = [] record_spec = [] record_std = [] ############################################################################## ## read in the uncut sac files and get the distances between source and station t1 = time.time() for i in range(len(record_path)): record = (record_path[i].split('/')[-1]) base = path.basename(record) network, station, channel, loc = base.split('_')[0:4] yyyy, month, day, hh, mm, ss = base.split('_')[4:] ss = ss.split('.')[0] eventid = yyyy + '_' + month + '_' + day + '_' + hh + '_' + mm + '_' + ss #read in uncorrected data for header info raw_file = working_dir + '/corrected/Event_'+ eventid + '/' + network + '_' + station + '_HHN_' + loc + '_' + eventid + '.SAC' stream = read(raw_file) tr = stream[0] evlon = tr.stats.sac.evlo #deg evlat = tr.stats.sac.evla #deg evdepth = tr.stats.sac.evdp #km stlon = tr.stats.sac.stlo #deg stlat = tr.stats.sac.stla #deg stdepth = tr.stats.sac.stdp #km #find distance between event and station dist = dread.compute_rrup(evlon, evlat, evdepth, stlon, stlat, stdepth) #in km #km to m dist = dist*1000. #read in file data = np.genfromtxt(record_path[i], dtype = float, comments = '#', delimiter = None, usecols = (0,1,2))#only read in first two cols record_freq.append(data[:,0])## #data is NE spectra #square for power spectra ########################################################################### #propagation here for errors going lin to log power record_spec.append((data[:,1]*dist)**2.) std_prop = np.abs(2*(data[:,2])/(data[:,1]*np.log(10))) record_std.append(std_prop)#in log power here #if network and station not part of the list yet add if station not in stationlist: stationlist.append(station) stn_lat.append(stlat) stn_lon.append(stlon) if eventid not in eventidlist: eventidlist.append(eventid) event_lat.append(evlat) event_lon.append(evlon) event_depth.append(evdepth) t2 = time.time() print 'time to read and distance correct all records: ', (t2-t1)/60. print len(record_freq) print len(record_spec) freq_list = record_freq[0] print(freq_list) F_bins = len(freq_list) print(F_bins) rows = len(record_path) #testing first 10 print(rows) index_matrix = [[0 for j in range(3)] for i in range(rows)] #for i in range(len(records)): for i in range(rows): record = record_path[i].split('/')[-1] base = path.basename(record) network, station, channel, loc = base.split('_')[0:4] yyyy, month, day, hh, mm, ss = base.split('_')[4:] ss = ss.split('.')[0] eventid = yyyy + '_' + month + '_' + day + '_' + hh + '_' + mm + '_' + ss #make a tuple of record, event, station so indices can be assigned index_matrix[i] = [base, eventidlist.index(eventid), stationlist.index(station)] print(eventidlist[0]) print(stationlist) I = len(eventidlist)#events J = len(stationlist)#stations K = len(record_path)#records K = rows print 'Number of events: ', I, ' Number of stations: ', J print 'Number of rows (records): ', K, ' Number of cols (events+stations): ', I+J #make the G matrix of 1s and 0s and R matrix of records G1 = np.zeros((K,I)) G2 = np.zeros((K,J)) for k in range(K):#for all records G1[k][index_matrix[k][1]] = 1 #record row, eventid col G2[k][index_matrix[k][2]] = 1 #record row, station col G = np.concatenate((G1,G2), axis = 1) print(G) R = np.zeros((K,F_bins)) cov = np.zeros((K,F_bins)) #populate R matrix with the log of the record spectra (power record spectra) for k in range(K):#for all records #each row is a record, and col is a frequency band #set row equal to the that spectral array #here we take the log R[k:,] = np.log10(record_spec[k]) cov[k:,] = record_std[k] m1 = np.zeros((I+J, F_bins)) m_cov = np.zeros((I+J, F_bins)) #do the inversion for each freq for f in range(F_bins): t1 = time.time() d = R[:,f]#record for given frequency col dT = d.T print 'inverting for frequency: ', f, freq_list[f] G_inv = np.linalg.pinv(G, rcond=1e-13) covd = np.diag(cov[:,f]) covm = np.dot((np.dot(G_inv, covd)), G_inv.T) m1[:,f] = np.dot(G_inv,dT) m_cov[:,f]= covm.diagonal() t2 = time.time() print 'time for inversion: (min) ', round((t2-t1)/60., 4) print(m1.shape) #now split m into an event matrix and a station matrix event = m1[0:I,:] #take first I rows station = m1[I:I+J,:] event_cov = m_cov[0:I,:] station_cov = m_cov[I:I+J,:] print(event.shape, station.shape) print(event_cov.shape, station_cov.shape) for i in range(I):#for each event #go from the log of the power spectra to the regular spectra in m amp = np.sqrt(np.power(10.0, event[i,:])) std = (np.sqrt(np.abs(event_cov[i,:])/2.)*((amp)*(np.log(10)))) outfile = open(outfile_path + '/' + eventidlist[i] + '.out', 'w') out = (np.array([freq_list, amp, std])).T outfile.write('#freq_bins \t vel_spec_NE_m \t stdev_m \n') np.savetxt(outfile, out, fmt=['%E', '%E', '%E'], delimiter='\t') outfile.close() print outfile_path for i in range(J):#for each station amp = np.sqrt(np.power(10.0, station[i,:])) std1 = np.sqrt((station_cov[i,:])) std = np.abs((std1/2.)*(amp)*(np.log(10))) outfile = open(outfile_path + '/' + stationlist[i] + '.out', 'w') out = (np.array([freq_list, amp, std])).T outfile.write('#freq_bins \t vel_spec_NE_m \t stdev_m \n') np.savetxt(outfile, out, fmt=['%E', '%E', '%E'], delimiter='\t') outfile.close()
#%% #order stations by distance to the source source_lat = 44.090 #N source_lon = -122.831 #°W source_dep = 4.0 #km x = [] for i in range(len(test)): name_specfem = (test[i].split('/')[-1])[0:-4] nets, stas, chans, ns = name_specfem.split('.') print name_specfem for j in range(len(stnm)): if stnm[j] == stas and chan[j][2] == plotchan and chans[ 2] == plotchanspecfem: print stnm[j], stas, chans, ns dist = dread.compute_rrup(source_lon, source_lat, source_dep, lon[j], lat[j], 0.0) x.append([stnm[j], test[i], dist]) station_dist = sorted(x, key=lambda x: x[2]) n = len(station_dist) ##%% ##make a n x 2 figure of each station with data on left and specfem on right #n = len(station_dist) #fig, (axs) = plt.subplots(n,2, sharex=True,figsize = (16,10)) # #for i in range(len(station_dist)): # print station_dist[i][0] # specfem = station_dist[i][1] # r = round(station_dist[i][2],2)
if stns[j] == pcat[l][1]: db_DA.append(pcat[l][2]) break db_sta.append(stns[j]) db_stelv.append(data.stelv[k]) db_stlat.append(data.stlat[k]) db_stlon.append(data.stlon[k]) db_vs30.append(data.vs30[k]) db_vs30method.append(data.vs30_method[k]) ind = np.where(tstarcat['site'] == (stns[j])) db_kappa.append(tstarcat['tstars'][ind]) dist = dread.compute_rrup(cat[i][3], cat[i][2], cat[i][4], data.stlon[k], data.stlat[k], -1 * data.stelv[k]) #in km db_r.append(dist) print ev, stns[j], data.stelv[k], data.stlat[ k], dist, data.vs30[k], tstarcat['tstars'][ind], M, cat[i][ 2] break #make other things 0 db_N = np.zeros(len(db_evnum)) db_DV = np.zeros(len(db_evnum)) db_sourcei = np.zeros(len(db_evnum)) db_receiveri = np.zeros(len(db_evnum)) db_pga_snr = np.zeros(len(db_evnum))