在傅里叶或时域中集成

Question

我很难理解信号数值积分的问题。基本上我有一个信号，我想整合或执行和antiderivative作为时间的函数（拾取线圈的集成获得磁场）。我尝试了两种不同的方法，原则上应该是一致的，但事实并非如此。我正在使用的代码如下。请注意，代码中的信号y先前已使用butterworth过滤进行高通滤波（类似于此处http://wiki.scipy.org/Cookbook/ButterworthBandpass所做的那样）。信号和时间基础可以在这里下载（https://www.dropbox.com/s/fi5z38sae6j5410/trial.npz?dl=0）

import scipy as sp
from scipy import integrate
from scipy import fftpack
data = np.load('trial.npz')
y = data['arr_1'] # this is the signal 
t = data['arr_0']
# integration using pfft
bI = sp.fftpack.diff(y-y.mean(),order=-1)
bI2= sp.integrate.cumtrapz(y-y.mean(),x=t)

现在两个信号（除了可以取出的最终不同的线性趋势）是不同的，或者更好的动态它们与振荡的相同时间非常相似但是在两个信号之间存在大约30的因子， bI2比bI低30倍（大约）的感觉。顺便说一句，我已经减去两个信号中的均值，以确保它们是零均值信号，并在IDL中执行积分（两者都具有等效的cumsumtrapz和傅里叶域），给出了与bI2兼容的值。任何线索都非常受欢迎

Answer 1

很难知道scipy.fftpack.diff()在发动机罩下做了什么。

为了尝试解决您的问题，我已经挖出了我之前写过的旧频域集成功能。值得指出的是，在实践中，人们通常希望对scipy.fftpack.diff()给你的一些参数进行更多的控制。例如，f_lo函数的f_hi和intf()参数允许您对输入进行频段限制，以排除可能有噪音的极低或极高频率。嘈杂的低频尤其可能会导致爆炸。在整合期间和压倒信号。您可能还想在时间序列的开头和结尾使用一个窗口来阻止频谱泄漏。

我已使用以下代码计算bI2以及结果bI3与intf()集成一次（为简单起见，我假设平均采样率）：

import intf
from scipy import integrate
data = np.load(path)
y = data['arr_1']
t = data['arr_0']

bI2= sp.integrate.cumtrapz(y-y.mean(),x=t)
bI3 = intf.intf(y-y.mean(), fs=500458, f_lo=1, winlen=1e-2, times=1)

我绘制了bI2和bI3：

两个时间序列具有相同的数量级，并且具有大致相同的形状，尽管bI2中存在明显的分段线性趋势。我知道这并不能解释scipy函数中发生了什么，但至少这表明它不是频域方法的问题。

intf的代码全部粘贴在下面。

def intf(a, fs, f_lo=0.0, f_hi=1.0e12, times=1, winlen=1, unwin=False):
"""
Numerically integrate a time series in the frequency domain.

This function integrates a time series in the frequency domain using
'Omega Arithmetic', over a defined frequency band.

Parameters
----------
a : array_like
    Input time series.
fs : int
    Sampling rate (Hz) of the input time series.
f_lo : float, optional
    Lower frequency bound over which integration takes place.
    Defaults to 0 Hz.
f_hi : float, optional
    Upper frequency bound over which integration takes place.
    Defaults to the Nyquist frequency ( = fs / 2).
times : int, optional
    Number of times to integrate input time series a. Can be either 
    0, 1 or 2. If 0 is used, function effectively applies a 'brick wall' 
    frequency domain filter to a.
    Defaults to 1.
winlen : int, optional
    Number of seconds at the beginning and end of a file to apply half a 
    Hanning window to. Limited to half the record length.
    Defaults to 1 second.
unwin : Boolean, optional
    Whether or not to remove the window applied to the input time series
    from the output time series.

Returns
-------
out : complex ndarray
    The zero-, single- or double-integrated acceleration time series.

Versions
----------
1.1 First development version. 
    Uses rfft to avoid complex return values.
    Checks for even length time series; if not, end-pad with single zero.
1.2 Zero-means time series to avoid spurious errors when applying Hanning
    window.

"""

a = a - a.mean()                        # Convert time series to zero-mean
if np.mod(a.size,2) != 0:               # Check for even length time series
    odd = True
    a = np.append(a, 0)                 # If not, append zero to array
else:
    odd = False
f_hi = min(fs/2, f_hi)                  # Upper frequency limited to Nyquist
winlen = min(a.size/2, winlen)          # Limit window to half record length

ni = a.size                             # No. of points in data (int) 
nf = float(ni)                          # No. of points in data (float)
fs = float(fs)                          # Sampling rate (Hz)
df = fs/nf                              # Frequency increment in FFT
stf_i = int(f_lo/df)                    # Index of lower frequency bound
enf_i = int(f_hi/df)                    # Index of upper frequency bound

window = np.ones(ni)                    # Create window function
es = int(winlen*fs)                     # No. of samples to window from ends
edge_win = np.hanning(es)               # Hanning window edge 
window[:es/2] = edge_win[:es/2]
window[-es/2:] = edge_win[-es/2:]
a_w = a*window

FFTspec_a = np.fft.rfft(a_w)            # Calculate complex FFT of input
FFTfreq = np.fft.fftfreq(ni, d=1/fs)[:ni/2+1]

w = (2*np.pi*FFTfreq)                   # Omega
iw = (0+1j)*w                           # i*Omega

mask = np.zeros(ni/2+1)                 # Half-length mask for +ve freqs
mask[stf_i:enf_i] = 1.0                 # Mask = 1 for desired +ve freqs

if times == 2:                          # Double integration
    FFTspec = -FFTspec_a*w / (w+EPS)**3
elif times == 1:                        # Single integration
    FFTspec = FFTspec_a*iw / (iw+EPS)**2
elif times == 0:                        # No integration
    FFTspec = FFTspec_a
else:
    print 'Error'

FFTspec *= mask                         # Select frequencies to use

out_w = np.fft.irfft(FFTspec)           # Return to time domain

if unwin == True:
    out = out_w*window/(window+EPS)**2  # Remove window from time series
else:
    out = out_w

if odd == True:                         # Check for even length time series
    return out[:-1]                     # If not, remove last entry
else:        
    return out