def kaiser_windows_filter(tr, isotr, periods, window=('kaiser', 9.0), deltaT=PERIOD_RESAMPLE, debug=False): """ Apply FIR filter with kaiser window :type tr: `obspy.trace` :param tr: trace contains raw waveform :type isotr: numpy matrix :param isotr: matrix contains isolated waveform :type periods: numpy array :param periods: contains various periods :type window: tuple :param window: window for setting kaiser filter :type deltaT: int or float :param deltaT: time interval """ conv_result = np.zeros(shape=(len(periods), len(tr.data))) nyq = tr.stats.sampling_rate / 2.0 ntaps = 2**math.ceil(math.log(tr.stats.sac.npts, 2)) if debug: print(nyq, ntaps) for iperiod, T0 in enumerate(periods): lowcut = 1.0 / (T0 + 0.2 * deltaT / 2.0) highcut = 1.0 / (T0 - 0.2 * deltaT / 2.0) width = (highcut - lowcut) / 2.0 window = firwin(ntaps, [lowcut, highcut], width=width, window=window, nyq=nyq, pass_zero=False) conv_result[iperiod, :] = sig_convolve(isotr[iperiod, :], window, mode='same') logger.info("Kaiser window filter applied Suc.!") return conv_result
freq_signal_4096 = np.linspace(-np.pi, np.pi, len(signal1_Response_4096)) from scipy import signal from scipy.signal import convolve as sig_convolve ## create window # SIZE OF WINDOW IS IMPORTANT window_Beta0_L64 = signal.kaiser(64, beta=0) window_Beta0_L64_Response = getFFT(window_Beta0_L64) window_Beta0_L64_Response_4096 = getFFT(window_Beta0_L64) freq_win = np.linspace(-np.pi, np.pi, len(window_Beta0_L64_Response)) ## convolve in freq domain the fft of the signal and fft of the window # 2048 conv1_L64 = sig_convolve(signal1_Response_2048, window_Beta0_L64_Response) conv2_L64 = sig_convolve(signal2_Response_2048, window_Beta0_L64_Response) freq_conv_L64 = np.linspace(-np.pi, np.pi, len(conv1_L64)) #4096 conv1_L64_4096 = sig_convolve(signal1_Response_4096, window_Beta0_L64_Response_4096) conv2_L64_4096 = sig_convolve(signal2_Response_4096, window_Beta0_L64_Response_4096) freq_conv_L64_4096 = np.linspace(-np.pi, np.pi, len(conv1_L64_4096)) ## Plots # FFT of input signal plt.figure(1) plt.title('Input Signal: FFT') plt.xlabel('omega')
fftconv_time = [] conv1d_time = [] lfilt_time = [] diff_list = [] diff2_list = [] diff3_list = [] ntaps_list = 2**np.arange(2, 14) for ntaps in ntaps_list: # Create a FIR filter. b = firwin(ntaps, [0.05, 0.95], width=0.05, pass_zero=False) # Signal convolve. tstart = time.time() conv_result = sig_convolve(x, b[np.newaxis, :], mode="valid") conv_time.append(time.time() - tstart) # --- numpy.convolve --- tstart = time.time() npconv_result = np.array([np_convolve(xi, b, mode="valid") for xi in x]) npconv_time.append(time.time() - tstart) # fft convolve (fast fourier transform) convolution. tstart = time.time() fftconv_result = fftconvolve(x, b[np.newaxis, :], mode="valid") fftconv_time.append(time.time() - tstart) # 1-dimensional (one-dimensional) convolution. tstart = time.time() # convolve1d doesn"t have a "valid" mode, so we expliclity slice out # the valid part of the result. conv1d_result = convolve1d(x, b)[:, (len(b) - 1) // 2:-(len(b) // 2)] conv1d_time.append(time.time() - tstart)
[dpass, dstop], Hz=1.0) bands *= 2.0 # above function outputs frequencies normalized from 0.0 to 0.5 # use this tool to design a Parks-McClellan lowpass filter using pre-specified design parameters b = scipy.signal.remez(numtaps, bands, amps, weights, Hz=2.0) # FREQUENCY DOMAIN # Frequency Response of filter w_axis, h = scipy.signal.freqz(b) # compute frequency domain convolutions fftconv_result = fftconvolve(signal, b, mode='full') # TIME DOMAIN # compute time domain convolution conv_result = sig_convolve(signal, b, mode='full') ### TIME DOMAIN PLOTS # Plots input signal plt.figure(1) #plt.plot(t[:400], signal[:400], 'b'); plt.plot(t, signal, 'b') plt.title('Input Signal') plt.xlabel('Time') plt.ylabel('Amplitude') plt.ylim(min(signal), max(signal)) plt.show() ## Filter Plots # plot impulse response of filter plt.figure(2)
diff_list = [] diff2_list = [] diff3_list = [] ntaps_list = 2 ** np.arange(2, 13) for ntaps in ntaps_list: # Create a FIR filter. b = firwin(ntaps, [0.05, 0.95], width=0.05, pass_zero=False) if ntaps <= 2 ** 9: # --- signal.convolve --- # We know this is slower than the others when ntaps is # large, so we only compute it for small values. tstart = time.time() conv_result = sig_convolve(x, b[np.newaxis, :], mode='valid') conv_time.append(time.time() - tstart) # --- numpy.convolve --- tstart = time.time() npconv_result = np.array([np_convolve(xi, b, mode='valid') for xi in x]) npconv_time.append(time.time() - tstart) # --- signal.fftconvolve --- tstart = time.time() fftconv_result = fftconvolve(x, b[np.newaxis, :], mode='valid') fftconv_time.append(time.time() - tstart) # --- convolve1d --- tstart = time.time() # convolve1d doesn't have a 'valid' mode, so we expliclity slice out
def gen_convolve_scipy (input, kernel, output=None, accumulate=False): y = sig_convolve (input, kernel, 'valid') if output is None: output = y elif accumulate: output += y else: output[:] = y return output