analysis.spectral¶
Module: analysis.spectral
¶
Inheritance diagram for nitime.analysis.spectral
:

Classes¶
FilterAnalyzer
¶
- class nitime.analysis.spectral.FilterAnalyzer(time_series, lb=0, ub=None, boxcar_iterations=2, filt_order=64, gpass=1, gstop=60, iir_ftype='ellip', fir_win='hamming')¶
Bases:
ResetMixin
A class for performing filtering operations on time-series and producing the filtered versions of the time-series
- Parameters
time_series: A nitime TimeSeries object. :
lb,ub: float (optional) :
Lower and upper band of a pass-band into which the data will be filtered. Default: 0, Nyquist
boxcar_iterations: int (optional) :
For box-car filtering, how many times to iterate over the data while convolving with a box-car function. Default: 2
gpass: float (optional) :
For iir filtering, the pass-band maximal ripple loss (default: 1)
gstop: float (optional) :
For iir filtering, the stop-band minimal attenuation (default: 60).
filt_order: int (optional) :
For iir/fir filtering, the order of the filter. Note for fir filtering, this needs to be an even number. Default: 64
iir_ftype: str (optional) :
The type of filter to be used in iir filtering (see scipy.signal.iirdesign for details). Default ‘ellip’
fir_win: str :
The window to be used in fir filtering (see scipy.signal.firwin for details). Default: ‘hamming’
- __init__(time_series, lb=0, ub=None, boxcar_iterations=2, filt_order=64, gpass=1, gstop=60, iir_ftype='ellip', fir_win='hamming')¶
- filtered_boxcar()¶
Filter the time-series by a boxcar filter.
The low pass filter is implemented by convolving with a boxcar function of the right length and amplitude and the high-pass filter is implemented by subtracting a low-pass version (as above) from the signal
- filtered_fourier()¶
Filter the time-series by passing it to the Fourier domain and null out the frequency bands outside of the range [lb,ub]
- filtfilt(b, a, in_ts=None)¶
Zero-phase delay filtering (either iir or fir).
- Parameters
a,b: filter coefficients :
in_ts: time-series object. :
This allows to replace the input. Instead of analyzing this analyzers input data, analyze some other time-series object
- fir()¶
Filter the time-series using an FIR digital filter. Filtering is done back and forth (using scipy.signal.filtfilt) to achieve zero phase delay
- iir()¶
Filter the time-series using an IIR filter. Filtering is done back and forth (using scipy.signal.filtfilt) to achieve zero phase delay
HilbertAnalyzer
¶
- class nitime.analysis.spectral.HilbertAnalyzer(input=None)¶
Bases:
BaseAnalyzer
Analyzer class for extracting the Hilbert transform
- __init__(input=None)¶
Constructor function for the Hilbert analyzer class.
- Parameters
input: TimeSeries :
- amplitude()¶
- analytic()¶
The natural output for this analyzer is the analytic signal
- imag()¶
- phase()¶
- real()¶
MorletWaveletAnalyzer
¶
- class nitime.analysis.spectral.MorletWaveletAnalyzer(input=None, freqs=None, sd_rel=0.2, sd=None, f_min=None, f_max=None, nfreqs=None, log_spacing=False, log_morlet=False)¶
Bases:
BaseAnalyzer
Analyzer class for extracting the (complex) Morlet wavelet transform
- __init__(input=None, freqs=None, sd_rel=0.2, sd=None, f_min=None, f_max=None, nfreqs=None, log_spacing=False, log_morlet=False)¶
Constructor function for the Wavelet analyzer class.
- Parameters
freqs: list or float :
List of center frequencies for the wavelet transform, or a scalar for a single band-passed signal.
sd: list or float :
List of filter bandwidths, given as standard-deviation of center frequencies. Alternatively sd_rel can be specified.
sd_rel: float :
Filter bandwidth, given as a fraction of the center frequencies.
f_min: float :
Minimal frequency.
f_max: float :
Maximal frequency.
nfreqs: int :
Number of frequencies.
log_spacing: bool :
If true, frequencies will be evenly spaced on a log-scale. Default: False
log_morlet: bool :
If True, a log-Morlet wavelet is used, if False, a regular Morlet wavelet is used. Default: False
- amplitude()¶
- analytic()¶
The natural output for this analyzer is the analytic signal
- imag()¶
- phase()¶
- real()¶
SpectralAnalyzer
¶
- class nitime.analysis.spectral.SpectralAnalyzer(input=None, method=None, BW=None, adaptive=False, low_bias=False)¶
Bases:
BaseAnalyzer
Analyzer object for spectral analysis
- __init__(input=None, method=None, BW=None, adaptive=False, low_bias=False)¶
The initialization of the
- Parameters
input: time-series objects :
method: dict (optional), :
The method spec used in calculating ‘psd’ see
algorithms.get_spectra()
for details.BW: float (optional), :
In ‘spectrum_multi_taper’ The bandwidth of the windowing function will determine the number tapers to use. This parameters represents trade-off between frequency resolution (lower main lobe BW for the taper) and variance reduction (higher BW and number of averaged estimates).
adaptive : {True/False}
In ‘spectrum_multi_taper’, use an adaptive weighting routine to combine the PSD estimates of different tapers.
low_bias: {True/False} :
In spectrum_multi_taper, use bias correction
Examples
>>> np.set_printoptions(precision=4) # for doctesting >>> t1 = ts.TimeSeries(data = np.arange(0,1024,1).reshape(2,512), ... sampling_rate=np.pi) >>> s1 = SpectralAnalyzer(t1) >>> s1.method['this_method'] 'welch' >>> s1.method['Fs'] 3.1415926535... Hz >>> f,s = s1.psd >>> f array([ 0. , 0.0491, 0.0982, 0.1473, 0.1963, 0.2454, 0.2945, 0.3436, 0.3927, 0.4418, 0.4909, 0.54 , 0.589 , 0.6381, 0.6872, 0.7363, 0.7854, 0.8345, 0.8836, 0.9327, 0.9817, 1.0308, 1.0799, 1.129 , 1.1781, 1.2272, 1.2763, 1.3254, 1.3744, 1.4235, 1.4726, 1.5217, 1.5708]) >>> s[0,0] 1128276.92538360...
- cpsd()¶
This outputs both the PSD and the CSD calculated using
algorithms.get_spectra()
.- Returns
(f,s): tuple :
f: Frequency bands over which the psd/csd are calculated and s: the n by n by len(f) matrix of PSD (on the main diagonal) and CSD (off diagonal)
- periodogram()¶
This is the spectrum estimated as the FFT of the time-series
- Returns
(f,spectrum): f is an array with the frequencies and spectrum is the :
complex-valued FFT. :
- psd()¶
The standard output for this analyzer is a tuple f,s, where: f is the frequency bands associated with the discrete spectral components and s is the PSD calculated using
mlab.psd()
.
- spectrum_fourier()¶
This is the spectrum estimated as the FFT of the time-series
- Returns
(f,spectrum): f is an array with the frequencies and spectrum is the :
complex-valued FFT. :