# 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

        >>> 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.9253836009

  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. :

  spectrum_multi_taper()

    The spectrum and cross-spectra, computed using :func:`multi_taper_csd’