def on_data(self, trace):
global i
global traces
global fn
global day
if i == 1:
print('Received traces. Checking for existing data...')
if (os.path.isfile(fn)):
print('Found %s, reading...' % fn)
traces = read(fn)
print('Done.')
else:
print('No data found. Creating new blank trace to write to...')
traces = Trace()
traces = trace
print('Trace %s: %s' % (i, trace))
else:
print('Trace %s: %s' % (i, trace))
traces += trace
traces.__add__(trace)
if (float(i) / 10. == int(float(i) / 10.)):
print('Saving %s traces to %s...' % (i, fn))
traces.write(fn, format='MSEED')
print('Done.')
i += 1
if (day != UTCDateTime.now().strftime('%Y.%j')):
day = UTCDateTime.now().strftime('%Y.%j')
fn = fn = '%s.%s.%s.%s.D.%s' % (net, sta, loc, cha, day)
i = 1
def love_pick(self,
T_trace,
la_s,
lo_s,
depth,
save_directory,
time_at_rec,
npts,
filter=True,
plot_modus=False):
if plot_modus == True:
dir_L = save_directory + '/Love_waves'
if not os.path.exists(dir_L):
os.makedirs(dir_L)
Love_st = Stream()
evla = la_s
evlo = lo_s
rec = instaseis.Receiver(latitude=self.prior['la_r'],
longitude=self.prior['lo_r'])
dist, az, baz = gps2dist_azimuth(lat1=evla,
lon1=evlo,
lat2=self.prior['la_r'],
lon2=self.prior['lo_r'],
a=self.prior['radius'],
f=0)
# For now I am just using the Z-component, because this will have the strongest Rayleigh signal:
T_comp = T_trace.copy()
if plot_modus == True:
T_comp.plot(outfile=dir_L + '/sw_entire_waveform.pdf')
phases = self.get_L_phases(time_at_rec)
for i in range(len(phases)):
if plot_modus == True:
dir_phases = dir_L + '/%s' % phases[i]['name']
if not os.path.exists(dir_phases):
os.makedirs(dir_phases)
trial = T_trace.copy()
if filter == True:
trial.detrend(type="demean")
trial.filter('highpass',
freq=phases[i]['fmin'],
zerophase=True)
trial.filter('lowpass', freq=phases[i]['fmax'], zerophase=True)
trial.detrend()
if plot_modus == True:
start_vline = int(
(phases[i]['starttime'](dist, depth).timestamp -
time_at_rec.timestamp) / trial.stats.delta)
end_vline = int((phases[i]['endtime'](dist, depth).timestamp -
time_at_rec.timestamp) / trial.stats.delta)
plt.figure(1)
ax = plt.subplot(111)
plt.plot(trial.data, alpha=0.5)
ymin, ymax = ax.get_ylim()
# plt.plot(trial.data)
plt.vlines([start_vline, end_vline], ymin, ymax)
plt.xlabel(time_at_rec.strftime('%Y-%m-%dT%H:%M:%S + sec'))
plt.savefig(dir_phases + '/sw_with_Love_windows.pdf')
plt.tight_layout()
plt.close()
if filter == True:
trial.detrend(type="demean")
env = envelope(trial.data)
trial.data = env
trial.trim(starttime=phases[i]['starttime'](dist, depth),
endtime=phases[i]['endtime'](dist, depth))
else:
env = trial.data
if plot_modus == True:
plt.figure(2)
plt.plot(trial, label='%s' % phases[i]['name'])
plt.legend()
plt.tight_layout()
plt.savefig(dir_phases +
'/Love_envelope_filter_%s.pdf' % phases[i]['name'])
plt.close()
zero_trace = Trace(np.zeros(npts),
header={
"starttime": phases[i]['starttime'](dist,
depth),
'delta': trial.meta.delta,
"station": trial.meta.station,
"network": trial.meta.network,
"location": trial.meta.location,
"channel": phases[i]['name']
})
total_trace = zero_trace.__add__(trial,
method=0,
interpolation_samples=0,
fill_value=trial.data,
sanity_checks=False)
Love_st.append(total_trace)
if plot_modus == True:
plt.figure(3)
plt.plot(Love_st.traces[0].data,
label='%s' % Love_st.traces[0].meta.channel)
plt.plot(Love_st.traces[1].data,
label='%s' % Love_st.traces[1].meta.channel)
plt.plot(Love_st.traces[2].data,
label='%s' % Love_st.traces[2].meta.channel)
plt.plot(Love_st.traces[3].data,
label='%s' % Love_st.traces[3].meta.channel)
plt.legend()
plt.tight_layout()
plt.savefig(dir_L + '/diff_Love_freq.pdf')
plt.close()
return Love_st
def pick_sw(self,
stream,
pick_info,
epi,
prior,
npts,
directory,
plot_modus=False):
if plot_modus == True:
dir_SW = directory + '/Blind_rayleigh'
if not os.path.exists(dir_SW):
os.makedirs(dir_SW)
Rayleigh_st = Stream()
Love_st = Stream()
dist = degrees2kilometers(epi, prior['radius'])
phase = 0
for pick in pick_info:
if pick['phase_name'] == 'R1':
if plot_modus == True:
dir_phases = dir_SW + '/Rayleigh_%.2f_%.2f' % (
pick['lower_frequency'], pick['upper_frequency'])
if not os.path.exists(dir_phases):
os.makedirs(dir_phases)
Z_trace = stream.traces[0].copy()
if plot_modus == True:
Z_trace.plot(outfile=dir_SW + '/Z_comp.pdf')
Z_trace.detrend(type="demean")
if (pick['lower_frequency']
== float(0.0)) and (pick['upper_frequency']
== float(0.0)):
pass
else:
Z_trace.filter('highpass',
freq=pick['lower_frequency'],
zerophase=True)
Z_trace.filter('lowpass',
freq=pick['upper_frequency'],
zerophase=True)
Z_trace.detrend()
Z_trace.detrend(type="demean")
if plot_modus == True:
start_vline = int(
((pick['time'].timestamp - pick['lower_uncertainty']) -
Z_trace.meta.starttime.timestamp) /
Z_trace.stats.delta)
end_vline = int(
((pick['time'].timestamp + pick['lower_uncertainty']) -
Z_trace.meta.starttime.timestamp) /
Z_trace.stats.delta)
plt.figure()
ax = plt.subplot(111)
plt.plot(Z_trace.data, alpha=0.5)
ymin, ymax = ax.get_ylim()
plt.plot(Z_trace.data)
plt.vlines([start_vline, end_vline], ymin, ymax)
plt.xlabel(
Z_trace.meta.starttime.strftime(
'%Y-%m-%dT%H:%M:%S + sec'))
plt.tight_layout()
plt.savefig(dir_phases + '/sw_with_Rayleigh_windows.pdf')
# plt.show()
plt.close()
Period = 1.0 / pick['frequency']
Z_trace.trim(starttime=pick['time'] - Period,
endtime=pick['time'] + Period)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": pick['time'] - Period,
'delta': Z_trace.meta.delta,
"station": Z_trace.meta.station,
"network": Z_trace.meta.network,
"location": Z_trace.meta.location,
"channel": Z_trace.meta.channel
})
total_trace = zero_trace.__add__(Z_trace,
method=0,
interpolation_samples=0,
fill_value=Z_trace.data,
sanity_checks=False)
Rayleigh_st.append(total_trace)
if plot_modus == True:
plt.figure()
plt.plot(
Z_trace.data,
label='%.2f_%.2f' %
(pick['lower_frequency'], pick['upper_frequency']))
plt.legend()
plt.tight_layout()
plt.savefig(dir_phases + '/diff_Love_freq.pdf')
plt.close()
elif pick['phase_name'] == 'G1':
if plot_modus == True:
dir_phases = dir_SW + '/Love_%.2f_%.2f' % (
pick['lower_frequency'], pick['upper_frequency'])
if not os.path.exists(dir_phases):
os.makedirs(dir_phases)
T_trace = stream.traces[2].copy()
if plot_modus == True:
T_trace.plot(outfile=dir_SW + '/T_comp.pdf')
T_trace.detrend(type="demean")
if (pick['lower_frequency']
== float(0.0)) and (pick['upper_frequency']
== float(0.0)):
pass
else:
T_trace.filter('highpass',
freq=pick['lower_frequency'],
zerophase=True)
T_trace.filter('lowpass',
freq=pick['upper_frequency'],
zerophase=True)
T_trace.detrend()
T_trace.detrend(type="demean")
if plot_modus == True:
start_vline = int(
((pick['time'].timestamp - pick['lower_uncertainty']) -
T_trace.meta.starttime.timestamp) /
T_trace.stats.delta)
end_vline = int(
((pick['time'].timestamp + pick['lower_uncertainty']) -
T_trace.meta.starttime.timestamp) /
T_trace.stats.delta)
plt.figure()
ax = plt.subplot(111)
plt.plot(T_trace.data, alpha=0.5)
ymin, ymax = ax.get_ylim()
plt.plot(T_trace.data)
plt.vlines([start_vline, end_vline], ymin, ymax)
plt.xlabel(
T_trace.meta.starttime.strftime(
'%Y-%m-%dT%H:%M:%S + sec'))
plt.tight_layout()
plt.savefig(dir_phases + '/sw_with_Love_windows.pdf')
# plt.show()
plt.close()
Period = 1.0 / pick['frequency']
T_trace.trim(starttime=pick['time'] - Period,
endtime=pick['time'] + Period)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": pick['time'] - Period,
'delta': T_trace.meta.delta,
"station": T_trace.meta.station,
"network": T_trace.meta.network,
"location": T_trace.meta.location,
"channel": T_trace.meta.channel
})
total_trace = zero_trace.__add__(T_trace,
method=0,
interpolation_samples=0,
fill_value=T_trace.data,
sanity_checks=False)
Love_st.append(total_trace)
if plot_modus == True:
plt.figure()
plt.plot(
T_trace.data,
label='%.2f_%.2f' %
(pick['lower_frequency'], pick['upper_frequency']))
plt.legend()
plt.tight_layout()
plt.savefig(dir_phases + '/diff_Love_freq.pdf')
plt.close()
return Rayleigh_st, Love_st
def get_window_obspy(self, seis_traces, epi, depth, time, npts):
tt_P = self.get_P(
epi, depth
) # Estimated P-wave arrival, based on the known velocity model
tt_S = self.get_S(
epi, depth
) # Estimated S-wave arrival, based on the known velocity model
sec_per_sample = 1 / (seis_traces[0].meta.sampling_rate)
#
total_stream = Stream()
s_stream = Stream()
p_stream = Stream()
p_time = time.timestamp + tt_P
s_time = time.timestamp + tt_S
start_time_p = obspy.UTCDateTime(p_time - 5)
start_time_s = obspy.UTCDateTime(s_time - 15)
end_time_p = obspy.UTCDateTime(p_time + 20)
end_time_s = obspy.UTCDateTime(s_time + 35)
#
for i, trace in enumerate(seis_traces.traces):
P_trace = Trace.slice(trace, start_time_p, end_time_p)
S_trace = Trace.slice(trace, start_time_s, end_time_s)
#
# params = {'legend.fontsize': 'x-large',
# 'figure.figsize': (15, 15),
# 'axes.labelsize': 25,
# 'axes.titlesize': 'x-large',
# 'xtick.labelsize': 25,
# 'ytick.labelsize': 25}
# pylab.rcParams.update(params)
# fig = plt.figure(figsize=(10, 10))
# time_array = np.arange(len(trace)) * trace.meta.delta
# Axes = plt.subplot()
# Axes.plot(time_array, trace, c='k', label = 'Z-component')
# ymin, ymax = Axes.get_ylim()
# x_cor = [start_time_p.timestamp - trace.meta.starttime.timestamp,
# end_time_p.timestamp - trace.meta.starttime.timestamp,
# end_time_p.timestamp - trace.meta.starttime.timestamp,
# start_time_p.timestamp - trace.meta.starttime.timestamp,
# start_time_p.timestamp - trace.meta.starttime.timestamp]
# y_cor = [ymax / 10.0, ymax / 10.0, ymin / 10.0, ymin / 10.0, ymax / 10.0]
# plt.plot(x_cor,y_cor,c='r')
# x_cor_s = [start_time_s.timestamp - trace.meta.starttime.timestamp,
# end_time_s.timestamp - trace.meta.starttime.timestamp,
# end_time_s.timestamp - trace.meta.starttime.timestamp,
# start_time_s.timestamp - trace.meta.starttime.timestamp,
# start_time_s.timestamp - trace.meta.starttime.timestamp]
# y_cor_s = [ymax / 10.0, ymax / 10.0, ymin / 10.0, ymin / 10.0, ymax / 10.0]
# plt.plot(x_cor_s,y_cor_s,c='r')
# # Axes.axhline(y=ymin, color='r')
# # Axes.axhline(y=ymax, color='r')
# # plt.vlines(start_time_p,ymin=ymin,ymax=ymax,colors='r',label='P pick')
# # plt.vlines(end_time_p,ymin=ymin,ymax=ymax,colors='r')
#
#
# phases = (dict(starttime=lambda dist, depth: time + dist / 2.8,
# endtime=lambda dist, depth: time + dist / 2.6,
# comp='Z',
# fmin=1. / 20.,
# fmax=1. / 10.,
# dt=5.0,
# name='R1_10_20'))
# # trace.detrend(type="demean")
# # trace.filter('highpass', freq=phases['fmin'], zerophase=True)
# # trace.filter('lowpass', freq=phases['fmax'], zerophase=True)
# # trace.detrend()
# start = phases['starttime'](2716.72921884, 10000)
# end = phases['endtime'](2716.72921884, 10000)
# start_vline = int(
# (phases['starttime'](2716.72921884, 10000).timestamp- time.timestamp))
# end_vline = int(
# (phases['endtime'](2716.72921884, 10000).timestamp - time.timestamp))
#
# y_cor_R = [ymin,ymin,ymax,ymax,ymin]
# x_cor_R = [start_vline,end_vline,end_vline,start_vline,start_vline]
#
# plt.plot(x_cor_R, y_cor_R, c='g')
# Axes.legend()
# Axes.ticklabel_format(style="sci", axis='y', scilimits=(-2, 2))
# Axes.set_xlabel(trace.meta.starttime.strftime('Time : %Y-%m-%dT%H:%M:%S + [sec]'))
# Axes.set_ylabel("Displacement [m]")
# plt.tight_layout()
# # plt.show()
# plt.savefig('/home/nienke/Documents/Applied_geophysics/Thesis/anaconda/Final/check_waveforms' + '/picks.pdf')
# plt.close()
#
# # v_p_start = start_time_p
stream_add = P_trace.__add__(S_trace,
fill_value=0,
sanity_checks=True)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": start_time_p,
'delta': trace.meta.delta,
"station": trace.meta.station,
"network": trace.meta.network,
"location": trace.meta.location,
"channel": trace.meta.channel
})
if 'T' in trace.meta.channel:
total_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_s_trace = total_trace.copy()
else:
total_trace = zero_trace.__add__(stream_add,
method=0,
interpolation_samples=0,
fill_value=stream_add.data,
sanity_checks=True)
total_s_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_p_trace = zero_trace.__add__(P_trace,
method=0,
interpolation_samples=0,
fill_value=P_trace.data,
sanity_checks=True)
p_stream.append(total_p_trace)
s_stream.append(total_s_trace)
total_stream.append(total_trace)
s_stream = self.BW_filter(s_stream)
p_stream = self.BW_filter(p_stream)
total_stream = self.BW_filter(total_stream)
return total_stream, p_stream, s_stream, start_time_p, start_time_s
def get_window_split_syn(self, splitted_syn, epi, depth, time_at_receiver,
npts):
tt_P = self.get_P(
epi, depth
) # Estimated P-wave arrival, based on the known velocity model
tt_S = self.get_S(
epi, depth
) # Estimated S-wave arrival, based on the known velocity model
diff = tt_S - tt_P
P_start = time_at_receiver
P_end = obspy.UTCDateTime(P_start + 5 + 20)
S_start = obspy.UTCDateTime(time_at_receiver.timestamp + diff)
S_end = obspy.UTCDateTime(S_start + 5 + 20)
p_stream = Stream()
s_stream = Stream()
total_stream = Stream()
for i, trace in enumerate(splitted_syn.traces):
P_trace = Trace.slice(trace, P_start, P_end)
S_trace = Trace.slice(trace, S_start, S_end)
stream_add = P_trace.__add__(S_trace,
fill_value=0,
sanity_checks=True)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": P_start,
'delta': trace.meta.delta,
"station": trace.meta.station,
"network": trace.meta.network,
"location": trace.meta.location,
"channel": trace.meta.channel,
"instaseis": trace.meta.instaseis
})
if 'T' in trace.meta.channel:
total_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_s_trace = total_trace.copy()
else:
total_trace = zero_trace.__add__(stream_add,
method=0,
interpolation_samples=0,
fill_value=stream_add.data,
sanity_checks=True)
total_s_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_p_trace = zero_trace.__add__(P_trace,
method=0,
interpolation_samples=0,
fill_value=P_trace.data,
sanity_checks=True)
p_stream.append(total_p_trace)
s_stream.append(total_s_trace)
total_stream.append(total_trace)
return total_stream, p_stream, s_stream
def get_sw(self, time_at_rec, epi, depth, la_s, lo_s, npts_trace):
gf = self.db.get_greens_function(epicentral_distance_in_degree=epi,
source_depth_in_m=depth,
origin_time=time_at_rec,
kind=self.par['kind'],
kernelwidth=self.par['kernelwidth'],
definition=self.par['definition'])
dist, az, baz = gps2dist_azimuth(lat1=la_s,
lon1=lo_s,
lat2=self.par['la_r'],
lon2=self.par['lo_r'],
a=self.par['radius'],
f=0)
Surface = Surface_waves(self.par)
Phases_R = Surface.get_R_phases(time_at_rec)
Phases_L = Surface.get_L_phases(time_at_rec)
for j, R in enumerate(Phases_R):
R_format_gf = Stream()
run = gf.copy()
for i in range(len(gf.traces)):
if 'Z' not in gf.traces[i].id:
continue
else:
R_trim = run.traces[i].trim(
starttime=R['starttime'](dist, depth),
endtime=R['endtime'](dist, depth))
zero_trace = Trace(np.zeros(npts_trace),
header={
"starttime": R['starttime'](dist,
depth),
'delta': gf.traces[0].meta.delta,
'definition':
self.par['definition'],
'kernelwidth':
self.par['kernelwidth'],
'kind': self.par['kind'],
"instaseis":
gf.traces[0].meta.instaseis,
'channel': gf.traces[i].id
})
R_Trace = Trace(R_trim.data,
header={
"starttime": R['starttime'](dist,
depth),
'delta': gf.traces[0].meta.delta,
'definition': self.par['definition'],
'kernelwidth': self.par['kernelwidth'],
'kind': self.par['kind'],
"instaseis":
gf.traces[0].meta.instaseis,
'channel': gf.traces[i].id
})
filled_trace = zero_trace.__add__(R_Trace,
method=0,
interpolation_samples=0,
fill_value=R_Trace.data,
sanity_checks=False)
R_format_gf.append(filled_trace)
zss = R_format_gf.traces[0].data
zds = R_format_gf.traces[1].data
zdd = R_format_gf.traces[2].data
zep = R_format_gf.traces[3].data
G_R_Z = np.ones((npts_trace, 5))
G_R_Z[:, 0] = zss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az'])) - zdd * 0.5
G_R_Z[:, 1] = -zdd * 0.5 - zss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az']))
# R_Zz G[0:G_z, 1] = zdd * (1/3) + zep * (1/3)
G_R_Z[:, 2] = zss * np.sin(2 * np.deg2rad(self.par['az']))
G_R_Z[:, 3] = -zds * np.cos(np.deg2rad(self.par['az']))
G_R_Z[:, 4] = -zds * np.sin(np.deg2rad(self.par['az']))
R_new = np.vstack((G_R_Z)) if j == 0 else np.vstack((R_new, G_R_Z))
for j, L in enumerate(Phases_L):
L_format_gf = Stream()
run = gf.copy()
for i in range(len(gf.traces)):
if 'T' not in gf.traces[i].id:
continue
else:
L_trim = run.traces[i].trim(
starttime=L['starttime'](dist, depth),
endtime=L['endtime'](dist, depth))
zero_trace = Trace(np.zeros(npts_trace),
header={
"starttime": L['starttime'](dist,
depth),
'delta': gf.traces[0].meta.delta,
'definition':
self.par['definition'],
'kernelwidth':
self.par['kernelwidth'],
'kind': self.par['kind'],
"instaseis":
gf.traces[0].meta.instaseis,
'channel': gf.traces[i].id
})
L_Trace = Trace(L_trim.data,
header={
"starttime": L['starttime'](dist,
depth),
'delta': gf.traces[0].meta.delta,
'definition': self.par['definition'],
'kernelwidth': self.par['kernelwidth'],
'kind': self.par['kind'],
"instaseis":
gf.traces[0].meta.instaseis,
'channel': gf.traces[i].id
})
filled_trace = zero_trace.__add__(L_Trace,
method=0,
interpolation_samples=0,
fill_value=L_Trace.data,
sanity_checks=False)
L_format_gf.append(filled_trace)
tss = L_format_gf.traces[0].data
tds = L_format_gf.traces[1].data
G_L_T = np.ones((npts_trace, 5))
G_L_T[:, 0] = -tss * (0.5) * np.sin(2 * np.deg2rad(self.par['az']))
G_L_T[:, 1] = tss * (0.5) * np.sin(2 * np.deg2rad(self.par['az']))
# L_Tt G[G_r:G_t, 1] = 0
G_L_T[:, 2] = tss * np.cos(2 * np.deg2rad(self.par['az']))
G_L_T[:, 3] = tds * np.sin(np.deg2rad(self.par['az']))
G_L_T[:, 4] = -tds * np.cos(np.deg2rad(self.par['az']))
L_new = np.vstack((G_L_T)) if j == 0 else np.vstack((L_new, G_L_T))
G_R_L = np.vstack((R_new, L_new))
return G_R_L, R_new, L_new
def get_bw(self, time_at_rec, epi, depth, npts_trace):
gf = self.db.get_greens_function(epicentral_distance_in_degree=epi,
source_depth_in_m=depth,
origin_time=time_at_rec,
kind=self.par['kind'],
kernelwidth=self.par['kernelwidth'],
definition=self.par['definition'])
tt_P = self.window.get_P(epi, depth)
tt_S = self.window.get_S(epi, depth)
p_time = time_at_rec.timestamp + tt_P
s_time = time_at_rec.timestamp + tt_S
start_time_p = obspy.UTCDateTime(p_time - 10)
start_time_s = obspy.UTCDateTime(s_time - 10)
end_time_p = obspy.UTCDateTime(p_time + 44.2)
end_time_s = obspy.UTCDateTime(s_time + 44.2)
format_gf = Stream()
for i in range(len(gf.traces)):
if i == 0 or i == 3:
stream_add = Trace.slice(gf.traces[i], start_time_s,
end_time_s)
else:
P_trace = Trace.slice(gf.traces[i], start_time_p, end_time_p)
S_trace = Trace.slice(gf.traces[i], start_time_s, end_time_s)
stream_add = P_trace.__add__(S_trace,
fill_value=0,
sanity_checks=True)
zero_trace = Trace(np.zeros(npts_trace),
header={
"starttime": start_time_p,
'delta': gf.traces[0].meta.delta,
'definition': self.par['definition'],
'kernelwidth': self.par['kernelwidth'],
'kind': self.par['kind'],
"instaseis": gf.traces[0].meta.instaseis,
'channel': gf.traces[i].id
})
filled_trace = zero_trace.__add__(stream_add,
method=0,
interpolation_samples=0,
fill_value=stream_add.data,
sanity_checks=False)
format_gf.append(filled_trace)
tss = format_gf.traces[0].data
zss = format_gf.traces[1].data
rss = format_gf.traces[2].data
tds = format_gf.traces[3].data
zds = format_gf.traces[4].data
rds = format_gf.traces[5].data
zdd = format_gf.traces[6].data
rdd = format_gf.traces[7].data
zep = format_gf.traces[8].data
rep = format_gf.traces[9].data
G_z = np.ones((npts_trace, 5))
G_r = np.ones((npts_trace, 5))
G_t = np.ones((npts_trace, 5))
G_z[:, 0] = zss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az'])) - zdd * 0.5
G_z[:, 1] = -zdd * 0.5 - zss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az']))
# _z G[0:G_z, 1] = zdd * (1/3) + zep * (1/3)
G_z[:, 2] = zss * np.sin(2 * np.deg2rad(self.par['az']))
G_z[:, 3] = -zds * np.cos(np.deg2rad(self.par['az']))
G_z[:, 4] = -zds * np.sin(np.deg2rad(self.par['az']))
G_r[:, 0] = rss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az'])) - rdd * 0.5
G_r[:, 1] = -0.5 * rdd - rss * (0.5) * np.cos(
2 * np.deg2rad(self.par['az']))
# _r G[G_z:G_r, 1] = rdd * (1/3) + rep * (1/3)
G_r[:, 2] = rss * np.sin(2 * np.deg2rad(self.par['az']))
G_r[:, 3] = -rds * np.cos(np.deg2rad(self.par['az']))
G_r[:, 4] = -rds * np.sin(np.deg2rad(self.par['az']))
G_t[:, 0] = -tss * (0.5) * np.sin(2 * np.deg2rad(self.par['az']))
G_t[:, 1] = tss * (0.5) * np.sin(2 * np.deg2rad(self.par['az']))
# _t G[G_r:G_t, 1] = 0
G_t[:, 2] = tss * np.cos(2 * np.deg2rad(self.par['az']))
G_t[:, 3] = tds * np.sin(np.deg2rad(self.par['az']))
G_t[:, 4] = -tds * np.cos(np.deg2rad(self.par['az']))
G_tot = np.vstack((np.vstack((G_z, G_r)), G_t))
return G_tot, G_z, G_r, G_t
def get_window_obspy(self, seis_traces, epi, depth, time, npts):
self.origin = seis_traces
tt_P = self.get_P(
epi, depth
) # Estimated P-wave arrival, based on the known velocity model
tt_S = self.get_S(
epi, depth
) # Estimated S-wave arrival, based on the known velocity model
sec_per_sample = 1 / (seis_traces[0].meta.sampling_rate)
#
self.BW_stream = Stream()
self.S_stream = Stream()
self.P_stream = Stream()
p_time = time.timestamp + tt_P
s_time = time.timestamp + tt_S
self.start_P = obspy.UTCDateTime(p_time - 5)
self.start_S = obspy.UTCDateTime(s_time - 15)
self.or_S_len = int(
(self.start_S - time) / seis_traces.traces[0].stats.delta)
self.or_P_len = int(
(self.start_P - time) / seis_traces.traces[0].stats.delta)
end_time_p = obspy.UTCDateTime(p_time + 20)
end_time_s = obspy.UTCDateTime(s_time + 35)
for i, trace in enumerate(seis_traces.traces):
P_trace = Trace.slice(trace, self.start_P, end_time_p)
self.P_len = len(P_trace)
S_trace = Trace.slice(trace, self.start_S, end_time_s)
self.S_len = len(S_trace)
stream_add = P_trace.__add__(S_trace,
fill_value=0,
sanity_checks=True)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": self.start_P,
'delta': trace.meta.delta,
"station": trace.meta.station,
"network": trace.meta.network,
"location": trace.meta.location,
"channel": trace.meta.channel
})
if 'T' in trace.meta.channel:
total_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_s_trace = total_trace.copy()
else:
total_trace = zero_trace.__add__(stream_add,
method=0,
interpolation_samples=0,
fill_value=stream_add.data,
sanity_checks=True)
total_s_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_p_trace = zero_trace.__add__(P_trace,
method=0,
interpolation_samples=0,
fill_value=P_trace.data,
sanity_checks=True)
self.P_stream.append(total_p_trace)
self.S_stream.append(total_s_trace)
self.BW_stream.append(total_trace)
self.S_stream = self.BW_filter(self.S_stream)
self.P_stream = self.BW_filter(self.P_stream)
self.BW_stream = self.BW_filter(self.BW_stream)
def get_window_obspy(self, seis_traces, epi, depth, or_time, npts):
tt_P = self.get_P(
epi, depth
) # Estimated P-wave arrival, based on the known velocity model
tt_S = self.get_S(
epi, depth
) # Estimated S-wave arrival, based on the known velocity model
sec_per_sample = 1 / (seis_traces[0].meta.sampling_rate)
total_stream = Stream()
s_stream = Stream()
p_stream = Stream()
p_time = or_time.timestamp + tt_P
s_time = or_time.timestamp + tt_S
start_time_p = obspy.UTCDateTime(
p_time - 5) # -10 , + 44.2 --> PAPER: STAHLER & SIGLOCH
end_time_p = obspy.UTCDateTime(p_time + 20)
start_time_s = obspy.UTCDateTime(s_time - 15)
end_time_s = obspy.UTCDateTime(s_time + 35)
for i, trace in enumerate(seis_traces.traces):
P_trace = Trace.slice(trace, start_time_p, end_time_p)
# P_trace.detrend(type='demean')
S_trace = Trace.slice(trace, start_time_s, end_time_s)
# S_trace.detrend(type='demean')
stream_add = P_trace.__add__(S_trace,
fill_value=0,
sanity_checks=True)
zero_trace = Trace(np.zeros(npts),
header={
"starttime": start_time_p,
'delta': trace.meta.delta,
"station": trace.meta.station,
"network": trace.meta.network,
"location": trace.meta.location,
"channel": trace.meta.channel
})
if 'T' in trace.meta.channel:
total_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_s_trace = total_trace.copy()
else:
total_trace = zero_trace.__add__(stream_add,
method=0,
interpolation_samples=0,
fill_value=stream_add.data,
sanity_checks=True)
total_s_trace = zero_trace.__add__(S_trace,
method=0,
interpolation_samples=0,
fill_value=S_trace.data,
sanity_checks=True)
total_p_trace = zero_trace.__add__(P_trace,
method=0,
interpolation_samples=0,
fill_value=P_trace.data,
sanity_checks=True)
p_stream.append(total_p_trace)
s_stream.append(total_s_trace)
total_stream.append(total_trace)
s_stream = self.BW_filter(s_stream)
p_stream = self.BW_filter(p_stream)
total_stream = self.BW_filter(total_stream)
return total_stream, p_stream, s_stream, start_time_p, start_time_s
