def process(self, stream):
"""Run algorithm for a stream.
Processes all traces in the stream.
Parameters
----------
stream : obspy.core.Stream
stream of data to process
Returns
-------
out : obspy.core.Stream
stream containing 1 trace per original trace.
"""
out = Stream()
for trace in stream:
data = trace.data
step = self.decimation
filtered = self.firfilter(data, self.window, step)
stats = Stats(trace.stats)
# stats.channel = trace_chan_dict2[stats.channel]
stats.starttime = trace.stats.starttime + \
self.numtaps * self.sample_period // 2
stats.delta = stats.delta * step
# stats.processing.append('[Gaussian Filter]')
stats.npts = filtered.shape[0]
trace_out = self.create_trace(stats.channel, stats, filtered)
out += trace_out
return out
def ascii(path, filename):
"""
Reads SPECFEM3D-style ASCII data
:type path: str
:param path: path to datasets
:type filenames: list
:param filenames: files to read
"""
st = Stream()
stats = Stats()
time, data = loadtxt(os.path.join(path, filename)).T
stats.filename = filename
stats.starttime = time[0]
stats.delta = time[1] - time[0]
stats.npts = len(data)
try:
parts = filename.split(".")
stats.network = parts[0]
stats.station = parts[1]
stats.channel = parts[2]
except:
pass
st.append(Trace(data=data, header=stats))
return st
def __create_trace(
data,
network="NT",
station="BOU",
channel="H",
location="R0",
data_interval="second",
data_type="interval",
):
"""
Utility to create a trace containing the given numpy array.
Parameters
----------
data: array
The array to be inserted into the trace.
Returns
-------
obspy.core.Stream
Stream containing the channel.
"""
stats = Stats()
stats.starttime = UTCDateTime("2019-12-01")
stats.delta = TimeseriesUtility.get_delta_from_interval(data_interval)
stats.channel = channel
stats.station = station
stats.npts = len(data)
stats.data_interval = data_interval
stats.data_type = data_type
numpy_data = numpy.array(data, dtype=numpy.float64)
return Trace(numpy_data, stats)
def read_ascii(path, NR, nt):
from numpy import loadtxt
from obspy.core import Stream, Stats, Trace
dat_type = 'semd'
comp1 = 'FXX'
comp2 = 'FXY'
stream = Stream()
for rec_x in range(0,NR):
file_name_in1 = path + 'P.R' + str(int(rec_x+1)) + '.' + comp1 + '.' + dat_type
file_name_in2 = path + 'P.R' + str(int(rec_x+1)) + '.' + comp2 + '.' + dat_type
xz1 = np.genfromtxt(file_name_in1)
xz2 = np.genfromtxt(file_name_in2)
deg = 0.0
alpha = np.arctan(xz2[:nt,1]/(1.0e-40 + xz1[:nt,1])) # angle of projection
direction = np.sign(np.cos(deg*np.pi/180.0)*xz1[:nt,1]*np.cos(alpha) + np.sin(deg*np.pi/180.0)*xz2[:nt,1]*np.cos(alpha))
data = direction*np.sqrt(xz1[:nt,1]**2 + xz2[:nt,1]**2)*np.cos(alpha) # scalar radial component
stats = Stats()
stats.filename = path + 'P.R' + str(int(rec_x+1))
stats.starttime = xz1[0,0]
stats.delta = xz1[1,0] - xz1[0,0]
stats.npts = len(xz1[:nt,0])
try:
parts = filename.split('.')
stats.network = parts[0]
stats.station = parts[1]
stats.channel = temp[2]
except:
pass
stream.append(Trace(data=data[:], header=stats))
return stream
def process_step(self, step, stream):
"""Filters stream for one step.
Filters all traces in stream.
Parameters
----------
step : array element
step holding variables for one filtering operation
stream : obspy.core.Stream
stream of data to filter
Returns
-------
out : obspy.core.Stream
stream containing 1 trace per original trace.
"""
# gather variables from step
input_sample_period = step["input_sample_period"]
output_sample_period = step["output_sample_period"]
window = np.array(step["window"])
decimation = int(output_sample_period / input_sample_period)
numtaps = len(window)
window = window / sum(window)
out = Stream()
for trace in stream:
filtered = self.firfilter(trace.data, window, decimation)
stats = Stats(trace.stats)
stats.starttime = stats.starttime + input_sample_period * (numtaps // 2)
stats.delta = output_sample_period
stats.npts = len(filtered)
trace_out = self.create_trace(stats.channel, stats, filtered)
out += trace_out
return out
def _create_trace(data, channel, starttime, delta=60.):
stats = Stats()
stats.channel = channel
stats.delta = delta
stats.starttime = starttime
stats.npts = len(data)
data = numpy.array(data, dtype=numpy.float64)
return Trace(data, stats)
def _create_trace(data, channel, starttime, delta=60.0):
stats = Stats()
stats.channel = channel
stats.delta = delta
stats.starttime = starttime
stats.npts = len(data)
data = numpy.array(data, dtype=numpy.float64)
return Trace(data, stats)
def process_step(self, step, stream):
"""Filters stream for one step.
Filters all traces in stream.
Parameters
----------
step : array element
step holding variables for one filtering operation
stream : obspy.core.Stream
stream of data to filter
Returns
-------
out : obspy.core.Stream
stream containing 1 trace per original trace.
"""
# gather variables from step
input_sample_period = step["input_sample_period"]
output_sample_period = step["output_sample_period"]
window = np.array(step["window"])
decimation = int(output_sample_period / input_sample_period)
numtaps = len(window)
window = window / sum(window)
# first output timestamp is in the center of the filter window
filter_time_shift = input_sample_period * (numtaps // 2)
out = Stream()
for trace in stream:
# data to filter
data = trace.data
starttime = trace.stats.starttime + filter_time_shift
# align with the output period
misalignment = starttime.timestamp % output_sample_period
if misalignment != 0:
# skip incomplete input
starttime = (starttime - misalignment) + output_sample_period
input_starttime = starttime - filter_time_shift
offset = int(1e-6 + (input_starttime - trace.stats.starttime) /
input_sample_period)
print(f"Skipping {offset} input samples to align output",
file=sys.stderr)
data = data[offset:]
# check there is still enough data for filter
if len(data) < numtaps:
continue
filtered = self.firfilter(data, window, decimation)
stats = Stats(trace.stats)
stats.starttime = starttime
stats.delta = output_sample_period
stats.npts = len(filtered)
trace_out = self.create_trace(stats.channel, stats, filtered)
out += trace_out
return out
def read_specfem_seismogram(output_files, network, station, band):
st = Stream()
for component in 'ZNE':
channel = '%sX%s' % (band, component)
filename = os.path.join(
output_files, '%s.%s.%s.sem.ascii' % (network, station, channel))
tmp = np.genfromtxt(filename)
stats = Stats()
stats.network = network
stats.station = station
stats.channel = channel
stats.delta = tmp[1, 0] - tmp[0, 0]
stats.npts = tmp.shape[0]
stats.starttime = tmp[0, 0]
tr = Trace(tmp[:, 1], stats)
st += tr
return st
def read_specfem_seismogram(output_files, network, station, band):
st = Stream()
for component in 'ZNE':
channel = '%sX%s' % (band, component)
filename = os.path.join(output_files,
'%s.%s.%s.sem.ascii' % (network, station,
channel))
tmp = np.genfromtxt(filename)
stats = Stats()
stats.network = network
stats.station = station
stats.channel = channel
stats.delta = tmp[1, 0] - tmp[0, 0]
stats.npts = tmp.shape[0]
stats.starttime = tmp[0, 0]
tr = Trace(tmp[:, 1], stats)
st += tr
return st
def load_axisem3d_data(file,station_code,component):
axisem3d_data = Dataset(file)
times_a = axisem3d_data.variables['time_points']
axisem3d_stats = Stats()
axisem3d_stats.delta = (times_a[1] - times_a[0])
axisem3d_stats.starttime = UTCDateTime(times_a[0])
axisem3d_stats.npts = times_a.size
station_code = station_code+('.KO.RTZ')
if component =='z':
c_a = axisem3d_data.variables[station_code][:, 2]
elif component =='t':
c_a = axisem3d_data.variables[station_code][:, 1]
elif component =='r':
c_a = axisem3d_data.variables[station_code][:, 0]
else:
raise Exception('No component with this name')
axisem3d_trace = Trace(c_a, header=axisem3d_stats)
axisem3d_data.close()
return axisem3d_trace
def process_step(self, step, stream):
"""Filters stream for one step.
Filters all traces in stream.
Parameters
----------
step : array element
step holding variables for one filtering operation
stream : obspy.core.Stream
stream of data to filter
Returns
-------
out : obspy.core.Stream
stream containing 1 trace per original trace.
"""
# gather variables from step
input_sample_period = step["input_sample_period"]
output_sample_period = step["output_sample_period"]
window = np.array(step["window"])
decimation = int(output_sample_period / input_sample_period)
numtaps = len(window)
window = window / sum(window)
out = Stream()
for trace in stream:
starttime, data = self.align_trace(step, trace)
# check that there is still enough data to filter
if len(data) < numtaps:
continue
filtered = self.firfilter(data, window, decimation)
stats = Stats(trace.stats)
stats.delta = output_sample_period
stats.data_interval = step["data_interval"]
stats.data_interval_type = step["data_interval_type"]
stats.filter_comments = step["filter_comments"]
stats.starttime = starttime
stats.npts = len(filtered)
trace_out = self.create_trace(stats.channel, stats, filtered)
out += trace_out
return out
#****************************************************************************
# data description
#****************************************************************************
NR = 50 # number of receivers
LEN = 10000 #8000# data length
comp1 = 'Uz'
# read Heidimode data
dz_src = path_in + '/arbzseis'
dz_data = np.fromfile(dz_src, dtype='>f') # big endian float (4 bytes)
dz_data = dz_data.reshape((NR, LEN), order="F")
dz_data = np.float32(dz_data)
# write SU-format binary
dz_dest = path_out + '/' + comp1 + '_file_single.su'
stats = Stats()
stats.filename = dz_dest
stats.starttime = 0.0
stats.delta = 1.0e-4 # ObsPy DO NOT WORK WITH VERY SMALL TIMESTEP 10.0e-8
stats.npts = LEN
stream = Stream()
for i in range(NR):
stream.append(Trace(data=dz_data[i, :], header=stats))
#stream.append(Trace(data=dz_data[i,:]))
print 'max of trace %i is %f' % (i, np.max(dz_data[i, :]))
print stream
#stream[0].plot()
stream.write(dz_dest, format='su')
def moveout_test(PSS_file, q, phase):
"""
Creates synthetic PRFs and stacks them after depth migration.
Parameters
----------
PSS_file : str
Filename of raysum file containing P-Sv-Sh traces.
q : float
Slowness [s/m].
phase : str
Either "P" for Ps or "S" for Sp.
Returns
-------
z : np.array
Depth vector.
stack : np.array
Receiver function stack.
RF_mo : np.array
Matrix containing all depth migrated RFs.
RF : np.array
Matrix containing all RFs.
dt : float
Sampling interval.
PSS : np.array
Matrix containing all traces in P-Sv-Sh.
"""
rayp = q * 1.111949e5
PSS, dt, M, N, shift = read_raysum(phase, PSS_file=PSS_file)
# Create receiver functions
RF = []
RF_mo = []
stats = Stats()
stats.npts = N
stats.delta = dt
stats.starttime = UTCDateTime(0)
for i in range(M):
if phase == "P":
data, _, IR = it(PSS[i, 0, :],
PSS[i, 1, :],
dt,
shift=shift,
width=4)
elif phase == "S":
data, _, _ = it(PSS[i, 1, :],
PSS[i, 0, :],
dt,
shift=shift,
width=4)
RF.append(data)
z, rfc = moveout(data,
stats,
UTCDateTime(shift),
rayp[i],
phase,
fname="raysum.dat")
RF_mo.append(rfc)
stack = np.average(RF_mo, axis=0)
plt.close('all')
plt.figure()
for mo in RF_mo:
plt.plot(z, mo)
return z, stack, RF_mo, RF, dt, PSS
def rf_test(phase,
dip,
rfloc='output/waveforms/RF',
geom_file='3D.geom',
decon_meth='it'):
"""
Creates synthetic PRFs from Raysum data.
Parameters
----------
phase : string
"P" or "S".
dip : int
Dip of the LAB in deg, determines, which files to use
rfloc : The parental directory, in which the RFs are saved.
geom_file : str, optional
Filename of the geometry file
Returns
-------
rfs: list
List of RFTrace objects. Will in addition be saved in SAC format.
"""
# Determine filenames
PSS_file = []
for i in range(16):
PSS_file.append('3D_' + str(dip) + '_' + str(i) + '.tr')
# Read geometry
baz, q, dN, dE = read_geom(geom_file, phase)
# statlat = dN/(DEG2KM*1000)
d = np.sqrt(np.square(dN) + np.square(dE))
az = np.rad2deg(np.arccos(dN / d))
i = np.where(dE < 0)
az[i] = az[i] + 180
statlat = []
statlon = []
for azimuth, delta in zip(az, d):
if delta == 0:
statlat.append(0)
statlon.append(0)
continue
coords = Geodesic.WGS84.Direct(0, 0, azimuth, delta)
statlat.append(coords["lat2"])
statlon.append(coords["lon2"])
# for n, longitude in enumerate(lon):
# y, _, _ = gps2dist_azimuth(latitude, 0, latitude, longitude)
# statlon = dE/(DEG2KM*1000)
rayp = q * DEG2KM * 1000
# Read traces
stream = []
for f in PSS_file:
PSS, dt, _, N, shift = read_raysum(phase, PSS_file=f)
stream.append(PSS)
streams = np.vstack(stream)
del stream
M = len(baz)
if M != streams.shape[0]:
raise ValueError([
"Number of traces", streams.shape[0], """does not
equal the number of backazimuths in the geom file""", M
])
rfs = []
odir = os.path.join(rfloc, phase, 'raysum', str(dip))
ch = ['BHP', 'BHV', 'BHH'] # Channel names
os.makedirs(odir, exist_ok=True)
# Create RF objects
for i, st in enumerate(streams):
s = Stream()
for j, tr in enumerate(st):
stats = Stats()
stats.npts = N
stats.delta = dt
stats.st # if old:
stats.channel = ch[j]
stats.network = 'RS'
stats.station = str(dip)
s.append(Trace(data=tr, header=stats))
# Create info dictionary for rf creation
info = {
'onset': [UTCDateTime(0) + shift],
'starttime': [UTCDateTime(0)],
'statlat': statlat[i],
'statlon': statlon[i],
'statel': 0,
'rayp_s_deg': [rayp[i]],
'rbaz': [baz[i]],
'rdelta': [np.nan],
'ot_ret': [0],
'magnitude': [np.nan],
'evt_depth': [np.nan],
'evtlon': [np.nan],
'evtlat': [np.nan]
}
rf = createRF(s, phase=phase, method=decon_meth, info=info)
# Write RF
rf.write(os.path.join(odir, str(i) + '.sac'), format='SAC')
rfs.append(rf)
return rfs, statlat, statlon
def raw_import(gzip_filename):
"""
Makes a 'raw' stream file from the gzipped csv file.
The csv file has been downloaded from the JAXA website.
The method makes a raw stream which does not yet have the frames
reconstructed.
:type gzip_filename: str
:param gzip_filename: gzipped filename of the CSV file to be read.
:rtype: :class:`~obspy.core.stream.Stream`
:return: A ObsPy Stream object.
"""
# read the gzipped csv file
with gzip.open(gzip_filename, 'rt') as fh:
# read file
buf = []
header = next(fh).split(',')
# read the header
# it should contain either 1 channel or 3
if len(header) == 8:
# the RESP files use either 'MH1', 'MH2', 'MHZ'
# the JAXA files use 'LPX', 'LPY', 'LPZ'
# X should point north, Y east, but this is not always the case
# so we rename LPX to MH1, and LPY to MH2
channels = ['MH1', 'MH2', 'MHZ']
raw_channels = ['_M1', '_M2', '_MZ']
for line in fh:
temp = line.split(',')
try:
temp[4] = UTCDateTime(temp[4])
except ValueError as e:
# this is a specific error which is found in the csv file
if temp[4] == '1975-49-11 19:13:04.232000':
temp[4] = UTCDateTime('1975-09-11 19:13:04.232000')
else:
raise
try:
temp[0] = int(temp[0])
except ValueError as e:
# this is a specific error which is found in the csv file
if temp[4] == UTCDateTime(
'1975-09-15 12:53:36.849000') and temp[0] == '<3':
temp[0] = 83
else:
raise
buf.append(
(temp[1], temp[2], temp[4], int(temp[0]), int(temp[3]),
int(temp[5]), int(temp[6]), int(temp[7])))
elif len(header) == 6:
channels = ['SPZ']
raw_channels = ['_SZ']
for line in fh:
# check the manual list of points which have been removed
if line in remove_manually:
continue
temp = line.split(',')
# the original order:
# frame_count, ap_station, ground_station, nc, time, spz
# make a tuple (in a new order so that it can be sorted):
# ap_station, ground_station, time, frame_count, nc, spz
buf.append(
(temp[1], temp[2], UTCDateTime(temp[4]), int(temp[0]),
int(temp[3]), int(temp[5])))
# sort by ap_station, ground_station and time (and also everything else,
# but that won't matter)
buf.sort()
stream = Stream()
data_x = []
data_y = []
data_z = []
data_sz = []
abs_times = []
frame_count_ncs = []
corr_frame_count_ncs = []
stats = Stats()
stats.delta = DELTA
network = 'XA'
last_id = None
for data in buf:
# read in the data from the buffer
station = data[0].rjust(3, 'S')
ground_station = data[1].rjust(2, '0')
time = data[2]
frame_count = data[3]
nc = data[4]
# create a combination of frame count and nc - from 0.0 to 89.75
frame_count_nc = float(frame_count) + (float(nc) - 1.) * 0.25
id = "{0:s}.{1:s}.{2:s}.{3:s}".format(network, station, ground_station,
channels[0])
# check whether we are adding to an existing one, or creating a new one
if (last_id is None or last_id != id):
# before creating the new one, add previous trace(s) to the stream
if len(abs_times) > 0:
_make_traces(stream=stream,
stats=stats,
header=header,
channels=raw_channels,
data_x=data_x,
data_y=data_y,
data_z=data_z,
data_sz=data_sz,
abs_times=abs_times,
frame_count_ncs=frame_count_ncs)
data_x = []
data_y = []
data_z = []
data_sz = []
abs_times = []
frame_count_ncs = []
stats = Stats()
stats.delta = DELTA
stats.starttime = time
stats.network = network
stats.station = station
stats.location = ground_station
# add the data) from any line
if len(header) == 8:
data_x.append(data[5])
data_y.append(data[6])
data_z.append(data[7])
else:
data_sz.append(data[5])
abs_times.append(time.timestamp)
frame_count_ncs.append(frame_count_nc)
last_id = id
# add the last one
if len(abs_times) > 0:
_make_traces(stream=stream,
stats=stats,
header=header,
channels=raw_channels,
data_x=data_x,
data_y=data_y,
data_z=data_z,
data_sz=data_sz,
abs_times=abs_times,
frame_count_ncs=frame_count_ncs)
return stream
def test_delta_zero(self):
"""
Make sure you can set delta = 0. for #1989
"""
stat = Stats()
stat.delta = 0
def test_delta_zero(self):
"""
Make sure you can set delta = 0. for #1989
"""
stat = Stats()
stat.delta = 0
endtime = UTCDateTime(Time_stamps[len(Time_stamps) - 1])
sttime._set_year(2017)
endtime._set_year(2017)
sttime._set_month(8)
endtime._set_month(8)
sttime._set_day(13 + UTCDateTime(Time_stamps[0]).day)
endtime._set_day(13 + UTCDateTime(Time_stamps[len(Time_stamps) - 1]).day)
# Define stats
stats = Stats()
stats.starttime = sttime
stats.station = station
stats.network = 'NT'
stats.location = 'R0'
stats.data_interval = '256Hz'
stats.delta = .00390625
stats.data_type = 'variation'
# Create list of arrays and channel names and intialize counter k
arrays = [Hx, Hy, Ex, Ey]
k = 0
# Loop over channels to create an obspy stream of the data
for ar in arrays:
stats.npts = len(ar)
stats.channel = channels[k]
ar = np.asarray(ar)
trace = Trace(ar, stats)
stream += trace
trace = None
k += 1