def test_symmetric_output(self):
converter = XArrayConverter()
signal_length = 1000
sampling_rate = 20.0
center_index = int(signal_length * sampling_rate) // 2
stream = create_sinsoidal_trace(sampling_rate=sampling_rate,
duration=signal_length,
period=2)
stream1 = create_sinsoidal_trace(sampling_rate=sampling_rate,
duration=signal_length,
period=0.5)
stream[0].data += stream1[0].data
stream[0].data += np.random.uniform(-0.01, 0.01, stream[0].data.shape)
converter = XArrayConverter()
xarray = converter(stream)
center = True
whitening_op = XArrayWhiten(taper=0.1,
window=0.05,
whiten_type='cross_component',
freqmax=20.0,
freqmin=0.01,
center=center,
order=2)
whitened_array = whitening_op(xarray)
xarray_squeezed = whitened_array[0, 0, :].data.squeeze()
difference = xarray_squeezed[:center_index] - xarray_squeezed[
-center_index:]
cumdiff = abs(
np.cumsum(difference)[-1] / (signal_length * sampling_rate))
assert pytest.approx(0, abs=1e-4) == cumdiff
def test_symmetric_output(self):
converter = XArrayConverter()
signal_length = 1000
sampling_rate = 20.0
center_index = int(signal_length * sampling_rate) // 2
stream = create_sinsoidal_trace(sampling_rate=sampling_rate,
duration=signal_length,
period=2)
stream1 = create_sinsoidal_trace(sampling_rate=sampling_rate,
duration=signal_length,
period=0.5)
stream[0].data += stream1[0].data
xarray = converter(stream)
t_norm_op = XArrayTemporalNorm(t_norm_type='reduce_metric',
taper=0.1,
freqmin=0.02,
freqmax=3.0,
window=5.0,
rolling_procedure='mean',
reduce_metric='max')
t_normed_array = t_norm_op(xarray)
xarray_squeezed = t_normed_array[0, 0, :].data.squeeze()
difference = xarray_squeezed[:center_index] - xarray_squeezed[
-center_index:]
cumdiff = abs(
np.cumsum(difference)[-1] / (signal_length * sampling_rate))
assert pytest.approx(0, abs=1e-2) == cumdiff
def test_whitened_success(self):
trace = convert(create_sinsoidal_trace(sampling_rate=100,period=0.5, duration=3))
freq_2 = convert(create_sinsoidal_trace(sampling_rate=100, period=0.1, duration=3))
target_trace = trace + freq_2
target_trace.attrs = freq_2.attrs
target = self.get_power_at_freq(6.0,target_trace)
source_trace = whiten(target_trace,starttime=0,station=0)
source = self.get_power_at_freq(6.0, source_trace)
assert target < source,"whitening failed"
def test_array_is_real(self):
tr_1 = create_sinsoidal_trace(sampling_rate=100, period=0.5, duration=3)
tr_2 = create_sinsoidal_trace(sampling_rate=100, period=0.1, duration=3)
st1 = Stream(traces=[*tr_1,*tr_2])
st2 = Stream(traces=[*tr_2, *tr_2])
trace = convert(st1)
freq_2 = convert(st2)
trace = trace + freq_2
trace.attrs = freq_2.attrs
trace = whiten(trace)
assert trace.data.dtype == np.float64,'improper data type'
def test_bandpass_zero_phase(self):
stream = synthfactory.create_sinsoidal_trace(sampling_rate=40.0,
duration=1000.0,
period=0.3)
xarray = convert(stream)
filtered_array = xr.apply_ufunc(filt_ops.taper_func,
xarray,
input_core_dims=[['time']],
output_core_dims=[['time']],
kwargs={'taper': 0.01},
keep_attrs=True)
filtered_array = xr.apply_ufunc(filt_ops.bandpass_in_time_domain_sos,
filtered_array,
input_core_dims=[['time']],
output_core_dims=[['time']],
kwargs={
'sample_rate': 40.0,
'freqmax': 5.0,
'freqmin': 0.01
},
keep_attrs=True)
a = xarray.data[0, 0, :]
b = filtered_array.data[0, 0, :]
xcorr = correlate(a, b)
# delta time array to match xcorr
dt = np.arange(1 - a.shape[-1], a.shape[-1])
recovered_time_shift = dt[xcorr.argmax()]
assert recovered_time_shift == 0
def test_phase_shift(self):
stream = create_sinsoidal_trace(sampling_rate=40.0,
duration=1000.0,
period=20)
stream[0].data += np.random.uniform(-0.01, 0.01, stream[0].data.shape)
converter = XArrayConverter()
xarray = converter(stream)
taper = 0.1
center = False
ratio = 0.01
whitening_op = XArrayWhiten(taper=0.1,
window=0.05,
whiten_type='cross_component',
freqmax=20.0,
freqmin=0.01,
center=center,
order=2)
whitened_array = whitening_op(xarray)
a = whitened_array.data[0, 0, :].squeeze()
b = xarray.data[0, 0, :].squeeze()
xcorr = correlate(a, b)
# delta time array to match xcorr
dt = np.arange(1 - a.shape[-1], a.shape[-1])
recovered_time_shift = dt[xcorr.argmax()]
assert recovered_time_shift == 0
def test_phase_shift_not_introduced(self):
target_rate = 20
process = XArrayResample(target_rate=target_rate)
trace_initial = converter(
create_sinsoidal_trace(sampling_rate=100, period=0.5,
duration=0.5))
trace_processed = converter(
create_sinsoidal_trace(sampling_rate=100, period=0.5,
duration=0.5))
trace_processed = process(trace_processed)
target = np.argmax(
trace_initial.data.ravel()) * trace_initial.attrs['delta']
source = np.argmax(
trace_processed.data.ravel()) * trace_processed.attrs['delta']
assert round(abs(target - source), int(np.log10(
1 / target_rate))) == 0, "filter introduced phase shift"
def test_into_freq_and_back(self):
stream = synthfactory.create_sinsoidal_trace(duration=3)
target_xarray = convert(stream)
xarray_freq = filt_ops.xarray_time_2_freq(target_xarray.copy())
source_xarray = filt_ops.xarray_freq_2_time(xarray_freq,
target_xarray.copy())
np.testing.assert_allclose(source_xarray.data,
target_xarray.data,
atol=1e-15)
def test_phase_shift_not_introduced(self):
process = XArrayBandpass(freqmin=0.5, freqmax=20.0)
trace_initial = converter(
create_sinsoidal_trace(sampling_rate=100, period=0.25,
duration=10))
trace_processed = process(trace_initial.copy(), starttime=0, station=0)
source_1 = np.argmax(
signal.correlate(trace_initial.data, trace_processed.data))
correction = source_1 - (trace_initial.data.shape[2] * 2 - 1) // 2
target = 0
assert correction == target, "filter introduced phase shift"
def test_crosscorrelate_phase_shift(self):
stream1 = synthfactory.create_sinsoidal_trace(sampling_rate=10.0,
duration=60.1,
period=15)
xarray_src = convert(stream1)
xarray_rec = convert(stream1)
xarray_corr = npfilt_ops.xarray_crosscorrelate(xarray_src, xarray_rec)
xcorr_data = xarray_corr.data.squeeze()
dt1 = np.arange(-xcorr_data.shape[-1] // 2 + 1,
xcorr_data.shape[-1] // 2)
assert dt1[xcorr_data.argmax()] == 0
def test_phase_shift(self):
stream = create_sinsoidal_trace(sampling_rate=40.0, duration = 2000.0,
period=0.3)
converter = XArrayConverter()
xarray = converter(stream)
t_norm_op = XArrayTemporalNorm(t_norm_type='reduce_metric',
lower_frequency=0.001, upper_frequency=4,
time_window=2.0, rolling_procedure='mean',
reduce_metric='max')
whitened_array = t_norm_op(xarray)
a = whitened_array.data[0,0,:].squeeze()
b = xarray.data[0,0,:].squeeze()
xcorr = correlate(a, b)
dt = np.arange(1 - a.shape[-1], a.shape[-1])
recovered_time_shift = dt[xcorr.argmax()]
assert recovered_time_shift==0
