def bandwidth(data, fs, smoothie, fk):
"""
Bandwidth of a signal.
Computes the bandwidth of the given data which can be windowed or not.
The bandwidth corresponds to the level where the power of the spectrum is
half its maximum value. It is determined as the level of 1/sqrt(2) times
the maximum Fourier amplitude.
If data are windowed the bandwidth of each window is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to make envelope of.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **bandwidth[, dbwithd]** - Bandwidth, Time derivative of
predominant period (windowed only).
"""
new_dtype = np.float32 if data.dtype.itemsize == 4 else np.float64
data = np.require(data, dtype=new_dtype)
nfft = util.next_pow_2(data.shape[1])
freqaxis = np.linspace(0, fs, nfft + 1)
bwith = np.zeros(data.shape[0])
f = fftpack.fft(data, nfft)
f_sm = util.smooth(abs(f[:, 0:nfft // 2]), 10)
if np.size(data.shape) > 1:
i = 0
for row in f_sm:
minfc = abs(row - max(abs(row * (1 / np.sqrt(2)))))
[mdist_ind, _mindist] = min(enumerate(minfc), key=itemgetter(1))
bwith[i] = freqaxis[mdist_ind]
i = i + 1
# bwith_add = \
# np.append(np.append([bandwidth[0]] * (np.size(fk) // 2), bandwidth),
# [bandwidth[np.size(bandwidth) - 1]] * (np.size(fk) // 2))
# faster alternative
bwith_add = np.hstack(
([bwith[0]] * (np.size(fk) // 2), bwith,
[bwith[np.size(bwith) - 1]] * (np.size(fk) // 2)))
dbwith = signal.lfilter(fk, 1, bwith_add)
# dbwith = dbwith[np.size(fk) // 2:(np.size(dbwith) -
# np.size(fk) // 2)]
# correct start and end values of time derivative
dbwith = dbwith[np.size(fk) - 1:]
bwith = util.smooth(bwith, smoothie)
dbwith = util.smooth(dbwith, smoothie)
return bwith, dbwith
else:
minfc = abs(data - max(abs(data * (1 / np.sqrt(2)))))
[mdist_ind, _mindist] = min(enumerate(minfc), key=itemgetter(1))
bwith = freqaxis[mdist_ind]
return bwith
def bandwidth(data, fs, smoothie, fk):
"""
Bandwidth of a signal.
Computes the bandwidth of the given data which can be windowed or not.
The bandwidth corresponds to the level where the power of the spectrum is
half its maximum value. It is determined as the level of 1/sqrt(2) times
the maximum Fourier amplitude.
If data are windowed the bandwidth of each window is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to make envelope of.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **bandwidth[, dbwithd]** - Bandwidth, Time derivative of
predominant period (windowed only).
"""
new_dtype = np.float32 if data.dtype.itemsize == 4 else np.float64
data = np.require(data, dtype=new_dtype)
nfft = util.next_pow_2(data.shape[1])
freqaxis = np.linspace(0, fs, nfft + 1)
bwith = np.zeros(data.shape[0])
f = fftpack.fft(data, nfft)
f_sm = util.smooth(abs(f[:, 0:nfft // 2]), 10)
if np.size(data.shape) > 1:
i = 0
for row in f_sm:
minfc = abs(row - max(abs(row * (1 / np.sqrt(2)))))
[mdist_ind, _mindist] = min(enumerate(minfc), key=itemgetter(1))
bwith[i] = freqaxis[mdist_ind]
i = i + 1
# bwith_add = \
# np.append(np.append([bandwidth[0]] * (np.size(fk) // 2), bandwidth),
# [bandwidth[np.size(bandwidth) - 1]] * (np.size(fk) // 2))
# faster alternative
bwith_add = np.hstack(
([bwith[0]] * (np.size(fk) // 2), bwith,
[bwith[np.size(bwith) - 1]] * (np.size(fk) // 2)))
dbwith = signal.lfilter(fk, 1, bwith_add)
# dbwith = dbwith[np.size(fk) // 2:(np.size(dbwith) -
# np.size(fk) // 2)]
# correct start and end values of time derivative
dbwith = dbwith[np.size(fk) - 1:]
bwith = util.smooth(bwith, smoothie)
dbwith = util.smooth(dbwith, smoothie)
return bwith, dbwith
else:
minfc = abs(data - max(abs(data * (1 / np.sqrt(2)))))
[mdist_ind, _mindist] = min(enumerate(minfc), key=itemgetter(1))
bwith = freqaxis[mdist_ind]
return bwith
def dominant_period(data, fs, smoothie, fk):
"""
Predominant period of a signal.
Computes the predominant period of the given data which can be windowed or
not. The period is determined as the period of the maximum value of the
Fourier amplitude spectrum.
If data are windowed the predominant period of each window is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to determine predominant period of.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **dperiod[, ddperiod]** - Predominant period, Time derivative of
predominant period (windowed only).
"""
new_dtype = np.float32 if data.dtype.itemsize == 4 else np.float64
data = np.require(data, dtype=new_dtype)
nfft = 1024
# nfft = util.next_pow_2(data.shape[1])
freqaxis = np.linspace(0, fs, nfft + 1)
dperiod = np.zeros(data.shape[0])
f = fftpack.fft(data, nfft)
# f_sm = util.smooth(abs(f[:,0:nfft // 2]),1)
f_sm = f[:, 0:nfft // 2]
if np.size(data.shape) > 1:
i = 0
for row in f_sm:
[mdist_ind, _mindist] = max(enumerate(abs(row)), key=itemgetter(1))
dperiod[i] = freqaxis[mdist_ind]
i = i + 1
# dperiod_add = np.append(np.append([dperiod[0]] * \
# (np.size(fk) // 2), dperiod),
# [dperiod[np.size(dperiod) - 1]] * (np.size(fk) // 2))
# faster alternative
dperiod_add = np.hstack(
([dperiod[0]] * (np.size(fk) // 2), dperiod,
[dperiod[np.size(dperiod) - 1]] * (np.size(fk) // 2)))
ddperiod = signal.lfilter(fk, 1, dperiod_add)
# ddperiod = ddperiod[np.size(fk) / \
# 2:(np.size(ddperiod) - np.size(fk) // 2)]
# correct start and end values of time derivative
ddperiod = ddperiod[np.size(fk) - 1:]
dperiod = util.smooth(dperiod, smoothie)
ddperiod = util.smooth(ddperiod, smoothie)
return dperiod, ddperiod
else:
[mdist_ind, _mindist] = max(enumerate(abs(data)), key=itemgetter(1))
dperiod = freqaxis[mdist_ind]
return dperiod
def dominant_period(data, fs, smoothie, fk):
"""
Predominant period of a signal.
Computes the predominant period of the given data which can be windowed or
not. The period is determined as the period of the maximum value of the
Fourier amplitude spectrum.
If data are windowed the predominant period of each window is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to determine predominant period of.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **dperiod[, ddperiod]** - Predominant period, Time derivative of
predominant period (windowed only).
"""
new_dtype = np.float32 if data.dtype.itemsize == 4 else np.float64
data = np.require(data, dtype=new_dtype)
nfft = 1024
# nfft = util.next_pow_2(data.shape[1])
freqaxis = np.linspace(0, fs, nfft + 1)
dperiod = np.zeros(data.shape[0])
f = fftpack.fft(data, nfft)
# f_sm = util.smooth(abs(f[:,0:nfft // 2]),1)
f_sm = f[:, 0:nfft // 2]
if np.size(data.shape) > 1:
i = 0
for row in f_sm:
[mdist_ind, _mindist] = max(enumerate(abs(row)), key=itemgetter(1))
dperiod[i] = freqaxis[mdist_ind]
i = i + 1
# dperiod_add = np.append(np.append([dperiod[0]] * \
# (np.size(fk) // 2), dperiod),
# [dperiod[np.size(dperiod) - 1]] * (np.size(fk) // 2))
# faster alternative
dperiod_add = np.hstack(
([dperiod[0]] * (np.size(fk) // 2), dperiod,
[dperiod[np.size(dperiod) - 1]] * (np.size(fk) // 2)))
ddperiod = signal.lfilter(fk, 1, dperiod_add)
# ddperiod = ddperiod[np.size(fk) / \
# 2:(np.size(ddperiod) - np.size(fk) // 2)]
# correct start and end values of time derivative
ddperiod = ddperiod[np.size(fk) - 1:]
dperiod = util.smooth(dperiod, smoothie)
ddperiod = util.smooth(ddperiod, smoothie)
return dperiod, ddperiod
else:
[mdist_ind, _mindist] = max(enumerate(abs(data)), key=itemgetter(1))
dperiod = freqaxis[mdist_ind]
return dperiod
def cfrequency(data, fs, smoothie, fk):
nfft = nextpow2(data.shape[0])
freq = np.arange(0, float(fs) - 1. / (nextpow2(data.shape[0]) / float(fs)),
1. / (nextpow2(data.shape[0]) / float(fs)))
freqaxis = freq[0:len(freq) / 2 + 1]
cfreq = np.zeros(data.shape[0])
if (np.size(data.shape) > 1):
i = 0
for row in data:
Px_wm = welch(row, hamming(len(row)), nextpow2(len(row)))
Px = Px_wm[0:len(Px_wm) / 2]
cfreq[i] = np.sqrt(sum(pow(freqaxis, 2) * Px) / (sum(Px)))
i = i + 1
cfreq = smooth(cfreq, smoothie)
cfreq_add = append(append([cfreq[0]] * (size(fk) // 2), cfreq),
[cfreq[size(cfreq) - 1]] * (size(fk) // 2))
dcfreq = signal.lfilter(fk, 1, cfreq_add)
dcfreq = dcfreq[size(fk) // 2:(size(dcfreq) - size(fk) // 2)]
return cfreq, dcfreq
else:
Px_wm = welch(data, np.hamming(len(data)), nextpow2(len(data)))
Px = Px_wm[0:len(Px_wm) / 2]
cfreq = np.sqrt(np.sum(pow(freqaxis, 2) * Px) / (sum(Px)))
return cfreq
def whiteCalib(monitor_trace, response_trace, **kwargs):
m_trace=monitor_trace.copy()
r_trace=response_trace.copy()
#Calcul du spectre du signal moniteur et du spectre de la réponse de la bobine
mSpectre=np.fft.fft(m_trace.data)
rSpectre=np.fft.fft(r_trace.data)
#Fréquences associées
f1=np.fft.fftfreq(len(mSpectre), d=1./m_trace.stats.sampling_rate)
f2=np.fft.fftfreq(len(rSpectre), d=1./r_trace.stats.sampling_rate)
if len(f1)-len(f2) != 0 or np.sum(f1-f2)!=0:
print("Warning: frequencies arrays does'nt have same length or frequencies arrays not strictly identical, mixing")
fmax=np.minimum(np.amax(np.absolute(f1)), np.amax(np.absolute(f2)))
i1=np.where(np.absolute(f1)<fmax)
f1=f1[i1]
mSpectre=mSpectre[i1]
i2=np.where(np.absolute(f2)<fmax)
f2=f2[i2]
rSpectre=rSpectre[i2]
if len(f1)>len(f2):
i=np.argmax(f1)
f1=np.delete(f1, i)
mSpectre=np.delete(mSpectre, i)
i=np.argmin(f1)
f1=np.delete(f1, i)
mSpectre=np.delete(mSpectre, i)
elif len(f2)>len(f1):
i=np.argmax(f2)
f2=np.delete(f2, i)
rSpectre=np.delete(rSpectre, i)
i=np.argmin(f2)
f2=np.delete(f2, i)
rSpectre=np.delete(rSpectre, i)
#Division spectrale brute (calcul de la fonction de transfert)
H=rSpectre/mSpectre
if 'smooth' in kwargs:
H=smooth(H, kwargs['smooth'])
else:
H=smooth(H, int(len(f1)*0.0001))
return (H,f1)
def TemporalNormalization(trace):
if normalization_method == 1:
trace.data = np.sign(trace.data)
if normalization_method == 2:
winsize = period_max / 2.0 * trace.stats.sampling_rate
tmp = util.smooth(abs(trace.data), round(winsize))
trace.data = trace.data / tmp
return trace
def env_norm(stream, N):
stream2 = copy.deepcopy(stream)
for trace in arange(len(stream2)):
data = stream2[trace].data
norm = util.smooth(absolute(data), N)
#normdata = cpxtrace.normEnvelope(data, fs=stream2[trace].stats.sampling_rate, smoothie=N, fk=[1, 1, 1, 1, 1] )
normdata = true_divide(data, norm)
stream2[trace].data = normdata
return stream2
def env_norm(stream, N):
stream2 = copy.deepcopy(stream)
for trace in arange(len(stream2)):
data = stream2[trace].data
norm = util.smooth(absolute(data), N)
#normdata = cpxtrace.normEnvelope(data, fs=stream2[trace].stats.sampling_rate, smoothie=N, fk=[1, 1, 1, 1, 1] )
normdata = true_divide(data,norm)
stream2[trace].data = normdata
return stream2
def _get_cut_times(config, tr):
"""Get trace cut times between P arrival and end of envelope coda."""
tr_env = tr.copy()
# remove the mean...
tr_env.detrend(type='constant')
# ...and the linear trend...
tr_env.detrend(type='linear')
# ...filter
freqmin = 1.
freqmax = 20.
nyquist = 1./(2. * tr.stats.delta)
if freqmax >= nyquist:
freqmax = nyquist * 0.999
msg = '%s: maximum frequency for bandpass filtering ' % tr.id
msg += 'in local magnitude computation is larger than or equal '
msg += 'to Nyquist. Setting it to %s Hz' % freqmax
logger.warning(msg)
cosine_taper(tr_env.data, width=config.taper_halfwidth)
tr_env.filter(type='bandpass', freqmin=freqmin, freqmax=freqmax)
tr_env.data = envelope(tr_env.data)
tr_env.data = smooth(tr_env.data, 100)
# Skip traces which do not have arrivals
try:
p_arrival_time = tr.stats.arrivals['P'][1]
except Exception:
logger.warning('%s: Trace has no P arrival: skipping trace' % tr.id)
raise RuntimeError
t1 = p_arrival_time - config.win_length
t2 = p_arrival_time + config.win_length
tr_noise = tr_env.copy()
tr_signal = tr_env.copy()
tr_noise.trim(starttime=t1, endtime=p_arrival_time,
pad=True, fill_value=0)
tr_signal.trim(starttime=p_arrival_time, endtime=t2,
pad=True, fill_value=0)
ampmin = tr_noise.data.mean()
ampmax = tr_signal.data.mean()
if ampmax <= ampmin:
logger.warning(
'%s: Trace has too high noise before P arrival: '
'skipping trace' % tr.id)
raise RuntimeError
trigger = trigger_onset(tr_env.data, ampmax, ampmin,
max_len=9e99, max_len_delete=False)[0]
t0 = p_arrival_time
t1 = t0 + trigger[-1] * tr.stats.delta
if t1 > tr.stats.endtime:
t1 = tr.stats.endtime
return t0, t1
def start_end(tr):
"""
Returns start and end times of signal using signal 2 noise ratio
"""
# set noise level as 5th percentile on envelope amplitudes
env = envelope(tr.data)
env = smooth(env, 100)
noise_level = np.percentile(env, 5.0)
# trigger
t_list = triggerOnset(env, 1.5 * noise_level, 1.5 * noise_level)
i_start = t_list[0][0]
i_end = t_list[0][1]
return i_start, i_end
def central_frequency(data, fs, smoothie, fk):
"""
Central frequency of a signal.
Computes the central frequency of the given data which can be windowed or
not. The central frequency is a measure of the frequency where the
power is concentrated. It corresponds to the second moment of the power
spectral density function.
The central frequency is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to estimate central frequency from.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **cfreq[, dcfreq]** - Central frequency, Time derivative of center
frequency (windowed only).
"""
# for windowed data
if np.size(data.shape) > 1:
cfreq = np.zeros(data.shape[0])
i = 0
for row in data:
cfreq[i] = central_frequency_unwindowed(row, fs)
i = i + 1
cfreq = util.smooth(cfreq, smoothie)
# cfreq_add = \
# np.append(np.append([cfreq[0]] * (np.size(fk) // 2), cfreq),
# [cfreq[np.size(cfreq) - 1]] * (np.size(fk) // 2))
# faster alternative
cfreq_add = np.hstack(
([cfreq[0]] * (np.size(fk) // 2), cfreq,
[cfreq[np.size(cfreq) - 1]] * (np.size(fk) // 2)))
dcfreq = signal.lfilter(fk, 1, cfreq_add)
# dcfreq = dcfreq[np.size(fk) // 2:(np.size(dcfreq) -
# np.size(fk) // 2)]
# correct start and end values of time derivative
dcfreq = dcfreq[np.size(fk) - 1:np.size(dcfreq)]
return cfreq, dcfreq
# for unwindowed data
else:
cfreq = central_frequency_unwindowed(data, fs)
return cfreq
def cfrequency(data, fs, smoothie, fk):
"""
Central frequency of a signal.
Computes the central frequency of the given data which can be windowed or
not. The central frequency is a measure of the frequency where the
power is concentrated. It corresponds to the second moment of the power
spectral density function.
The central frequency is returned.
:type data: :class:`~numpy.ndarray`
:param data: Data to estimate central frequency from.
:param fs: Sampling frequency in Hz.
:param smoothie: Factor for smoothing the result.
:param fk: Coefficients for calculating time derivatives
(calculated via central difference).
:return: **cfreq[, dcfreq]** - Central frequency, Time derivative of center
frequency (windowed only).
"""
# for windowed data
if np.size(data.shape) > 1:
cfreq = np.zeros(data.shape[0])
i = 0
for row in data:
cfreq[i] = cfrequency_unwindowed(row, fs)
i = i + 1
cfreq = util.smooth(cfreq, smoothie)
# cfreq_add = \
# np.append(np.append([cfreq[0]] * (np.size(fk) // 2), cfreq),
# [cfreq[np.size(cfreq) - 1]] * (np.size(fk) // 2))
# faster alternative
cfreq_add = np.hstack(
([cfreq[0]] * (np.size(fk) // 2), cfreq, [cfreq[np.size(cfreq) - 1]] * (np.size(fk) // 2))
)
dcfreq = signal.lfilter(fk, 1, cfreq_add)
# dcfreq = dcfreq[np.size(fk) // 2:(np.size(dcfreq) -
# np.size(fk) // 2)]
# correct start and end values of time derivative
dcfreq = dcfreq[np.size(fk) - 1 : np.size(dcfreq)]
return cfreq, dcfreq
# for unwindowed data
else:
cfreq = cfrequency_unwindowed(data, fs)
return cfreq
def duration_exceed_RMS(x, ampthresh, RMSlen, dt):
"""
Noise level metric that calcualtes the total duration of the RMS
function above a theshold (ampthresh).
RMSlen = window length used to calculate RMS (sec)
x: np array or list of numbers
st = an ObsPy stream
dt = timeseries increment (sec)
"""
from obspy.signal.util import smooth
duration = 0
if (len(x) > int(RMSlen / dt)):
iRMSwinlen = int(RMSlen / dt)
RMS = np.sqrt(smooth((x**2), iRMSwinlen))
duration = ((RMS > ampthresh).sum()) * dt
else:
duration = []
duration = -1
print("Error duration_exceed_RMS: len(x)=" + str(len(x) * dt) +
" must be greater than RMSlen=" + str(RMSlen))
return duration
+ frq_bnd + 'Hz_' + cpnt + '_smooth')
# create the directory path_rslt in case it does not exist
if not os.path.isdir(path_rslt):
try:
os.makedirs(path_rslt)
except OSError:
print('Creation of the directory {} failed'.format(path_rslt))
else:
print('Successfully created the directory {}'.format(path_rslt))
else:
print('{} is already existing'.format(path_rslt))
# pick the envelopes from the directory path_data
lst_fch = os.listdir(path_data)
print('Smoothing of the envelopes')
for s in lst_fch:
os.chdir(path_data)
# load the envelope
st = read(s)
# smooth the envelope
tr = smooth(st[0].data, int(l_smooth/st[0].stats.delta))
# preparation for SAC format
tr = Trace(tr, st[0].stats)
# save the file
os.chdir(path_rslt)
tr.write(s[:-4] + '_smooth.sac', format = 'SAC')
print('The envelope of the station {}'.format(s[:6]),
'has been successfully smoothed')
list_fich = [
a for a in list_fich if ('UD' in a) == True and ('UD1' in a) == False
]
for station in list_fich:
print(station)
os.chdir(path_data)
st = read(station)
st.detrend(type='constant')
tstart = st[0].stats.starttime + st[0].stats.sac.a - 5
tend = tstart + 50
tr = st[0].trim(tstart, tend, pad=True, fill_value=0)
st[0].stats.sac.nzyear = st[0].stats.starttime.year
st[0].stats.sac.nzjday = st[0].stats.starttime.julday
st[0].stats.sac.nzhour = st[0].stats.starttime.hour
st[0].stats.sac.nzmin = st[0].stats.starttime.minute
st[0].stats.sac.nzsec = st[0].stats.starttime.second
st[0].stats.sac.nzmsec = st[0].stats.starttime.microsecond
st[0].stats.sac.t0 = st[0].stats.sac.t0 - st[0].stats.sac.a + 5
st[0].stats.sac.a = 5
tr = tr.filter('bandpass',
freqmin=0.2,
freqmax=10,
corners=4,
zerophase=True)
tr = [a**2 for a in tr]
tr = np.asarray(smooth(tr, 20))
tr = Trace(tr, st[0].stats)
os.chdir(path_env)
tr.write('env_' + station, format='SAC')
def make_station_figure_eew_stationreport(st1, st2, st3, st4, st5, label1,
label2, label3, label4, label5,
thresh1, thresh2, thresh3, thresh4,
thresh5, RMSwinlen):
net = st1[0].stats.network
stat = st1[0].stats.station
loc = st1[0].stats.location
chan = st1[0].stats.channel
fig = plt.figure(figsize=(8, 8), dpi=180)
gs1 = gridspec.GridSpec(1, 1)
gs1.update(left=0.15, right=0.92, bottom=0.81, top=0.94, wspace=0.01)
ax1 = plt.subplot(gs1[:, :])
gs2 = gridspec.GridSpec(1, 1)
gs2.update(left=0.15, right=0.92, bottom=0.62, top=0.78, wspace=0.01)
ax2 = plt.subplot(gs2[:, :])
gs3 = gridspec.GridSpec(1, 1)
gs3.update(left=0.15, right=0.92, bottom=0.43, top=0.59, wspace=0.01)
ax3 = plt.subplot(gs3[:, :])
gs4 = gridspec.GridSpec(1, 1)
gs4.update(left=0.15, right=0.92, bottom=0.24, top=0.40, wspace=0.01)
ax4 = plt.subplot(gs4[:, :])
gs5 = gridspec.GridSpec(1, 1)
gs5.update(left=0.15, right=0.92, bottom=0.08, top=0.21, wspace=0.01)
ax5 = plt.subplot(gs5[:, :])
tlast = st1[len(st1) - 1].stats.endtime
timediffinsec = (tlast - st1[0].stats.starttime)
tadd = timediffinsec * 0.01
t1 = st1[0].stats.starttime - datetime.timedelta(seconds=tadd)
t2 = tlast + datetime.timedelta(seconds=tadd)
t = t1
t1 = datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second,
t.microsecond)
t = t2
t2 = datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second,
t.microsecond)
for ii in range(0, len(st1)):
timearray = np.arange(st1[ii].stats.npts) * st1[ii].stats.delta
t = st1[ii].stats.starttime
x1 = np.array([
datetime.datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second, t.microsecond) +
datetime.timedelta(seconds=jj) for jj in timearray
])
ax1.plot(x1, st1[ii].data, color='k', linewidth=0.2)
if (thresh1 > 0):
ax1.plot([t1, t2], [thresh1, thresh1], color='r', linewidth=0.5)
ax1.plot([t1, t2], [-1 * thresh1, -1 * thresh1],
color='r',
linewidth=0.5)
ax1.xaxis.set_major_formatter(DateFormatter('%H:%M'))
tlast = st1[ii].stats.endtime
for ii in range(0, len(st2)):
timearray = np.arange(st2[ii].stats.npts) * st2[ii].stats.delta
t = st2[ii].stats.starttime
x2 = np.array([
datetime.datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second, t.microsecond) +
datetime.timedelta(seconds=jj) for jj in timearray
])
ax2.plot(x2, st2[ii].data, color='k', linewidth=0.2)
if (thresh2 > 0):
ax2.plot([t1, t2], [thresh2, thresh2], color='r', linewidth=0.5)
ax2.plot([t1, t2], [-1 * thresh2, -1 * thresh2],
color='r',
linewidth=0.5)
ax2.xaxis.set_major_formatter(DateFormatter('%H:%M'))
for ii in range(0, len(st3)):
timearray = np.arange(st3[ii].stats.npts) * st3[ii].stats.delta
t = st3[ii].stats.starttime
x3 = np.array([
datetime.datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second, t.microsecond) +
datetime.timedelta(seconds=jj) for jj in timearray
])
iRMSwinlen = int(RMSwinlen / st3[ii].stats.delta)
if (st3[ii].stats.npts > iRMSwinlen):
rmsthing = np.sqrt(smooth(((st3[ii].data)**2), iRMSwinlen))
ax3.plot(x3, st3[ii].data, color='k', linewidth=0.2)
ax3.plot(x3, rmsthing, color='c', linewidth=1)
if (thresh3 > 0):
ax3.plot([t1, t2], [thresh3, thresh3], color='r', linewidth=0.5)
ax3.xaxis.set_major_formatter(DateFormatter('%H:%M'))
for ii in range(0, len(st4)):
timearray = np.arange(st4[ii].stats.npts) * st4[ii].stats.delta
t = st4[ii].stats.starttime
x4 = np.array([
datetime.datetime(t.year, t.month, t.day, t.hour, t.minute,
t.second, t.microsecond) +
datetime.timedelta(seconds=jj) for jj in timearray
])
ax4.plot(x4, st4[ii].data, color='k', linewidth=0.2)
if (thresh4 > 0):
ax4.plot([t1, t2], [thresh4, thresh4], color='r', linewidth=0.5)
ax4.plot([t1, t2], [-1 * thresh4, -1 * thresh4],
color='r',
linewidth=0.5)
ax4.xaxis.set_major_formatter(DateFormatter('%H:%M'))
timearray = np.arange(len(st5)) * st1[0].stats.delta
t = st1[ii].stats.starttime
x5 = np.array([
datetime.datetime(t.year, t.month, t.day, t.hour, t.minute, t.second,
t.microsecond) + datetime.timedelta(seconds=jj)
for jj in timearray
])
if (thresh5 > 0):
ax5.plot([t1, t2], [thresh5, thresh5], color='r', linewidth=0.5)
ax5.plot(x5, st5, color='k', linewidth=0.2)
ax5.xaxis.set_major_formatter(DateFormatter('%H:%M'))
ax5.set_ylim(-1, 29)
ttextL = t1 - datetime.timedelta(seconds=timediffinsec * 0.18)
ttextR = t1 + datetime.timedelta(seconds=timediffinsec * 1.025)
ttextR2 = t1 + datetime.timedelta(seconds=timediffinsec * 1.055)
ttitle = t1 + datetime.timedelta(seconds=timediffinsec * 0.15)
titletext = str(ttitle.year) + '/' + str(ttitle.month) + '/' + str(
ttitle.day
) + ' (UTC) ' + net + '.' + stat + '.' + loc + '.' + chan
ytitle = ax1.get_ylim()[0] + (ax1.get_ylim()[1] - ax1.get_ylim()[0]) * 1.04
ax1.text(ttitle, ytitle, titletext)
ax1.set_xlim([t1, t2])
ax2.set_xlim([t1, t2])
ax3.set_xlim([t1, t2])
ax4.set_xlim([t1, t2])
ax5.set_xlim([t1, t2])
ax1.set_xticklabels([])
ax2.set_xticklabels([])
ax3.set_xticklabels([])
ax4.set_xticklabels([])
if (thresh1 > 0 and ax1.get_ylim()[1] < thresh1):
ax1.set_ylim([-1.05 * thresh1, 1.05 * thresh1])
if (thresh2 > 0 and ax2.get_ylim()[1] < thresh2):
ax2.set_ylim([-1.05 * thresh2, 1.05 * thresh2])
if (thresh3 > 0 and ax3.get_ylim()[1] < thresh3):
ax3.set_ylim([-1.05 * thresh3, 1.05 * thresh3])
if (thresh4 > 0 and ax4.get_ylim()[1] < thresh4):
ax4.set_ylim([-1.05 * thresh4, 1.05 * thresh4])
if (thresh5 > 0 and ax5.get_ylim()[1] < thresh5):
ax5.set_ylim([-1.05 * thresh5, 1.05 * thresh5])
ytext1 = ax1.get_ylim()[0] + (ax1.get_ylim()[1] - ax1.get_ylim()[0]) * 0.85
ytext2 = ax2.get_ylim()[0] + (ax2.get_ylim()[1] - ax2.get_ylim()[0]) * 0.85
ytext3 = ax3.get_ylim()[0] + (ax3.get_ylim()[1] - ax3.get_ylim()[0]) * 0.85
ytext4 = ax4.get_ylim()[0] + (ax4.get_ylim()[1] - ax4.get_ylim()[0]) * 0.85
ytext5 = ax5.get_ylim()[0] + (ax5.get_ylim()[1] - ax5.get_ylim()[0]) * 0.85
ttextLsat = t1 - datetime.timedelta(seconds=timediffinsec * 0.05)
if (len(label1) < 18):
ax1.text(ttextR, ytext1, label1, color='k', rotation=270)
else:
ax1.text(ttextR2, ytext1, label1.split()[0], color='k', rotation=270)
ax1.text(ttextR,
ytext1,
" ".join(label1.split()[1:]),
color='k',
rotation=270)
if (len(label2) < 18):
ax1.text(ttextR, ytext2, label2, color='k', rotation=270)
else:
ax2.text(ttextR2, ytext2, label2.split()[0], color='k', rotation=270)
ax2.text(ttextR,
ytext2,
" ".join(label2.split()[1:]),
color='k',
rotation=270)
if (len(label3) < 18):
ax3.text(ttextR, ytext3, label3, color='k', rotation=270)
else:
ax3.text(ttextR2, ytext3, label3.split()[0], color='k', rotation=270)
ax3.text(ttextR,
ytext3,
" ".join(label3.split()[1:]),
color='k',
rotation=270)
if (len(label4) < 18):
ax4.text(ttextR, ytext4, label4, color='k', rotation=270)
else:
ax4.text(ttextR2, ytext4, label4.split()[0], color='k', rotation=270)
ax4.text(ttextR,
ytext4,
" ".join(label4.split()[1:]),
color='k',
rotation=270)
if (len(label5) < 18):
ax5.text(ttextR, ytext5, label5, color='k', rotation=270)
ax5.text(ttextLsat, 28, ">30", color='k')
else:
ax5.text(ttextR2, ytext5, label5.split()[0], color='k', rotation=270)
ax5.text(ttextR,
ytext5,
" ".join(label5.split()[1:]),
color='k',
rotation=270)
ax5.text(ttextLsat, 28, ">30", color='k')
locname = loc
if (loc == "--"):
locname = ""
figname = 'WAVEFORMS.' + str(ttitle.year) + '.' + str(
ttitle.month) + '.' + str(ttitle.day) + '.' + str(
ttitle.hour
) + '.' + net + '.' + stat + '.' + locname + '.' + chan + '.png'
plt.savefig(figname, dpi=180)
plt.close("all")
ax_env_all.set_xlabel('time (s)')
cpt = 0
for fichier in list_file_used:
os.chdir(path_data)
st = read(fichier)
st = st.detrend(type='constant') #retirer la moyenne
tr_brut = st[0]
tr_filt = tr_brut.filter('bandpass',
freqmin=0.2,
freqmax=10,
corners=4,
zerophase=True)
envelop = abs(hilbert(tr_filt))
env_smoothed = smooth(envelop, 20)
t = np.arange(tr_brut.stats.npts) / tr_brut.stats.sampling_rate
os.chdir(path_env)
fig_env, ax_env = plt.subplots(1, 1)
ax_env.set_xlabel('time (s)')
ax_env.plot(t, tr_brut, linewidth=0.2, color='black')
ax_env.plot(t, env_smoothed, linewidth=1, color='red')
fig_env.savefig('envelope_' + str(st[0].stats.station) + '.pdf')
ax_env_all.plot(t, env_smoothed + cpt, linewidth=0.5)
cpt = cpt + 2000
plt.grid()
if (flagSave==1):
fig.savefig('cumul.png')
plt.show()
fig=plt.figure()
plt.plot(tempo[:-1],enend)
ax=plt.gca()
plt.xlabel("time [s]")
plt.ylabel("first derivative of cumulative")
plt.grid()
if (flagSave==1):
plt.savefig("derivCumuOrig.png")
plt.show()
pr=smooth(enend,100)
plt.plot(pr[5000:10000])
plt.show()
yhat = savitzky_golay(pr, 801, 3)
plt.plot(yhat[5000:15000])
plt.show()
# CREATE MAXIMA AND MINIMA:
maxima_num=0
minima_num=0
max_locations=[]
f"{ct+1}/{len(pred_list)}: {idx[k].numpy().decode('utf-8')}")
trc_id_decode = idx[k].numpy().decode('utf-8').split('.')
evid = trc_id_decode[0]
chn = trc_id_decode[1]
sta_info = '.'.join(trc_id_decode[2:])
# predictions information
pred_pick_T = pred_pick[k].T
predict_P = pred_pick_T[0]
predict_S = pred_pick_T[1]
predict_nz = pred_pick_T[2]
pred_mask_T = pred_mask[k].T
pred_eq_mask = pred_mask_T[0]
pred_nz_mask = pred_mask_T[1]
trigger_mask = trigger_onset(smooth(pred_eq_mask, 10), 0.3, 0.3)
# labeled P&S arrival time
label_info = label[k].numpy()
try:
labeled_P = np.where(label_info.T[0] == 1)[0][0] * dt
labeled_S = np.where(label_info.T[1] == 1)[0][0] * dt
raw_tp_ts_diff = labeled_S - labeled_P
p_peak, p_value = pick_peaks(predict_P,
labeled_P,
dt,
search_win=1)
s_peak, s_value = pick_peaks(predict_S,
labeled_S,
dt,
search_win=1)
ax_env_norm[1].set_ylabel('Normalized squared amplitude')
ax_env_norm[0].ticklabel_format(style = 'sci', axis = 'y', scilimits = (0, 0))
ax_env_norm[1].ticklabel_format(style = 'sci', axis = 'y', scilimits = (0, 0))
ax_env_norm[2].ticklabel_format(style = 'sci', axis = 'y', scilimits = (0, 0))
os.chdir(path_data)
for station in list_sta:
st = read(station)
st.detrend(type = 'constant')
tstart = st[0].stats.starttime + st[0].stats.sac.t0 - 15
tend = tstart + 50
st[0].trim(tstart, tend, pad=True, fill_value=0)
tr_brut = st[0]
tr_filt = tr_brut.filter('bandpass', freqmin=0.2, freqmax=10, corners=4, zerophase=True)
squared_tr = [a**2 for a in tr_filt]
env_smoothed = norm1(smooth(squared_tr, 20))
t = np.arange(tr_brut.stats.npts)/tr_brut.stats.sampling_rate
#traces brute, filtree, au carre, smoothee
ista = list_sta.index(station)
ax_brute[ista].plot(t, tr_brut)#, aspect = 50)#, aspect = 50/(abs(1.1*tr_brut.max()) + abs(1.1*tr_brut.max())))
ax_filtree[ista].plot(t, tr_filt)#, aspect = 50)#, aspect = 50/(abs(1.1*tr_filt.max()) + abs(1.1*tr_filt.max())))
ax_filt_sqr[ista].plot(t, squared_tr)#, aspect = 50)#, aspect = 50/(abs(1.1*squared_tr.max()) + abs(1.1*squared_tr.max())))
ax_env_norm[ista].plot(t, env_smoothed)#, aspect = 50)#, aspect = 50/(abs(1.1*env_smoothed.max()) + abs(1.1*env_smoothed.max())))
if st[0].stats.channel == 'EW':
ax_brute[ista].text(45, abs(tr_brut.max())/2, 'EW')
ax_filtree[ista].text(45, abs(tr_filt.max())/2, 'EW')
ax_filt_sqr[ista].text(45, max(squared_tr)/2, 'EW')
ax_env_norm[ista].text(45, max(env_smoothed)/2, 'EW')
elif st[0].stats.channel == 'NS':
def spectrum_gen(ts_in,
pick,
args,
mt_tb=4,
debug=0,
return_timeseries=False,
usedecon=False,
ts_in2=None,
pick2=None,
npick=None,
npick2=None,
npickp=None,
npickp2=None):
"""
returns the spectrum of a timeseries
INPUT
ts_in timeseries as an obspy trace
pick pick as time
station string
args see
"""
from mtspec import mtspec, mt_deconvolve
timeseries = ts_in.copy()
if usedecon:
timeseries2 = ts_in2.copy()
#arguments
#fftype=args.ft
winlength = args.W
shift = args.S
stype = args.P
nwins = args.N
snrtype = args.snrtype
nlogbins = args.lb
smoothfactor = 3
flims = [-2, 1.2]
specs = []
ffreq = []
if usedecon:
msnrs = []
esnrs = []
mspecs = []
especs = []
decons = []
esnrps = []
msnrps = []
noisewin = timeseries.copy()
noisewin.trim(npick, npick + winlength)
noisewin2 = timeseries2.copy()
noisewin2.trim(npick2, npick2 + winlength)
noisewinpcoda = timeseries.copy()
noisewinpcoda.trim(npickp, npickp + winlength)
noisewinpcoda2 = timeseries2.copy()
noisewinpcoda2.trim(npickp2, npickp2 + winlength)
lenwin = 0
for i in range(1, nwins + 1):
clipwin = timeseries.copy()
clipstart = pick + (i - 1) * shift
clipend = clipstart + winlength
if clipwin.stats.endtime - clipend < 0:
if debug > 1:
print('at the end of the data')
continue
if clipstart - clipwin.stats.starttime < 0:
if debug > 1:
print('starting before the data')
continue
clipwin.trim(clipstart, clipend)
lenwin = len(clipwin.data)
if lenwin <= 256:
nopts = 256
elif lenwin <= 512:
nopts = 512
elif lenwin < 1024:
nopts = 1024
else:
nopts = 2048
if not usedecon:
spec, freq, jackknife, _, _ = mtspec(data=clipwin.data,
delta=clipwin.stats.delta,
time_bandwidth=mt_tb,
nfft=nopts,
statistics=True)
specs.append(np.sqrt(spec))
ffreq = freq
else:
clipwin2 = timeseries2.copy()
clipstart2 = pick2 + (i - 1) * shift
clipend2 = clipstart2 + winlength
if clipwin2.stats.endtime - clipend2 < 0:
if debug > 1:
print('at the end of the data')
continue
if clipstart2 - clipwin2.stats.starttime < 0:
if debug > 1:
print('starting before the data')
continue
clipwin2.trim(clipstart2, clipend2)
freq, spec, spec1, spec2, decon = specrat_gen(
clipwin, clipwin2, nopts, mt_tb)
freqnL, msnr, _, _, denoiseL = specrat_gen(clipwin, noisewin,
nopts, mt_tb)
freqnS, esnr, _, _, denoiseS = specrat_gen(clipwin2, noisewin2,
nopts, mt_tb)
freqnpL, msnrp, _, _, denoisepL = specrat_gen(
clipwin, noisewinpcoda, nopts, mt_tb)
freqnpS, esnrp, _, _, denoisepS = specrat_gen(
clipwin2, noisewinpcoda2, nopts, mt_tb)
# specs.append([spec,spec1,spec2,msnr,esnr,msnrp,esnrp])
msnrs.append(msnr)
esnrs.append(esnr)
specs.append(spec)
mspecs.append(spec1)
especs.append(spec2)
decons.append(decon)
msnrps.append(msnrp)
esnrps.append(esnrp)
ffreq = freq
specs = np.average(specs, axis=0)
if usedecon:
msnrs = np.average(msnrs, axis=0)
esnrs = np.average(esnrs, axis=0)
mspecs = np.average(mspecs, axis=0)
especs = np.average(especs, axis=0)
decons = np.average(decons, axis=0)
msnrps = np.average(msnrps, axis=0)
esnrps = np.average(esnrps, axis=0)
#smooth the individual spectra before taking spectral ratio.
if len(ffreq) == 0:
print('the spectrum has length 0')
return
ffreq1, specs = logbin(ffreq, specs, nbins=nlogbins, flims=flims)
if usedecon:
ffreq1, msnrs = logbin(ffreq, msnrs, nbins=nlogbins, flims=flims)
ffreq1, esnrs = logbin(ffreq, esnrs, nbins=nlogbins, flims=flims)
ffreq1, mspecs = logbin(ffreq, mspecs, nbins=nlogbins, flims=flims)
ffreq1, especs = logbin(ffreq, especs, nbins=nlogbins, flims=flims)
ffreq1, msnrps = logbin(ffreq, msnrps, nbins=nlogbins, flims=flims)
ffreq1, esnrps = logbin(ffreq, esnrps, nbins=nlogbins, flims=flims)
if args.sm:
specs = smooth(specs, smoothfactor)
if usedecon:
msnrs = smooth(msnrs, smoothfactor)
esnrs = smooth(esnrs, smoothfactor)
mspecs = smooth(mspecs, smoothfactor)
especs = smooth(especs, smoothfactor)
msnrps = smooth(msnrps, smoothfactor)
esnrps = smooth(esnrps, smoothfactor)
return ffreq1, specs, mspecs, especs, decons, msnrs, esnrs, msnrps, esnrps
else:
return ffreq1, specs
#trN.plot()
#==================================================================================================================
#========= #Calculando la transformada de fourier ==============================================================
#==================================================================================================================
#spectrum=mper(trN.data,200,np.size(trN.data))
n=np.size(trN.data)
#dt=0.01
t=np.linspace(0,n-1,n)*dt
df=1/(n*dt)
freq=np.linspace(0,(n+1)/2,(n+1)/2)*df
specN=np.fft.rfft(trN.data)
specE=np.fft.rfft(trE.data)
Hspec=np.sqrt((specN**2+specE**2)/2)
smooth_Hspec=smooth(Hspec,smth)
<<<<<<< HEAD
'''
=======
<<<<<<< HEAD
=======
'''
>>>>>>> d2ecf1f1dcdc0faedb0ee9378140a19249a90d73
>>>>>>> casa
#Graficando log-espectro
plt.plot(np.log10(freq),np.log10(abs(smooth_Hspec)),'k')
plt.title('Espectro de desplazamiento onda S '+trN.stats.station)
plt.xlim(0,2)
plt.ylabel('log(A)')
plt.xlabel('log(frecuencia [Hz])')
for fichier in list_fichier:
st = read(fichier)
st = st.detrend(type='constant')
tstart = st[0].stats.starttime + st[0].stats.sac.t0 - 15
tend = tstart + 50
st[0].trim(tstart, tend, pad=True, fill_value=0)
tr_brut = st[0]
tr_filt = tr_brut.filter('bandpass',
freqmin=0.2,
freqmax=10,
corners=4,
zerophase=True)
#envelop = abs(hilbert(tr_filt))
#env_smoothed = smooth(envelop, 20)
squared_tr = [a**2 for a in tr_filt]
env_smoothed = smooth(squared_tr, 20)
t = np.arange(tr_brut.stats.npts) / tr_brut.stats.sampling_rate
ordo = dist(st[0].stats.sac.stla, st[0].stats.sac.stlo,
0.001 * st[0].stats.sac.stel, st[0].stats.sac.evla,
st[0].stats.sac.evlo, -st[0].stats.sac.evdp)
ax.plot(t, norm(env_smoothed) + ordo, linewidth=0.2)
ax.text(40, ordo, st[0].stats.station, fontsize=3)
ax2.plot(t, norm(env_smoothed) + ordo, linewidth=0.2)
ax2.text(40, ordo, st[0].stats.station, fontsize=3)
os.chdir(path_results)
ax2.axvline(15)
