def test_registerRtProcess(self):
"""
Testing register_rt_process method.
"""
tr = RtTrace()
# 1 - function call
tr.register_rt_process(np.abs)
self.assertEqual(tr.processing, [(np.abs, {}, None)])
# 2 - predefined RT processing algorithm
tr.register_rt_process('integrate', test=1, muh='maeh')
self.assertEqual(tr.processing[1][0], 'integrate')
self.assertEqual(tr.processing[1][1], {'test': 1, 'muh': 'maeh'})
self.assertTrue(isinstance(tr.processing[1][2][0], RtMemory))
# 3 - contained name of predefined RT processing algorithm
tr.register_rt_process('in')
self.assertEqual(tr.processing[2][0], 'integrate')
tr.register_rt_process('integ')
self.assertEqual(tr.processing[3][0], 'integrate')
tr.register_rt_process('integr')
self.assertEqual(tr.processing[4][0], 'integrate')
# 4 - unknown functions
self.assertRaises(NotImplementedError,
tr.register_rt_process, 'integrate2')
self.assertRaises(NotImplementedError, tr.register_rt_process, 'xyz')
# 5 - module instead of function
self.assertRaises(NotImplementedError, tr.register_rt_process, np)
# check number off all processing steps within RtTrace
self.assertEqual(len(tr.processing), 5)
# check tr.stats.processing
self.assertEqual(len(tr.stats.processing), 5)
self.assertTrue(tr.stats.processing[0].startswith("realtime_process"))
self.assertIn('absolute', tr.stats.processing[0])
for i in range(1, 5):
self.assertIn('integrate', tr.stats.processing[i])
# check kwargs
self.assertIn("maeh", tr.stats.processing[1])
def test_register_rt_process(self):
"""
Testing register_rt_process method.
"""
tr = RtTrace()
# 1 - function call
tr.register_rt_process(np.abs)
self.assertEqual(tr.processing, [(np.abs, {}, None)])
# 2 - predefined RT processing algorithm
tr.register_rt_process('integrate', test=1, muh='maeh')
self.assertEqual(tr.processing[1][0], 'integrate')
self.assertEqual(tr.processing[1][1], {'test': 1, 'muh': 'maeh'})
self.assertTrue(isinstance(tr.processing[1][2][0], RtMemory))
# 3 - contained name of predefined RT processing algorithm
tr.register_rt_process('in')
self.assertEqual(tr.processing[2][0], 'integrate')
tr.register_rt_process('integ')
self.assertEqual(tr.processing[3][0], 'integrate')
tr.register_rt_process('integr')
self.assertEqual(tr.processing[4][0], 'integrate')
# 4 - unknown functions
self.assertRaises(NotImplementedError, tr.register_rt_process,
'integrate2')
self.assertRaises(NotImplementedError, tr.register_rt_process, 'xyz')
# 5 - module instead of function
self.assertRaises(NotImplementedError, tr.register_rt_process, np)
# check number off all processing steps within RtTrace
self.assertEqual(len(tr.processing), 5)
# check tr.stats.processing
self.assertEqual(len(tr.stats.processing), 5)
self.assertTrue(tr.stats.processing[0].startswith("realtime_process"))
self.assertIn('absolute', tr.stats.processing[0])
for i in range(1, 5):
self.assertIn('integrate', tr.stats.processing[i])
# check kwargs
self.assertIn("maeh", tr.stats.processing[1])
def test_copy(self):
"""
Testing copy of RtTrace object.
"""
rtr = RtTrace()
rtr.copy()
# register predefined function
rtr.register_rt_process('integrate', test=1, muh='maeh')
rtr.copy()
# register ObsPy function call
rtr.register_rt_process(signal.filter.bandpass, freqmin=0, freqmax=1,
df=0.1)
rtr.copy()
# register NumPy function call
rtr.register_rt_process(np.square)
rtr.copy()
def test_copy(self):
"""
Testing copy of RtTrace object.
"""
rtr = RtTrace()
rtr.copy()
# register predefined function
rtr.register_rt_process('integrate', test=1, muh='maeh')
rtr.copy()
# register ObsPy function call
rtr.register_rt_process(obspy.signal.filter.bandpass,
freqmin=0,
freqmax=1,
df=0.1)
rtr.copy()
# register NumPy function call
rtr.register_rt_process(np.square)
rtr.copy()
def test_missingOrWrongArgumentInRtProcess(self):
"""
Tests handling of missing/wrong arguments.
"""
trace = Trace(np.arange(100))
# 1- function scale needs no additional arguments
rt_trace = RtTrace()
rt_trace.register_rt_process('scale')
rt_trace.append(trace)
# adding arbitrary arguments should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('scale', muh='maeh')
self.assertRaises(TypeError, rt_trace.append, trace)
# 2- function tauc has one required argument
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', width=10)
rt_trace.append(trace)
# wrong argument should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', xyz='xyz')
self.assertRaises(TypeError, rt_trace.append, trace)
# missing argument width should raise an exception
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc')
self.assertRaises(TypeError, rt_trace.append, trace)
# adding arbitrary arguments should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', width=20, notexistingoption=True)
self.assertRaises(TypeError, rt_trace.append, trace)
class RealTimeSignalTestCase(unittest.TestCase):
"""
The obspy.realtime.signal test suite.
"""
@classmethod
def setUpClass(cls):
# read test data as float64
cls.orig_trace = read(os.path.join(os.path.dirname(__file__), 'data',
'II.TLY.BHZ.SAC'),
dtype=np.float64)[0]
# make really sure test data is float64
cls.orig_trace.data = np.require(cls.orig_trace.data, np.float64)
cls.orig_trace_chunks = cls.orig_trace / NUM_PACKETS
def setUp(self):
# clear results
self.filt_trace_data = None
self.rt_trace = None
self.rt_appended_traces = []
def tearDown(self):
# use results for debug plots if enabled
if PLOT_TRACES and self.filt_trace_data is not None and \
self.rt_trace is not None and self.rt_appended_traces:
self._plot_results()
def test_square(self):
"""
Testing np.square function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = np.square(trace)
# filtering real time
process_list = [(np.square, {})]
self._run_rt_process(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_integrate(self):
"""
Testing integrate function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = signal.integrate(trace)
# filtering real time
process_list = [('integrate', {})]
self._run_rt_process(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_differentiate(self):
"""
Testing differentiate function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = signal.differentiate(trace)
# filtering real time
process_list = [('differentiate', {})]
self._run_rt_process(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_boxcar(self):
"""
Testing boxcar function.
"""
trace = self.orig_trace.copy()
options = {'width': 500}
# filtering manual
self.filt_trace_data = signal.boxcar(trace, **options)
# filtering real time
process_list = [('boxcar', options)]
self._run_rt_process(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertAlmostEqual(peak, 566974.214, 3)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_scale(self):
"""
Testing scale function.
"""
trace = self.orig_trace.copy()
options = {'factor': 1000}
# filtering manual
self.filt_trace_data = signal.scale(trace, **options)
# filtering real time
process_list = [('scale', options)]
self._run_rt_process(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertEqual(peak, 1045237000.0)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_offset(self):
"""
Testing offset function.
"""
trace = self.orig_trace.copy()
options = {'offset': 500}
# filtering manual
self.filt_trace_data = signal.offset(trace, **options)
# filtering real time
process_list = [('offset', options)]
self._run_rt_process(process_list)
# check results
diff = self.rt_trace.data - self.orig_trace.data
self.assertEqual(np.mean(diff), 500)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_kurtosis(self):
"""
Testing kurtosis function.
"""
trace = self.orig_trace.copy()
options = {'win': 5}
# filtering manual
self.filt_trace_data = signal.kurtosis(trace, **options)
# filtering real time
process_list = [('kurtosis', options)]
self._run_rt_process(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_abs(self):
"""
Testing np.abs function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = np.abs(trace)
# filtering real time
process_list = [(np.abs, {})]
self._run_rt_process(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertEqual(peak, 1045237)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_tauc(self):
"""
Testing tauc function.
"""
trace = self.orig_trace.copy()
options = {'width': 60}
# filtering manual
self.filt_trace_data = signal.tauc(trace, **options)
# filtering real time
process_list = [('tauc', options)]
self._run_rt_process(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertAlmostEqual(peak, 114.302, 3)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_mwp_integral(self):
"""
Testing mwpintegral functions.
"""
trace = self.orig_trace.copy()
options = {
'mem_time': 240,
'ref_time': trace.stats.starttime + 301.506,
'max_time': 120,
'gain': 1.610210e+09
}
# filtering manual
self.filt_trace_data = signal.mwpintegral(self.orig_trace.copy(),
**options)
# filtering real time
process_list = [('mwpintegral', options)]
self._run_rt_process(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_mwp(self):
"""
Testing Mwp calculation using two processing functions.
"""
trace = self.orig_trace.copy()
epicentral_distance = 30.0855
options = {
'mem_time': 240,
'ref_time': trace.stats.starttime + 301.506,
'max_time': 120,
'gain': 1.610210e+09
}
# filtering manual
trace.data = signal.integrate(trace)
self.filt_trace_data = signal.mwpintegral(trace, **options)
# filtering real time
process_list = [('integrate', {}), ('mwpintegral', options)]
self._run_rt_process(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
mwp = signal.calculate_mwp_mag(peak, epicentral_distance)
self.assertAlmostEqual(mwp, 8.78902911791, 5)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_combined(self):
"""
Testing combining integrate and differentiate functions.
"""
trace = self.orig_trace.copy()
# filtering manual
trace.data = signal.integrate(trace)
self.filt_trace_data = signal.differentiate(trace)
# filtering real time
process_list = [('int', {}), ('diff', {})]
self._run_rt_process(process_list)
# check results
trace = self.orig_trace.copy()
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
np.testing.assert_almost_equal(trace.data[1:], self.rt_trace.data[1:])
np.testing.assert_almost_equal(trace.data[1:],
self.filt_trace_data[1:])
def _run_rt_process(self, process_list, max_length=None):
"""
Helper function to create a RtTrace, register all given process
functions and run the real time processing.
"""
# assemble real time trace
self.rt_trace = RtTrace(max_length=max_length)
for (process, options) in process_list:
self.rt_trace.register_rt_process(process, **options)
# append packet data to RtTrace
self.rt_appended_traces = []
for trace in self.orig_trace_chunks:
# process single trace
result = self.rt_trace.append(trace, gap_overlap_check=True)
# add to list of appended traces
self.rt_appended_traces.append(result)
def _plot_results(self):
"""
Plots original, filtered original and real time processed traces into
a single plot.
"""
# plot only if test is started manually
if __name__ != '__main__':
return
# create empty stream
st = Stream()
st.label = self._testMethodName
# original trace
self.orig_trace.label = "Original Trace"
st += self.orig_trace
# use header information of original trace with filtered trace data
tr = self.orig_trace.copy()
tr.data = self.filt_trace_data
tr.label = "Filtered original Trace"
st += tr
# real processed chunks
for i, tr in enumerate(self.rt_appended_traces):
tr.label = "RT Chunk %02d" % (i + 1)
st += tr
# real time processed trace
self.rt_trace.label = "RT Trace"
st += self.rt_trace
st.plot(automerge=False, color='blue', equal_scale=False)
def test_missing_or_wrong_argument_in_rt_process(self):
"""
Tests handling of missing/wrong arguments.
"""
trace = Trace(np.arange(100))
# 1- function scale needs no additional arguments
rt_trace = RtTrace()
rt_trace.register_rt_process('scale')
rt_trace.append(trace)
# adding arbitrary arguments should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('scale', muh='maeh')
self.assertRaises(TypeError, rt_trace.append, trace)
# 2- function tauc has one required argument
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', width=10)
rt_trace.append(trace)
# wrong argument should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', xyz='xyz')
self.assertRaises(TypeError, rt_trace.append, trace)
# missing argument width should raise an exception
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc')
self.assertRaises(TypeError, rt_trace.append, trace)
# adding arbitrary arguments should fail
rt_trace = RtTrace()
rt_trace.register_rt_process('tauc', width=20, notexistingoption=True)
self.assertRaises(TypeError, rt_trace.append, trace)
class RealTimeSignalTestCase(unittest.TestCase):
"""
The obspy.realtime.signal test suite.
"""
def __init__(self, *args, **kwargs):
super(RealTimeSignalTestCase, self).__init__(*args, **kwargs)
# read test data as float64
self.orig_trace = read(os.path.join(os.path.dirname(__file__), 'data',
'II.TLY.BHZ.SAC'),
dtype=np.float64)[0]
# make really sure test data is float64
self.orig_trace.data = np.require(self.orig_trace.data, np.float64)
self.orig_trace_chunks = self.orig_trace / NUM_PACKETS
def setUp(self):
# clear results
self.filt_trace_data = None
self.rt_trace = None
self.rt_appended_traces = []
def tearDown(self):
# use results for debug plots if enabled
if PLOT_TRACES and self.filt_trace_data is not None and \
self.rt_trace is not None and self.rt_appended_traces:
self._plotResults()
def test_square(self):
"""
Testing np.square function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = np.square(trace)
# filtering real time
process_list = [(np.square, {})]
self._runRtProcess(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_integrate(self):
"""
Testing integrate function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = signal.integrate(trace)
# filtering real time
process_list = [('integrate', {})]
self._runRtProcess(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_differentiate(self):
"""
Testing differentiate function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = signal.differentiate(trace)
# filtering real time
process_list = [('differentiate', {})]
self._runRtProcess(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_boxcar(self):
"""
Testing boxcar function.
"""
trace = self.orig_trace.copy()
options = {'width': 500}
# filtering manual
self.filt_trace_data = signal.boxcar(trace, **options)
# filtering real time
process_list = [('boxcar', options)]
self._runRtProcess(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertAlmostEqual(peak, 566974.214, 3)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_scale(self):
"""
Testing scale function.
"""
trace = self.orig_trace.copy()
options = {'factor': 1000}
# filtering manual
self.filt_trace_data = signal.scale(trace, **options)
# filtering real time
process_list = [('scale', options)]
self._runRtProcess(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertEqual(peak, 1045237000.0)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_offset(self):
"""
Testing offset function.
"""
trace = self.orig_trace.copy()
options = {'offset': 500}
# filtering manual
self.filt_trace_data = signal.offset(trace, **options)
# filtering real time
process_list = [('offset', options)]
self._runRtProcess(process_list)
# check results
diff = self.rt_trace.data - self.orig_trace.data
self.assertEqual(np.mean(diff), 500)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_kurtosis(self):
"""
Testing kurtosis function.
"""
trace = self.orig_trace.copy()
options = {'win': 5}
# filtering manual
self.filt_trace_data = signal.kurtosis(trace, **options)
# filtering real time
process_list = [('kurtosis', options)]
self._runRtProcess(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_abs(self):
"""
Testing np.abs function.
"""
trace = self.orig_trace.copy()
# filtering manual
self.filt_trace_data = np.abs(trace)
# filtering real time
process_list = [(np.abs, {})]
self._runRtProcess(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertEqual(peak, 1045237)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_tauc(self):
"""
Testing tauc function.
"""
trace = self.orig_trace.copy()
options = {'width': 60}
# filtering manual
self.filt_trace_data = signal.tauc(trace, **options)
# filtering real time
process_list = [('tauc', options)]
self._runRtProcess(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
self.assertAlmostEqual(peak, 114.302, 3)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_mwpIntegral(self):
"""
Testing mwpIntegral functions.
"""
trace = self.orig_trace.copy()
options = {'mem_time': 240,
'ref_time': trace.stats.starttime + 301.506,
'max_time': 120,
'gain': 1.610210e+09}
# filtering manual
self.filt_trace_data = signal.mwpIntegral(self.orig_trace.copy(),
**options)
# filtering real time
process_list = [('mwpIntegral', options)]
self._runRtProcess(process_list)
# check results
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_mwp(self):
"""
Testing Mwp calculation using two processing functions.
"""
trace = self.orig_trace.copy()
epicentral_distance = 30.0855
options = {'mem_time': 240,
'ref_time': trace.stats.starttime + 301.506,
'max_time': 120,
'gain': 1.610210e+09}
# filtering manual
trace.data = signal.integrate(trace)
self.filt_trace_data = signal.mwpIntegral(trace, **options)
# filtering real time
process_list = [('integrate', {}), ('mwpIntegral', options)]
self._runRtProcess(process_list)
# check results
peak = np.amax(np.abs(self.rt_trace.data))
mwp = signal.calculateMwpMag(peak, epicentral_distance)
self.assertAlmostEqual(mwp, 8.78902911791, 5)
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
def test_combined(self):
"""
Testing combining integrate and differentiate functions.
"""
trace = self.orig_trace.copy()
# filtering manual
trace.data = signal.integrate(trace)
self.filt_trace_data = signal.differentiate(trace)
# filtering real time
process_list = [('int', {}), ('diff', {})]
self._runRtProcess(process_list)
# check results
trace = self.orig_trace.copy()
np.testing.assert_almost_equal(self.filt_trace_data,
self.rt_trace.data)
np.testing.assert_almost_equal(trace.data[1:], self.rt_trace.data[1:])
np.testing.assert_almost_equal(trace.data[1:],
self.filt_trace_data[1:])
def _runRtProcess(self, process_list, max_length=None):
"""
Helper function to create a RtTrace, register all given process
functions and run the real time processing.
"""
# assemble real time trace
self.rt_trace = RtTrace(max_length=max_length)
for (process, options) in process_list:
self.rt_trace.register_rt_process(process, **options)
# append packet data to RtTrace
self.rt_appended_traces = []
for trace in self.orig_trace_chunks:
# process single trace
result = self.rt_trace.append(trace, gap_overlap_check=True)
# add to list of appended traces
self.rt_appended_traces.append(result)
def _plotResults(self):
"""
Plots original, filtered original and real time processed traces into
a single plot.
"""
# plot only if test is started manually
if __name__ != '__main__':
return
# create empty stream
st = Stream()
st.label = self._testMethodName
# original trace
self.orig_trace.label = "Original Trace"
st += self.orig_trace
# use header information of original trace with filtered trace data
tr = self.orig_trace.copy()
tr.data = self.filt_trace_data
tr.label = "Filtered original Trace"
st += tr
# real processed chunks
for i, tr in enumerate(self.rt_appended_traces):
tr.label = "RT Chunk %02d" % (i + 1)
st += tr
# real time processed trace
self.rt_trace.label = "RT Trace"
st += self.rt_trace
st.plot(automerge=False, color='blue', equal_scale=False)
