mne.filter.create_filter

mne.filter.create_filter(data, sfreq, l_freq, h_freq, filter_length=’auto’, l_trans_bandwidth=’auto’, h_trans_bandwidth=’auto’, method=’fir’, iir_params=None, phase=’zero’, fir_window=’hamming’, verbose=None)[source]

Create a FIR or IIR filter.

l_freq and h_freq are the frequencies below which and above which, respectively, to filter out of the data. Thus the uses are:

  • l_freq < h_freq: band-pass filter
  • l_freq > h_freq: band-stop filter
  • l_freq is not None and h_freq is None: high-pass filter
  • l_freq is None and h_freq is not None: low-pass filter
Parameters:

data : ndarray, shape (…, n_times)

The data that will be filtered. This is used for sanity checking only.

sfreq : float

The sample frequency in Hz.

l_freq : float | None

Low cut-off frequency in Hz. If None the data are only low-passed.

h_freq : float | None

High cut-off frequency in Hz. If None the data are only high-passed.

filter_length : str | int

Length of the FIR filter to use (if applicable):

  • int: specified length in samples.
  • ‘auto’ (default): the filter length is chosen based on the size of the transition regions (6.6 times the reciprocal of the shortest transition band for fir_window=’hamming’).
  • str: a human-readable time in units of “s” or “ms” (e.g., “10s” or “5500ms”) will be converted to that number of samples if phase="zero", or the shortest power-of-two length at least that duration for phase="zero-double".

l_trans_bandwidth : float | str

Width of the transition band at the low cut-off frequency in Hz (high pass or cutoff 1 in bandpass). Can be “auto” (default) to use a multiple of l_freq:

min(max(l_freq * 0.25, 2), l_freq)

Only used for method='fir'.

h_trans_bandwidth : float | str

Width of the transition band at the high cut-off frequency in Hz (low pass or cutoff 2 in bandpass). Can be “auto” (default in 0.14) to use a multiple of h_freq:

min(max(h_freq * 0.25, 2.), info['sfreq'] / 2. - h_freq)

Only used for method='fir'.

method : str

‘fir’ will use overlap-add FIR filtering, ‘iir’ will use IIR forward-backward filtering (via filtfilt).

iir_params : dict | None

Dictionary of parameters to use for IIR filtering. See mne.filter.construct_iir_filter for details. If iir_params is None and method=”iir”, 4th order Butterworth will be used.

phase : str

Phase of the filter, only used if method='fir'. By default, a symmetric linear-phase FIR filter is constructed. If phase='zero' (default), the delay of this filter is compensated for. If phase=='zero-double', then this filter is applied twice, once forward, and once backward. If ‘minimum’, then a minimum-phase, causal filter will be used.

New in version 0.13.

fir_window : str

The window to use in FIR design, can be “hamming” (default), “hann”, or “blackman”.

New in version 0.13.

verbose : bool, str, int, or None

If not None, override default verbose level (see mne.verbose() and Logging documentation for more). Defaults to self.verbose.
Returns:

filt : array or dict

Will be an array of FIR coefficients for method=’fir’, and dict with IIR parameters for method=’iir’.

See also

filter_data

Notes

Band-pass filter

The frequency response is (approximately) given by:

  1-|               ----------
    |             /|         | \
|H| |            / |         |  \
    |           /  |         |   \
    |          /   |         |    \
  0-|----------    |         |     --------------
    |         |    |         |     |            |
    0        Fs1  Fp1       Fp2   Fs2          Nyq

Where:

  • Fs1 = Fp1 - l_trans_bandwidth in Hz
  • Fs2 = Fp2 + h_trans_bandwidth in Hz

Band-stop filter

The frequency response is (approximately) given by:

  1-|---------                   ----------
    |         \                 /
|H| |          \               /
    |           \             /
    |            \           /
  0-|             -----------
    |        |    |         |    |        |
    0       Fp1  Fs1       Fs2  Fp2      Nyq

Where Fs1 = Fp1 + l_trans_bandwidth and Fs2 = Fp2 - h_trans_bandwidth.

Multiple stop bands can be specified using arrays.

Low-pass filter

The frequency response is (approximately) given by:

  1-|------------------------
    |                        \
|H| |                         \
    |                          \
    |                           \
  0-|                            ----------------
    |                       |    |              |
    0                      Fp  Fstop           Nyq

Where Fstop = Fp + trans_bandwidth.

High-pass filter

The frequency response is (approximately) given by:

  1-|             -----------------------
    |            /
|H| |           /
    |          /
    |         /
  0-|---------
    |        |    |                     |
    0      Fstop  Fp                   Nyq

Where Fstop = Fp - trans_bandwidth.

New in version 0.14.

Examples using mne.filter.create_filter