Beispiel #1
0
def normalize_signals(signals, normalization=None, axis=None, percent=None):
    # Following pylab demean:

    def matrix_subtract_along_axis(x, y, axis=0):
        "Return x minus y, where y corresponds to some statistic of x along the specified axis"
        if axis == 0 or axis is None or x.ndim <= 1:
            return x - y
        ind = [slice(None)] * x.ndim
        ind[axis] = np.newaxis
        return x - y[ind]

    def matrix_divide_along_axis(x, y, axis=0):
        "Return x divided by y, where y corresponds to some statistic of x along the specified axis"
        if axis == 0 or axis is None or x.ndim <= 1:
            return x / y
        ind = [slice(None)] * x.ndim
        ind[axis] = np.newaxis
        return x / y[ind]

    for norm, ax, prcnd in zip(ensure_list(normalization), cycle(ensure_list(axis)), cycle(ensure_list(percent))):
        if isinstance(norm, string_types):
            if isequal_string(norm, "zscore"):
                signals = zscore(signals, axis=ax)  # / 3.0
            elif isequal_string(norm, "baseline-std"):
                signals = normalize_signals(["baseline", "std"], axis=axis)
            elif norm.find("baseline") == 0 and norm.find("amplitude") >= 0:
                signals = normalize_signals(signals, ["baseline", norm.split("-")[1]], axis=axis, percent=percent)
            elif isequal_string(norm, "minmax"):
                signals = normalize_signals(signals, ["min", "max"], axis=axis)
            elif isequal_string(norm, "mean"):
                signals = demean(signals, axis=ax)
            elif isequal_string(norm, "baseline"):
                if prcnd is None:
                    prcnd = 1
                signals = matrix_subtract_along_axis(signals, np.percentile(signals, prcnd, axis=ax), axis=ax)
            elif isequal_string(norm, "min"):
                signals = matrix_subtract_along_axis(signals, np.min(signals, axis=ax), axis=ax)
            elif isequal_string(norm, "max"):
                signals = matrix_divide_along_axis(signals, np.max(signals, axis=ax), axis=ax)
            elif isequal_string(norm, "std"):
                signals = matrix_divide_along_axis(signals, signals.std(axis=ax), axis=ax)
            elif norm.find("amplitude") >= 0:
                if prcnd is None:
                    prcnd = [1, 99]
                amplitude = np.percentile(signals, prcnd[1], axis=ax) - np.percentile(signals, prcnd[0], axis=ax)
                this_ax = ax
                if isequal_string(norm.split("amplitude")[0], "max"):
                    amplitude = amplitude.max()
                    this_ax = None
                elif isequal_string(norm.split("amplitude")[0], "mean"):
                    amplitude = amplitude.mean()
                    this_ax = None
                signals = matrix_divide_along_axis(signals, amplitude, axis=this_ax)
            else:
                raise_value_error("Ignoring signals' normalization " + normalization +
                                  ",\nwhich is not one of the currently available " + str(NORMALIZATION_METHODS) + "!",
                                  logger)
    return signals
Beispiel #2
0
def noise_segmenting(poisson_times, st_event_2, st_t, noise_level, samp_rate, delta):
    """ Creates the noise array so that it is big enough to host all of the events. 
    Creating the noise by multiplying white noise by the seismic noise, in the frequency domain.
    We then inverse FFT it and scale it to whatever SNR level is defined to output the full
    noise array.
    """
    # end time for noise to cover all events
    noise_lim = (poisson_times[-1] + len(st_event_2)) *2    #gives some time after last event

    st_noise_start_t = UTCDateTime("2015-01-22T01:00:00")
    st_noise_end_t = UTCDateTime("2015-01-22T01:02:00")
    test_trace = st_t[0].slice(st_noise_start_t, st_noise_end_t)
    test_trace_length = int(len(test_trace) / test_trace.stats.sampling_rate)

    minutes_long = (noise_lim)/st_event_2.stats.sampling_rate
    noise_loops = int(np.ceil(minutes_long/2.0)) #working out how many 2 minute loops we need

    noise_array = np.zeros([noise_loops, len(test_trace)])

    for j in range(noise_loops):
        # we average the Tungurahua noise over twenty 2 minute demeaned samples
        tung_n_fft = np.zeros([20, int(np.ceil((len(test_trace)/2.0)))])
        for i in range(20):
            st_noise = st_t[0].slice(st_noise_start_t+
                                     (i*test_trace_length),
                                     st_noise_end_t+
                                     (i*test_trace_length))
            noise_detrended = st_noise.detrend()
            noise_demeaned = mlab.demean(noise_detrended)
            noise_averaging = Trace(noise_demeaned).normalize()
            tung_n_fft[i] = np.fft.rfft(noise_averaging.data)

        # work out the average fft
        ave = np.average(tung_n_fft, axis=0)
        # smooth the data
        aves = movingaverage(ave,20)

        whitenoise = np.random.normal(0, 1, len(noise_averaging))
        whitenoise_n = Trace(whitenoise).normalize()

        wn_n_fft = np.fft.rfft(whitenoise_n.data)

        newnoise_fft = wn_n_fft * aves

        newnoise = ifft(newnoise_fft, n = len(st_noise))
        
        noise_array[j] = np.real(newnoise)
    
    full_noise_array = np.ravel(noise_array)
    full_noise_array_n = Trace(np.float32(full_noise_array)).normalize()
    full_noise_array_n_scaled = Trace(np.multiply(full_noise_array_n, noise_level))
    full_noise_array_n_scaled.stats.sampling_rate = samp_rate
    full_noise_array_n_scaled.stats.delta = delta
    
    return full_noise_array_n_scaled
