Python RtTrace.append方法代码示例

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_gaussian_filter(self):
        from am_signal import gaussian_filter

        data_trace = self.data_trace.copy()
        gauss5,tshift = gaussian_filter(1.0, 5.0, 0.01)

        rt_trace=RtTrace()
        rt_single=RtTrace()
        for rtt in [rt_trace, rt_single]:
            rtt.registerRtProcess('convolve',conv_signal=gauss5)

        rt_single.append(data_trace, gap_overlap_check = True)

        for tr in self.traces:
            # pre-apply inversed time-shift before appending data
            tr.stats.starttime -= tshift
            rt_trace.append(tr, gap_overlap_check = True)

        # test the waveforms are the same
        diff=self.data_trace.copy()
        diff.data=rt_trace.data-rt_single.data
        self.assertAlmostEquals(np.mean(np.abs(diff)),0.0)
        # test the time-shifts
        starttime_diff=rt_single.stats.starttime-self.data_trace.stats.starttime
        self.assertAlmostEquals(starttime_diff,0.0)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_kurt_grad(self):
        win=3.0 
        data_trace = self.data_trace.copy()

        sigma=float(np.std(data_trace.data))
        fact = 1/sigma

        rt_trace=RtTrace()
        rt_trace_single = RtTrace()

        for rtt in [rt_trace, rt_trace_single]:
            rtt.registerRtProcess('scale',factor=fact)
            rtt.registerRtProcess('kurtosis',win=win)
            rtt.registerRtProcess('boxcar',width=50)
            rtt.registerRtProcess('differentiate')
            rtt.registerRtProcess('neg_to_zero')

        rt_trace_single.append(data_trace)
        
        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)

        diff=self.data_trace.copy()
        diff.data=rt_trace_single.data - rt_trace.data
        self.assertAlmostEquals(np.mean(np.abs(diff)), 0.0, 5)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
 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)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
 def test_appendSanityChecks(self):
     """
     Testing sanity checks of append method.
     """
     rtr = RtTrace()
     ftr = Trace(data=np.array([0, 1]))
     # sanity checks need something already appended
     rtr.append(ftr)
     # 1 - differing ID
     tr = Trace(header={'network': 'xyz'})
     self.assertRaises(TypeError, rtr.append, tr)
     tr = Trace(header={'station': 'xyz'})
     self.assertRaises(TypeError, rtr.append, tr)
     tr = Trace(header={'location': 'xy'})
     self.assertRaises(TypeError, rtr.append, tr)
     tr = Trace(header={'channel': 'xyz'})
     self.assertRaises(TypeError, rtr.append, tr)
     # 2 - sample rate
     tr = Trace(header={'sampling_rate': 100.0})
     self.assertRaises(TypeError, rtr.append, tr)
     tr = Trace(header={'delta': 0.25})
     self.assertRaises(TypeError, rtr.append, tr)
     # 3 - calibration factor
     tr = Trace(header={'calib': 100.0})
     self.assertRaises(TypeError, rtr.append, tr)
     # 4 - data type
     tr = Trace(data=np.array([0.0, 1.1]))
     self.assertRaises(TypeError, rtr.append, tr)
     # 5 - only Trace objects are allowed
     self.assertRaises(TypeError, rtr.append, 1)
     self.assertRaises(TypeError, rtr.append, "2323")

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
 def test_appendNotFloat32(self):
     """
     Test for not using float32.
     """
     tr = read()[0]
     tr.data = np.require(tr.data, dtype=native_str('>f4'))
     traces = tr / 3
     rtr = RtTrace()
     for trace in traces:
         rtr.append(trace)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
 def test_appendOverlap(self):
     """
     Appending overlapping traces should raise a UserWarning/TypeError
     """
     rtr = RtTrace()
     tr = Trace(data=np.array([0, 1]))
     rtr.append(tr)
     # this raises UserWarning
     with warnings.catch_warnings(record=True):
         warnings.simplefilter('error', UserWarning)
         self.assertRaises(UserWarning, rtr.append, tr)
     # append with gap_overlap_check=True will raise a TypeError
     self.assertRaises(TypeError, rtr.append, tr, gap_overlap_check=True)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_offset(self):

        offset=500

        rt_trace=RtTrace()
        rt_trace.registerRtProcess('offset',offset=offset)

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)


        diff=self.data_trace.copy()
        diff.data=rt_trace.data-self.data_trace.data
        self.assertAlmostEquals(np.mean(np.abs(diff)),offset)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_neg_to_zero(self):

        data_trace=self.data_trace.copy()
        max_val=np.max(data_trace.data)
        
        rt_trace=RtTrace()
        rt_trace.registerRtProcess('neg_to_zero')

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)

        max_val_test=np.max(rt_trace.data)
        min_val_test=np.min(rt_trace.data)
        self.assertEqual(max_val, max_val_test)
        self.assertEqual(0.0, min_val_test)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
 def test_appendGap(self):
     """
     Appending a traces with a time gap should raise a UserWarning/TypeError
     """
     rtr = RtTrace()
     tr = Trace(data=np.array([0, 1]))
     tr2 = Trace(data=np.array([5, 6]))
     tr2.stats.starttime = tr.stats.starttime + 10
     rtr.append(tr)
     # this raises UserWarning
     with warnings.catch_warnings(record=True):
         warnings.simplefilter('error', UserWarning)
         self.assertRaises(UserWarning, rtr.append, tr2)
     # append with gap_overlap_check=True will raise a TypeError
     self.assertRaises(TypeError, rtr.append, tr2, gap_overlap_check=True)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_variance(self):


        win=10

        data_trace=self.data_trace.copy()

        rt_single=RtTrace()
        rt_trace=RtTrace()
        rt_trace.registerRtProcess('variance',win=win)
        rt_single.registerRtProcess('variance',win=win)

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)
        rt_single.append(data_trace, gap_overlap_check = True)

        assert_array_almost_equal(rt_single, rt_trace)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_scale(self):

        data_trace = self.data_trace.copy()

        fact=1/np.std(data_trace.data)

        data_trace.data *= fact

        rt_trace=RtTrace()
        rt_trace.registerRtProcess('scale',factor=fact)

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)

        diff=self.data_trace.copy()
        diff.data=rt_trace.data-data_trace.data
        self.assertAlmostEquals(np.mean(np.abs(diff)),0.0)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_sw_kurtosis(self):
        win=3.0

        data_trace = self.data_trace.copy()

        rt_trace=RtTrace()
        rt_single=RtTrace()

        rt_trace.registerRtProcess('sw_kurtosis',win=win)
        rt_single.registerRtProcess('sw_kurtosis',win=win)

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)
        rt_single.append(data_trace)
   
        diff=self.data_trace.copy()
        diff.data=rt_trace.data-rt_single.data
        self.assertAlmostEquals(np.mean(np.abs(diff)),0.0)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_mean(self):

        win=0.05

        data_trace=self.data_trace.copy()

        rt_single=RtTrace()
        rt_trace=RtTrace()
        rt_trace.registerRtProcess('mean',win=win)
        rt_single.registerRtProcess('mean',win=win)

        for tr in self.traces:
            rt_trace.append(tr, gap_overlap_check = True)
        rt_single.append(data_trace, gap_overlap_check = True)

        newtr=self.data_trace.copy()
        newtr.data=newtr.data-rt_trace.data
        assert_array_almost_equal(rt_single, rt_trace)
        self.assertAlmostEqual(np.mean(newtr.data),0.0,0)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_kwin_bank(self):
        win_list=[1.0, 3.0, 9.0] 
        n_win = len(win_list)

        data_trace = self.data_trace.copy()

        sigma=float(np.std(data_trace.data))
        fact = 1/sigma

        # One RtTrace for processing before the kurtosis
        rt_trace=RtTrace()
        rt_trace.registerRtProcess('scale',factor=fact)

        # One RtTrace per kurtosis window
        kurt_traces=[]
        for i in xrange(n_win):
            rtt=RtTrace()
            rtt.registerRtProcess('kurtosis',win=win_list[i])
            kurt_traces.append(rtt)

        # One RrTrace for post-processing the max kurtosis window
        max_kurt=RtTrace()
        max_kurt.registerRtProcess('differentiate')
        max_kurt.registerRtProcess('neg_to_zero')

        for tr in self.traces:
            # prepare memory for kurtosis
            kurt_tr=tr.copy() 
            # do initial processing
            proc_trace=rt_trace.append(tr, gap_overlap_check = True)
            kurt_output=[]
            for i in xrange(n_win):
                # pass output of initial processing to the kwin bank
                ko=kurt_traces[i].append(proc_trace, gap_overlap_check = True)
                # append the output to the kurt_output list
                kurt_output.append(ko.data)
            # stack the output of the kwin bank and find maximum
            kurt_stack=np.vstack(tuple(kurt_output))
            kurt_tr.data=np.max(kurt_stack,axis=0)
            # append to the max_kurt RtTrace for post-processing
            max_kurt.append(kurt_tr)

# 需要导入模块: from obspy.realtime import RtTrace [as 别名]
# 或者: from obspy.realtime.RtTrace import append [as 别名]
    def test_rt_kurtosis_dec(self):

        win=5.0

        data_trace=self.data_trace_filt.copy()
        data_trace_dec=self.data_trace_filt.copy()
        # no need to filter as we're using a pre-filtered trace
        data_trace_dec.decimate(5,no_filter=True)


        rt_trace=RtTrace()
        rt_dec=RtTrace()
        rt_trace.registerRtProcess('kurtosis',win=win)
        rt_dec.registerRtProcess('kurtosis',win=win)

        rt_trace.append(data_trace, gap_overlap_check = True)
        rt_dec.append(data_trace_dec, gap_overlap_check = True)

        newtr=rt_trace.copy()
        newtr.decimate(5, no_filter=True)

        #assert_array_almost_equal(rt_dec.data, newtr.data, 0)
        diff=(np.max(rt_dec.data)-np.max(newtr.data)) / np.max(rt_dec.data)
        self.assertAlmostEquals(np.abs(diff) , 0.0, 2)