def test_recursive(self, read_header_mock):
# For this we need to patch fnmatch as well, as the names here aren't
# full path
read_header_mock.return_value = None
d_innera = {
'a':
create_group_mock({}, '/outout/outer_group0/testname', False),
'b':
create_group_mock({}, '/outout/outer_group0/different_name', False)
}
d_innerb = {
'a':
create_group_mock({}, '/outout/outer_group1/testname', False),
'b':
create_group_mock({}, '/outout/outer_group1/different_name', False)
}
d_outer = {
'A': create_group_mock(d_innera, '/outout/outer_group0', True),
'B': create_group_mock(d_innerb, '/outout/outer_group1', True)
}
g = create_group_mock(d_outer, 'outout', True)
st = RFStream()
st = rfh5.all_traces_recursive(g, st, '/outout/outer_group1/testname')
self.assertEqual(st.count(), 1)
st = rfh5.all_traces_recursive(g, st.clear(), '*')
self.assertEqual(st.count(), 4)
def all_traces_recursive(group: h5py._hl.group.Group, stream: RFStream,
pattern: str) -> RFStream:
"""
Recursively, appends all traces in a h5py group to the input stream.
In addition this will check whether the data matches a certain pattern.
:param group: group to search through
:type group: class:`h5py._hl.group.Group`
:param stream: Stream to append the traces to
:type stream: CorrStream
:param pattern: pattern for the path in the hdf5 file, see fnmatch for
details.
:type pattern: str
:return: Stream with appended traces
:rtype: CorrStream
"""
for v in group.values():
if isinstance(v, h5py._hl.group.Group):
all_traces_recursive(v, stream, pattern)
elif not fnmatch.fnmatch(v.name, pattern) and v.name not in pattern:
continue
else:
# try:
stream.append(RFTrace(np.array(v), header=read_hdf5_header(v)))
# except ValueError:
# warnings.warn(
# 'Header could not be converted. Attributes are: %s' % (
# str(v.attrs)))
return stream
def get_data(self,
network: str,
station: str,
phase: str,
evt_time: UTCDateTime,
tag: str = 'rf',
pol: str = 'v') -> RFStream:
"""
Returns a :class:`~pyglimer.rf.create.RFStream` holding
all the requested data.
.. note::
`Wildcards are allowed for all parameters`.
:param network: network code, e.g., IU
:type network: str
:param station: station code, e.g., HRV
:type station: str
:param phase: Teleseismic phase
:type phase: str
:param evt_time: Origin Time of the Event
:type evt_time: UTCDateTime, optional
:param tag: Data tag (e.g., 'rf'). Defaults to rf.
:type tag: str, optional
:param pol: RF Polarisation. Defaults to v.
:type pol: str, optional
:return: a :class:`~pyglimer.rf.create.RFStream` holding the requested
data.
:rtype: RFStream
"""
try:
evt_time = UTCDateTime(evt_time)
evt_time = evt_time.format_fissures()
except TypeError:
evt_time = '*'
path = hierarchy.format(tag=tag,
network=network,
station=station,
phase=phase,
pol=pol,
evt_time=evt_time)
# Extremely ugly way of changing the path
if '*' not in path:
data = np.array(self[path])
header = read_hdf5_header(self[path])
return RFStream(RFTrace(data, header=header))
# Now, we need to differ between the fnmatch pattern and the actually
# acessed path
pattern = path.replace('/*', '*')
path = path.split('*')[0]
try:
return all_traces_recursive(self[path], RFStream(), pattern)
except KeyError:
warnings.warn(
f'Could not find data from {network}.{station} for phase ' +
f'{phase}, tag {tag}, polarisation {pol}, and time ' +
f'{evt_time}. Returning empty Stream.')
return RFStream()
def cos_taper_st(st: Stream,
taper_len: float,
taper_at_masked: bool,
side: str = 'both') -> Stream:
"""
Applies a cosine taper to the input Stream.
:param tr: Input Stream
:type tr: :class:`~obspy.core.stream.Stream`
:param taper_len: Length of the taper per side
:type taper_len: float
:param taper_at_masked: applies a split to each trace and merges again
afterwards
:type taper_at_masked: bool
:return: Tapered Stream
:rtype: :class:`~obspy.core.stream.Stream`
.. note::
This action is performed in place. If you want to keep the
original data use :func:`~obspy.core.stream.Stream.copy`.
"""
if isinstance(st, Trace):
st = Stream([st])
elif isinstance(st, RFTrace):
st = RFStream([st])
for ii, _ in enumerate(st):
try:
st[ii] = cos_taper(st[ii], taper_len, taper_at_masked, side)
except ValueError as e:
warn('%s, corresponding trace not tapered.' % e)
return st
def test_get_coords_warning(self, file_mock, get_data_mock):
get_data_mock.return_value = RFStream([self.rftr])
d_inner = {
'bla':
create_group_mock(
{}, '/rf/%s/%s/P/v' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_middle = {
'v':
create_group_mock(
d_inner, '/rf/%s/%s/P' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_outer = {
'P':
create_group_mock(
d_middle, '/rf/%s/%s' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_oo = {
'rf': {
self.rftr.stats.network: {
self.rftr.stats.station: d_outer
}
}
}
file_mock.side_effect = d_oo.__getitem__
with warnings.catch_warnings(record=True) as w:
x = self.dbh.get_coords('bla', self.rftr.stats.station)
self.assertTupleEqual(x, (None, None, None))
self.assertEqual(len(w), 1)
def test_get_coords(self, file_mock, get_data_mock):
get_data_mock.return_value = RFStream([self.rftr])
d_inner = {
'bla':
create_group_mock(
{}, '/rf/%s/%s/P/v' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_middle = {
'v':
create_group_mock(
d_inner, '/rf/%s/%s/P' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_outer = {
'P':
create_group_mock(
d_middle, '/rf/%s/%s' %
(self.rftr.stats.network, self.rftr.stats.station), True)
}
d_oo = {
'rf': {
self.rftr.stats.network: {
self.rftr.stats.station: d_outer
}
}
}
file_mock.side_effect = d_oo.__getitem__
exp_result = (15, -55, 355)
self.assertTupleEqual(
exp_result,
self.dbh.get_coords(self.rftr.stats.network,
self.rftr.stats.station))
def test_moveout_vs_XY(self):
stream = RFStream(read())[:1]
for tr in stream:
tr.stats.slowness = 10.
tr.stats.onset = tr.stats.starttime + 20.643
tr.stats.phase = 'P'
tr.stats.type = 'time'
tr.stats.station_elevation = 0
tr.stats.station_longitude = 0
tr.stats.station_latitude = 0
stream.decimate(10)
N = len(stream[0])
t = np.linspace(0, 20 * np.pi, N)
stream[0].data = np.sin(t) * np.exp(-0.04 * t)
stream[0].stats.slowness = 4.0
stream1 = stream.copy()
stream3 = stream.copy()
stream3[0].stats.slowness = 9.0
stream9 = stream.copy()
stream10 = stream.copy()
stream1.moveout('iasp91.dat')
stream3.moveout('iasp91.dat')
np.testing.assert_array_almost_equal(stream9[0].data,
stream10[0].data,
decimal=2)
def test_is_np_array(self, read_header_mock):
read_header_mock.return_value = None
d = {
'a': create_group_mock({}, '/outer_group/testname', False),
'b': create_group_mock({}, '/outer_group/different_name', False)
}
g = create_group_mock(d, '/outer_group', True)
st = RFStream()
st = rfh5.all_traces_recursive(g, st, '/outer_group/testname')
self.assertEqual(st.count(), 1)
st = rfh5.all_traces_recursive(g, st.clear(),
'/outer_group/different_name')
self.assertEqual(st.count(), 1)
st = rfh5.all_traces_recursive(g, st.clear(), '*name')
self.assertEqual(st.count(), 2)
st = rfh5.all_traces_recursive(g, st.clear(), 'no_match')
self.assertEqual(st.count(), 0)
def test_get_data_wildcard2(self, file_mock, all_tr_recursive_mock):
all_tr_recursive_mock.return_value = None
net = 'AB'
stat = '*'
phase = '*'
tag = 'rand'
evt_time = '*'
pol = '*'
exp_path = rfh5.hierarchy.format(tag=tag,
network=net,
station=stat,
phase=phase,
pol=pol,
evt_time=evt_time)
exp_path = '/'.join(exp_path.split('/')[:-4])
d = {exp_path: self.rftr.data, '/rand/AB/': self.rftr.data}
file_mock.side_effect = d.__getitem__
_ = self.dbh.get_data(net, stat, phase, evt_time, tag=tag, pol=pol)
file_mock.assert_called_with('/rand/AB/')
all_tr_recursive_mock.assert_called_with(d['/rand/AB/'], RFStream(),
'/rand/AB****')
def test_get_data_wildcard(self, file_mock, all_tr_recursive_mock):
all_tr_recursive_mock.return_value = None
net = 'AB'
stat = '*'
tag = 'rand'
phase = 'P'
pol = 'v'
evt_time = UTCDateTime(0)
exp_path = rfh5.hierarchy.format(tag=tag,
network=net,
station=stat,
phase=phase,
pol=pol,
evt_time=evt_time.format_fissures())
d = {exp_path: self.rftr.data, '/rand/AB/': self.rftr.data}
file_mock.side_effect = d.__getitem__
_ = self.dbh.get_data(net, stat, phase, evt_time, tag=tag, pol=pol)
file_mock.assert_called_with('/rand/AB/')
all_tr_recursive_mock.assert_called_with(
d['/rand/AB/'], RFStream(),
'/rand/AB*/%s/%s/%s' % (phase, pol, evt_time.format_fissures()))