Beispiel #3
0
def create_noise_snr_data(st_noise_n_t, st_event_2, noise_lim, noise_steps):
    """
    Creates noise for SNR data based on the size and characteristics of the noise variable.
    Averages the noise from Tungurahua for 20 demeaned samples and smooths it.
    st_noise_n_t = Trace array for basing the noise on
    st_event_2 = Trace array for the signal (used in SNR calc)
    noise_lim = limit of noise multiplications
    noise_steps = steps for the noise_level
    
    snr_r contains the SNR array for then storing (which can then be loaded when doing the
    calculations instead of doing this each time). This allows for the SNR to be input when creating noise
    (noise_segmenting) rather than the noise_level.
    noise_levels contains the noise levels used to calculate the SNR.
    
    """
    st_noise_start_t = UTCDateTime("2015-01-22T01:00:00")
    st_noise_end_t = UTCDateTime("2015-01-22T01:02:00")
    test_trace = st_noise_n_t.slice(st_noise_start_t, st_noise_end_t)
    test_trace_n = test_trace.normalize()
    test_trace_length = int(len(test_trace) / test_trace.stats.sampling_rate)
    
    noise_levels = np.arange(0,noise_lim,noise_steps)
    snr_r = np.zeros(len(noise_levels))
    
    noise_averaging = np.zeros([20, len(test_trace)])
    tung_n_fft = np.zeros([20, int(np.ceil((len(test_trace)/2.0)))])
    pp = np.zeros([20, int(np.ceil((len(test_trace)/2.0)))])

    for j in range(0, len(noise_levels)):
        for i in range(20):
            st_noise = st_noise_n_t.slice(st_noise_start_t+
                                     (i*test_trace_length),
                                     st_noise_end_t+
                                     (i*test_trace_length))
            noise_detrended = st_noise.detrend()
            noise_demeaned = mlab.demean(noise_detrended)
            noise_averaging = Trace(noise_demeaned).normalize()
            tung_n_fft[i] = np.fft.rfft(noise_averaging.data)
            ff, pp[i] = periodogram(noise_averaging.data,100)

        # work out the average fft and periodogram signal
        ave = np.average(tung_n_fft, axis=0)
        ave_p = np.average(pp, axis=0)
        # smooth the data
        aves = movingaverage(ave,20)
        aves_p = movingaverage(ave_p,20)

        whitenoise = np.random.normal(0, 1, len(noise_averaging))
        whitenoise_n = Trace(whitenoise).normalize()

        wn_n_fft = np.fft.rfft(whitenoise_n.data)

        newnoise_fft = wn_n_fft * aves

        newnoise = ifft(newnoise_fft, n = len(st_noise))
        newnoise_n = (Trace(newnoise).normalize())
        newnoise_n_scaling = np.multiply(newnoise_n,noise_levels[j])

        snr_r[j] = snr_eventtonoise(st_event_2, newnoise_n_scaling)
    
    return snr_r, noise_levels
"""
为了兼容matlab创造的一个库
"""
from matplotlib import mlab
import numpy as np

# 实现去中心化
a = np.random.random((10, 3))
b = mlab.demean(a, axis=0)
print(a)
print('=' * 10)
print(b)
print('=' * 10)
print(a - np.tile(np.mean(a, axis=1), (3, 1)).reshape(a.shape))